storkit: merge 445_bug_rate_limited_mergemaster_exits_advance_stories_to_done_without_merging

2026-03-28 20:05:10 +00:00
parent 8e45b2a08d
commit 3048d26e66
2 changed files with 152 additions and 13 deletions
@@ -498,18 +498,63 @@ impl AgentPool {
                        }
                    }

-                    // Server-owned completion: run acceptance gates automatically
-                    // when the agent process exits normally.
-                    super::pipeline::run_server_owned_completion(
-                        &agents_ref,
-                        port_for_task,
-                        &sid,
-                        &aname,
-                        result.session_id,
-                        watcher_tx_clone.clone(),
-                    )
-                    .await;
-                    AgentPool::notify_agent_state_changed(&watcher_tx_clone);
+                    // Mergemaster agents have their own completion path via
+                    // start_merge_agent_work / run_merge_pipeline and must NOT go
+                    // through server-owned gates.  When a mergemaster exits early
+                    // (e.g. rate-limited before calling start_merge_agent_work) the
+                    // feature-branch worktree compiles fine and post-merge tests on
+                    // master pass (nothing changed), which would wrongly advance the
+                    // story to 5_done/ without any squash merge having occurred.
+                    // Instead: just remove the agent from the pool and let
+                    // auto-assign restart a new mergemaster for the story.
+                    let stage = config_clone
+                        .find_agent(&aname)
+                        .map(agent_config_stage)
+                        .unwrap_or_else(|| pipeline_stage(&aname));
+                    if stage == PipelineStage::Mergemaster {
+                        let (tx_done, done_session_id) = {
+                            let mut lock = match agents_ref.lock() {
+                                Ok(a) => a,
+                                Err(_) => return,
+                            };
+                            if let Some(agent) = lock.remove(&key_clone) {
+                                (agent.tx, agent.session_id.or(result.session_id))
+                            } else {
+                                (tx_clone.clone(), result.session_id)
+                            }
+                        };
+                        let _ = tx_done.send(AgentEvent::Done {
+                            story_id: sid.clone(),
+                            agent_name: aname.clone(),
+                            session_id: done_session_id,
+                        });
+                        AgentPool::notify_agent_state_changed(&watcher_tx_clone);
+                        // Send a WorkItem event so the auto-assign watcher loop
+                        // re-dispatches a new mergemaster if the story still needs
+                        // merging.  This avoids an async call to start_agent inside
+                        // a tokio::spawn (which would require Send).
+                        let _ = watcher_tx_clone.send(
+                            crate::io::watcher::WatcherEvent::WorkItem {
+                                stage: "4_merge".to_string(),
+                                item_id: sid.clone(),
+                                action: "reassign".to_string(),
+                                commit_msg: String::new(),
+                            },
+                        );
+                    } else {
+                        // Server-owned completion: run acceptance gates automatically
+                        // when the agent process exits normally.
+                        super::pipeline::run_server_owned_completion(
+                            &agents_ref,
+                            port_for_task,
+                            &sid,
+                            &aname,
+                            result.session_id,
+                            watcher_tx_clone.clone(),
+                        )
+                        .await;
+                        AgentPool::notify_agent_state_changed(&watcher_tx_clone);
+                    }
                }
                Err(e) => {
                    slog_error!("[agents] Agent process error for {aname} on {sid}: {e}");