huskies: merge 959

server/src/http/workflow/pipeline.rs

@@ -66,21 +66,14 @@ pub struct PipelineState {
     pub deterministic_merges_in_flight: Vec<String>,
 }
 
-/// Determine which pipeline bucket a frozen item's `resume_to` stage maps to.
+/// Unwrap nested `Stage::Frozen` layers to find the innermost resume target.
 ///
 /// Mirrors the routing in `load_pipeline_state` for non-frozen items so that
 /// a frozen story always appears under the same section it was in before freezing.
-fn frozen_resume_bucket(resume_to: &crate::pipeline_state::Stage) -> &'static str {
-    use crate::pipeline_state::Stage;
-    match resume_to {
-        Stage::Upcoming | Stage::Backlog => "backlog",
-        Stage::Coding | Stage::Blocked { .. } => "current",
-        Stage::Qa | Stage::ReviewHold { .. } => "qa",
-        Stage::Merge { .. } | Stage::MergeFailure { .. } | Stage::MergeFailureFinal { .. } => {
-            "merge"
-        }
-        Stage::Frozen { resume_to: inner } => frozen_resume_bucket(inner),
-        _ => "backlog", // Done, Archived → fall back to backlog (should not occur)
+fn unwrap_frozen(stage: &crate::pipeline_state::Stage) -> &crate::pipeline_state::Stage {
+    match stage {
+        crate::pipeline_state::Stage::Frozen { resume_to: inner } => unwrap_frozen(inner),
+        other => other,
     }
 }
 
@@ -182,10 +175,12 @@ pub fn load_pipeline_state(ctx: &AppContext) -> Result<PipelineState, String> {
             Stage::Frozen { resume_to } => {
                 // Route to the section matching the stage that was active when
                 // the item was frozen, so it appears in-place.
-                match frozen_resume_bucket(resume_to) {
-                    "current" => state.current.push(story),
-                    "qa" => state.qa.push(story),
-                    "merge" => state.merge.push(story),
+                match unwrap_frozen(resume_to) {
+                    Stage::Coding | Stage::Blocked { .. } => state.current.push(story),
+                    Stage::Qa | Stage::ReviewHold { .. } => state.qa.push(story),
+                    Stage::Merge { .. }
+                    | Stage::MergeFailure { .. }
+                    | Stage::MergeFailureFinal { .. } => state.merge.push(story),
                     _ => state.backlog.push(story),
                 }
             }