Story 52: Mergemaster agent role with merge_agent_work MCP tool

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

server/src/http/mcp.rs

@@ -1,4 +1,4 @@
-use crate::agents::move_story_to_archived;
+use crate::agents::{close_bug_to_archive, move_story_to_archived, move_story_to_merge};
 use crate::config::ProjectConfig;
 use crate::http::context::AppContext;
 use crate::http::settings::get_editor_command_from_store;
@@ -6,7 +6,6 @@ use crate::http::workflow::{
     check_criterion_in_file, create_bug_file, create_story_file, list_bug_files,
     load_upcoming_stories, set_test_plan_in_file, validate_story_dirs,
 };
-use crate::agents::close_bug_to_archive;
 use crate::worktree;
 use crate::io::story_metadata::{parse_front_matter, parse_unchecked_todos};
 use crate::workflow::{evaluate_acceptance_with_coverage, TestCaseResult, TestStatus};
@@ -711,6 +710,38 @@ fn handle_tools_list(id: Option<Value>) -> JsonRpcResponse {
                         },
                         "required": ["bug_id"]
                     }
+                },
+                {
+                    "name": "merge_agent_work",
+                    "description": "Trigger the mergemaster pipeline for a completed story: squash-merge the feature branch into master, run quality gates (cargo clippy, cargo test, pnpm build, pnpm test), archive the story from work/4_merge/ or work/2_current/ to work/5_archived/, and clean up the worktree and branch. Reports success/failure with details including any conflicts found and gate output.",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "story_id": {
+                                "type": "string",
+                                "description": "Story identifier (e.g. '52_story_mergemaster_agent_role')"
+                            },
+                            "agent_name": {
+                                "type": "string",
+                                "description": "Optional: name of the coder agent whose work is being merged (for logging)"
+                            }
+                        },
+                        "required": ["story_id"]
+                    }
+                },
+                {
+                    "name": "move_story_to_merge",
+                    "description": "Move a story or bug from work/2_current/ to work/4_merge/ to queue it for the mergemaster pipeline. Auto-commits to master.",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "story_id": {
+                                "type": "string",
+                                "description": "Story identifier (filename stem, e.g. '28_my_story')"
+                            }
+                        },
+                        "required": ["story_id"]
+                    }
                 }
             ]
         }),
@@ -763,6 +794,9 @@ async fn handle_tools_call(
         "create_bug" => tool_create_bug(&args, ctx),
         "list_bugs" => tool_list_bugs(ctx),
         "close_bug" => tool_close_bug(&args, ctx),
+        // Mergemaster tools
+        "merge_agent_work" => tool_merge_agent_work(&args, ctx).await,
+        "move_story_to_merge" => tool_move_story_to_merge(&args, ctx),
         _ => Err(format!("Unknown tool: {tool_name}")),
     };
 
@@ -1275,6 +1309,57 @@ fn tool_close_bug(args: &Value, ctx: &AppContext) -> Result<String, String> {
     ))
 }
 
+// ── Mergemaster tool implementations ─────────────────────────────
+
+async fn tool_merge_agent_work(args: &Value, ctx: &AppContext) -> Result<String, String> {
+    let story_id = args
+        .get("story_id")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing required argument: story_id")?;
+    let agent_name = args.get("agent_name").and_then(|v| v.as_str());
+
+    let project_root = ctx.agents.get_project_root(&ctx.state)?;
+    let report = ctx.agents.merge_agent_work(&project_root, story_id).await?;
+
+    let status_msg = if report.success && report.gates_passed {
+        "Merge complete: all quality gates passed. Story archived and worktree cleaned up."
+    } else if report.had_conflicts {
+        "Merge failed: conflicts detected. Merge was aborted. Resolve conflicts manually and retry."
+    } else if report.success && !report.gates_passed {
+        "Merge committed but quality gates failed. Review gate_output and fix issues before re-running."
+    } else {
+        "Merge failed. Review gate_output for details."
+    };
+
+    serde_json::to_string_pretty(&json!({
+        "story_id": story_id,
+        "agent_name": agent_name,
+        "success": report.success,
+        "had_conflicts": report.had_conflicts,
+        "conflict_details": report.conflict_details,
+        "gates_passed": report.gates_passed,
+        "gate_output": report.gate_output,
+        "worktree_cleaned_up": report.worktree_cleaned_up,
+        "story_archived": report.story_archived,
+        "message": status_msg,
+    }))
+    .map_err(|e| format!("Serialization error: {e}"))
+}
+
+fn tool_move_story_to_merge(args: &Value, ctx: &AppContext) -> Result<String, String> {
+    let story_id = args
+        .get("story_id")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing required argument: story_id")?;
+
+    let project_root = ctx.agents.get_project_root(&ctx.state)?;
+    move_story_to_merge(&project_root, story_id)?;
+
+    Ok(format!(
+        "Story '{story_id}' moved to work/4_merge/ and committed. Ready for mergemaster."
+    ))
+}
+
 /// Run `git log <base>..HEAD --oneline` in the worktree and return the commit
 /// summaries, or `None` if git is unavailable or there are no new commits.
 async fn get_worktree_commits(worktree_path: &str, base_branch: &str) -> Option<Vec<String>> {
@@ -1432,7 +1517,9 @@ mod tests {
         assert!(names.contains(&"create_bug"));
         assert!(names.contains(&"list_bugs"));
         assert!(names.contains(&"close_bug"));
-        assert_eq!(tools.len(), 24);
+        assert!(names.contains(&"merge_agent_work"));
+        assert!(names.contains(&"move_story_to_merge"));
+        assert_eq!(tools.len(), 26);
     }
 
     #[test]
@@ -2021,4 +2108,104 @@ mod tests {
         assert!(!bug_file.exists());
         assert!(tmp.path().join(".story_kit/work/5_archived/1_bug_crash.md").exists());
     }
+
+    // ── Mergemaster tool tests ─────────────────────────────────────────────
+
+    #[test]
+    fn merge_agent_work_in_tools_list() {
+        let resp = handle_tools_list(Some(json!(1)));
+        let tools = resp.result.unwrap()["tools"].as_array().unwrap().clone();
+        let tool = tools.iter().find(|t| t["name"] == "merge_agent_work");
+        assert!(tool.is_some(), "merge_agent_work missing from tools list");
+        let t = tool.unwrap();
+        assert!(t["description"].is_string());
+        let required = t["inputSchema"]["required"].as_array().unwrap();
+        let req_names: Vec<&str> = required.iter().map(|v| v.as_str().unwrap()).collect();
+        assert!(req_names.contains(&"story_id"));
+        // agent_name is optional
+        assert!(!req_names.contains(&"agent_name"));
+    }
+
+    #[test]
+    fn move_story_to_merge_in_tools_list() {
+        let resp = handle_tools_list(Some(json!(1)));
+        let tools = resp.result.unwrap()["tools"].as_array().unwrap().clone();
+        let tool = tools.iter().find(|t| t["name"] == "move_story_to_merge");
+        assert!(tool.is_some(), "move_story_to_merge missing from tools list");
+        let t = tool.unwrap();
+        assert!(t["description"].is_string());
+        let required = t["inputSchema"]["required"].as_array().unwrap();
+        let req_names: Vec<&str> = required.iter().map(|v| v.as_str().unwrap()).collect();
+        assert!(req_names.contains(&"story_id"));
+    }
+
+    #[tokio::test]
+    async fn tool_merge_agent_work_missing_story_id() {
+        let tmp = tempfile::tempdir().unwrap();
+        let ctx = test_ctx(tmp.path());
+        let result = tool_merge_agent_work(&json!({}), &ctx).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("story_id"));
+    }
+
+    #[test]
+    fn tool_move_story_to_merge_missing_story_id() {
+        let tmp = tempfile::tempdir().unwrap();
+        let ctx = test_ctx(tmp.path());
+        let result = tool_move_story_to_merge(&json!({}), &ctx);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("story_id"));
+    }
+
+    #[test]
+    fn tool_move_story_to_merge_moves_file() {
+        let tmp = tempfile::tempdir().unwrap();
+        setup_git_repo_in(tmp.path());
+        let current_dir = tmp.path().join(".story_kit/work/2_current");
+        std::fs::create_dir_all(&current_dir).unwrap();
+        let story_file = current_dir.join("24_story_test.md");
+        std::fs::write(&story_file, "---\nname: Test\ntest_plan: approved\n---\n").unwrap();
+        std::process::Command::new("git")
+            .args(["add", "."])
+            .current_dir(tmp.path())
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["commit", "-m", "add story"])
+            .current_dir(tmp.path())
+            .output()
+            .unwrap();
+
+        let ctx = test_ctx(tmp.path());
+        let result = tool_move_story_to_merge(&json!({"story_id": "24_story_test"}), &ctx).unwrap();
+        assert!(result.contains("4_merge"));
+        assert!(!story_file.exists(), "2_current file should be gone");
+        assert!(
+            tmp.path().join(".story_kit/work/4_merge/24_story_test.md").exists(),
+            "4_merge file should exist"
+        );
+    }
+
+    #[tokio::test]
+    async fn tool_merge_agent_work_returns_coherent_report() {
+        let tmp = tempfile::tempdir().unwrap();
+        setup_git_repo_in(tmp.path());
+        let ctx = test_ctx(tmp.path());
+
+        // Try to merge a non-existent branch — should return a report (not panic)
+        let result = tool_merge_agent_work(
+            &json!({"story_id": "99_nonexistent", "agent_name": "coder-1"}),
+            &ctx,
+        )
+        .await
+        .unwrap();
+        let parsed: Value = serde_json::from_str(&result).unwrap();
+        assert_eq!(parsed["story_id"], "99_nonexistent");
+        assert_eq!(parsed["agent_name"], "coder-1");
+        assert!(parsed.get("success").is_some());
+        assert!(parsed.get("had_conflicts").is_some());
+        assert!(parsed.get("gates_passed").is_some());
+        assert!(parsed.get("gate_output").is_some());
+        assert!(parsed.get("message").is_some());
+    }
 }