trusty-mpm 1.0.2

//! Unit tests for the trusty-mpm MCP dispatch layer (#1221 + earlier phases).
//!
//! Why: extracting the test module out of `mcp/mod.rs` keeps that production
//! file under the 500-SLOC cap while the tests (classified as a test file, 1500
//! cap) live alongside it. Included via `#[path = "tests.rs"] mod tests;`.
//! What: a `MockBackend` implementing every `OrchestratorBackend` method plus
//! dispatch tests for the handshake, the core tools, the bug-reporting tools,
//! and the nine session-lifecycle tools (seven per-session #1221 + #2012 ops +
//! the two fleet-wide #1508 teardown verbs).
//! Test: this IS the test module.

use super::*;

/// In-memory backend that records calls and returns canned values.
struct MockBackend;

#[async_trait]
impl OrchestratorBackend for MockBackend {
    async fn session_list(&self) -> Result<Value, String> {
        Ok(json!([{ "id": "s1", "status": "active" }]))
    }
    async fn session_status(&self, session_id: &str) -> Result<Value, String> {
        Ok(json!({ "id": session_id, "status": "active" }))
    }
    async fn agent_delegate(
        &self,
        _session_id: &str,
        agent: &str,
        _task: &str,
        _tier: Option<&str>,
    ) -> Result<Value, String> {
        Ok(json!({ "delegation_id": "d1", "agent": agent }))
    }
    async fn memory_protect(
        &self,
        _session_id: &str,
        used_tokens: u64,
        window_tokens: u64,
    ) -> Result<Value, String> {
        Ok(json!({ "fraction": used_tokens as f64 / window_tokens as f64 }))
    }
    async fn circuit_breaker_status(&self, _agent: Option<&str>) -> Result<Value, String> {
        Ok(json!({ "state": "closed" }))
    }
    async fn hook_event(
        &self,
        _session_id: &str,
        event: &str,
        _payload: Value,
    ) -> Result<Value, String> {
        Ok(json!({ "received": event }))
    }
    async fn list_recent_errors(&self, limit: u64) -> Result<Value, String> {
        Ok(json!({ "errors": [], "limit": limit, "total": 0 }))
    }
    async fn preview_bug_report(&self, fingerprint: &str) -> Result<Value, String> {
        Ok(json!({ "fingerprint": fingerprint, "title": "mock title", "body": "mock body" }))
    }
    async fn report_bug(&self, fingerprint: &str, confirm: bool) -> Result<Value, String> {
        if confirm {
            Ok(json!({ "filed": false, "note": "mock: no token in test" }))
        } else {
            Ok(
                json!({ "filed": false, "note": "confirm:false — preview only", "fingerprint": fingerprint }),
            )
        }
    }

    // ── #1221: session-lifecycle mock impls ──────────────────────────────
    async fn session_new(
        &self,
        repo_url: &str,
        git_ref: &str,
        _task: &str,
        _name_hint: Option<&str>,
        runtime: Option<&str>,
        ephemeral: Option<bool>,
    ) -> Result<Value, String> {
        Ok(json!({
            "id": "m-1",
            "repo_url": repo_url,
            "branch": git_ref,
            "runtime": runtime.unwrap_or("claude-code"),
            "ephemeral": ephemeral.unwrap_or(false),
            "state": "active",
        }))
    }
    async fn session_stop(&self, session_id: &str) -> Result<Value, String> {
        Ok(json!({ "id": session_id, "state": "stopped" }))
    }
    async fn session_resume(&self, session_id: &str) -> Result<Value, String> {
        Ok(json!({ "id": session_id, "state": "active" }))
    }
    async fn session_decommission(&self, session_id: &str) -> Result<Value, String> {
        Ok(json!({ "id": session_id, "state": "decommissioned" }))
    }
    async fn session_delete(&self, session_id: &str, force: bool) -> Result<Value, String> {
        // Mirror the real fail-closed contract: a non-forced delete of the
        // sentinel "running-id" is refused, exercising the dispatch-level test.
        if !force && session_id == "running-id" {
            return Err(format!(
                "session is active — stop it first, or pass --force ({session_id})"
            ));
        }
        Ok(json!({ "id": session_id, "state": "stopped", "deleted": true }))
    }
    async fn session_activity(&self, session_id: &str, lines: u32) -> Result<Value, String> {
        Ok(json!({ "id": session_id, "lines": lines, "raw_pane": "" }))
    }
    async fn session_send(&self, session_id: &str, text: &str) -> Result<Value, String> {
        Ok(json!({ "id": session_id, "sent": true, "text": text }))
    }

    // ── PM pause/resume context mock impls ───────────────────────────────────
    async fn session_context_catchup(
        &self,
        project_dir: &str,
        session_id: Option<&str>,
        all_projects: bool,
        full: bool,
    ) -> Result<Value, String> {
        Ok(json!({
            "sessions": [],
            "recent_commits": [],
            "recent_memory": [],
            "resolved_snapshot": null,
            "watermark_advanced": false,
            "project_dir": project_dir,
            "session_id": session_id,
            "all_projects": all_projects,
            "full": full,
        }))
    }
    async fn session_context_pause(
        &self,
        project_dir: &str,
        session_id: &str,
        summary: &str,
        completed: Vec<String>,
        in_progress: Vec<String>,
        next_steps: Vec<String>,
        tmux_window: Option<&str>,
        prune_worktrees: bool,
    ) -> Result<Value, String> {
        Ok(json!({
            "snapshot_path": format!("{project_dir}/.trusty-mpm/sessions/session-mock.md"),
            "timestamp": "2026-07-20T00:00:00Z",
            "pruned_worktrees": [],
            "session_id": session_id,
            "summary": summary,
            "completed": completed,
            "in_progress": in_progress,
            "next_steps": next_steps,
            "tmux_window": tmux_window,
            "prune_worktrees": prune_worktrees,
        }))
    }

    // ── #1508: fleet-wide teardown mock impls ────────────────────────────────
    async fn session_decommission_ephemeral(&self) -> Result<Value, String> {
        Ok(json!({ "decommissioned": 3 }))
    }
    async fn session_prune(
        &self,
        state: &str,
        dry_run: bool,
        include_active: bool,
    ) -> Result<Value, String> {
        // Mirror the real engine's contract: reject an unknown filter spelling so
        // the dispatch-level "rejects bad state" test exercises the error path.
        crate::session_manager::PruneFilter::parse(state)?;
        Ok(json!({
            "dry_run": dry_run,
            "filter": state,
            "include_active": include_active,
            "sessions": [],
        }))
    }

    // ── #1222: console-facing mock impls ─────────────────────────────────────
    async fn console_metrics(&self) -> Result<Value, String> {
        Ok(json!({
            "service_id": "trusty-mpm",
            "display_name": "Trusty MPM",
            "version": "0.0.0",
            "status": "ok",
            "metrics": { "fleet": { "active": 0 }, "auto_resume": { "desired": false } },
            "metrics_schema_version": 1,
        }))
    }
    async fn supervisor_status(&self) -> Result<Value, String> {
        Ok(json!({
            "fleet": { "active": 0, "stopped": 0, "total": 0 },
            "auto_resume": { "desired": false, "env": false, "pending_restart": false },
        }))
    }
    async fn auto_resume_set(&self, enabled: bool) -> Result<Value, String> {
        Ok(json!({ "desired": enabled, "env": false, "pending_restart": enabled }))
    }

    // ── #1220: config-convention mock impls ──────────────────────────────────
    async fn config_read(&self) -> Result<Value, String> {
        Ok(json!({
            "workspace_root_template": null,
            "auto_resume": null,
            "default_model": null,
            "workspace_root": "/home/test/trusty-mpm-projects",
        }))
    }
    #[allow(clippy::too_many_arguments)]
    async fn config_write(
        &self,
        workspace_root_template: Option<&str>,
        auto_resume: Option<bool>,
        default_model: Option<&str>,
        project_name: Option<&str>,
        github_config_dir: Option<&str>,
        _github_token_env: Option<&str>,
        _github_account: Option<&str>,
        _github_host: Option<&str>,
        commit_name: Option<&str>,
        _commit_email: Option<&str>,
        untracked_sync_patterns: Option<Vec<String>>,
        untracked_sync_enabled: Option<bool>,
    ) -> Result<Value, String> {
        Ok(json!({
            "workspace_root_template": workspace_root_template,
            "auto_resume": auto_resume,
            "default_model": default_model,
            "workspace_root": workspace_root_template.unwrap_or("/home/test/trusty-mpm-projects"),
            "project_name": project_name,
            "github_config_dir": github_config_dir,
            "commit_name": commit_name,
            "untracked_sync_patterns": untracked_sync_patterns,
            "untracked_sync_enabled": untracked_sync_enabled,
        }))
    }

    // ── #1519 WI-2: project-registry mock impls ───────────────────────────────
    async fn project_list(&self) -> Result<Value, String> {
        Ok(json!({
            "projects": [
                { "name": "trusty-tools", "repo_url": "https://github.com/o/trusty-tools", "default_branch": "main" }
            ],
            "count": 1,
        }))
    }
    async fn project_register(
        &self,
        name: &str,
        repo_url: &str,
        default_branch: Option<&str>,
        stack_hint: Option<&str>,
        tags: Option<Vec<String>>,
        description: Option<&str>,
        gh_user: Option<&str>,
        gh_account: Option<&str>,
    ) -> Result<Value, String> {
        Ok(json!({
            "name": name,
            "repo_url": repo_url,
            "default_branch": default_branch.unwrap_or("main"),
            "stack_hint": stack_hint,
            "tags": tags.unwrap_or_default(),
            "description": description,
            "gh_user": gh_user,
            "gh_account": gh_account,
        }))
    }
    async fn project_get(&self, name: &str) -> Result<Value, String> {
        if name == "trusty-tools" {
            Ok(json!({
                "name": "trusty-tools",
                "repo_url": "https://github.com/o/trusty-tools",
                "default_branch": "main",
            }))
        } else {
            Err(format!("project `{name}` not found"))
        }
    }

    // ── #2550: session-manager proxy mock impls ──────────────────────────────
    // Each echoes its parsed args so the dispatch tests can assert the tool name
    // routed to the right method with correctly-parsed arguments.
    async fn session_proxy_focus(
        &self,
        conversation_key: &str,
        session_id: &str,
    ) -> Result<Value, String> {
        Ok(json!({
            "outcome": "focused",
            "conversation_key": conversation_key,
            "session_id": session_id,
        }))
    }
    async fn session_proxy_unfocus(&self, conversation_key: &str) -> Result<Value, String> {
        Ok(json!({ "cleared": { "conversation_key": conversation_key } }))
    }
    async fn session_proxy_message(
        &self,
        conversation_key: &str,
        text: &str,
    ) -> Result<Value, String> {
        Ok(json!({
            "outcome": "sent",
            "conversation_key": conversation_key,
            "text": text,
        }))
    }
    async fn session_proxy_summary(&self, conversation_key: &str) -> Result<Value, String> {
        Ok(json!({ "outcome": "summary", "conversation_key": conversation_key }))
    }

    // ── #1517 WI-5: NL→repo resolver mock impl ───────────────────────────────
    async fn project_resolve(&self, query: &str) -> Result<Value, String> {
        if query == "trusty-tools" {
            Ok(json!({
                "primary": {
                    "project": {
                        "name": "trusty-tools",
                        "repo_url": "https://github.com/o/trusty-tools",
                        "default_branch": "main",
                    },
                    "confidence": 1.0,
                    "reason": "exact name match",
                },
                "needs_disambiguation": false,
                "matches": [{
                    "project": {
                        "name": "trusty-tools",
                        "repo_url": "https://github.com/o/trusty-tools",
                        "default_branch": "main",
                    },
                    "confidence": 1.0,
                    "reason": "exact name match",
                }],
            }))
        } else {
            Ok(json!({
                "primary": null,
                "needs_disambiguation": false,
                "matches": [],
                "error": format!("no project matched query: {query:?}"),
            }))
        }
    }
}

fn call(name: &str, args: Value) -> Request {
    Request {
        jsonrpc: Some("2.0".into()),
        id: Some(json!(1)),
        method: "tools/call".into(),
        params: Some(json!({ "name": name, "arguments": args })),
    }
}

#[tokio::test]
async fn dispatch_initialize_returns_server_info() {
    let req = Request {
        jsonrpc: Some("2.0".into()),
        id: Some(json!(1)),
        method: "initialize".into(),
        params: None,
    };
    let resp = dispatch(&MockBackend, req).await;
    let result = resp.result.unwrap();
    assert_eq!(result["serverInfo"]["name"], SERVER_NAME);
}

#[tokio::test]
async fn dispatch_tools_list_returns_full_catalog() {
    // 9 core + 11 session-lifecycle + 5 console + 4 project + 4 proxy = 33
    // (#1222 + the two #1220 config tools + the two #1508 fleet-teardown tools
    // + #2012 session_delete + the three #1519 project-registry tools + #1517
    // WI-5 project_resolve + the four #2550 session-manager proxy tools + the
    // two PM pause/resume context tools `session_context_catchup` /
    // `session_context_pause`).
    let req = Request {
        jsonrpc: Some("2.0".into()),
        id: Some(json!(1)),
        method: "tools/list".into(),
        params: None,
    };
    let resp = dispatch(&MockBackend, req).await;
    let tools = resp.result.unwrap()["tools"].clone();
    assert_eq!(tools.as_array().unwrap().len(), 33);
}

/// Why: the console Config tab calls `config_read`; dispatch must route it and
/// return a non-error result carrying the resolved `workspace_root`.
/// Test: this test.
#[tokio::test]
async fn dispatch_config_read_tool() {
    let resp = dispatch(&MockBackend, call("config_read", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("workspace_root")
    );
}

/// Why: the Config tab's save calls `config_write`; dispatch must parse the
/// optional fields and route them, echoing the persisted value.
/// Test: this test.
#[tokio::test]
async fn dispatch_config_write_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "config_write",
            json!({ "workspace_root_template": "~/custom-projects" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("custom-projects")
    );
}

/// Why: the console poller calls `console_metrics`; dispatch must route it to the
/// backend and return a non-error result carrying the report.
/// Test: this test.
#[tokio::test]
async fn dispatch_console_metrics_tool() {
    let resp = dispatch(&MockBackend, call("console_metrics", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("trusty-mpm")
    );
}

/// Why: the supervisor widget calls `supervisor_status`; dispatch must route it.
/// Test: this test.
#[tokio::test]
async fn dispatch_supervisor_status_tool() {
    let resp = dispatch(&MockBackend, call("supervisor_status", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("fleet")
    );
}

/// Why: the auto-resume toggle calls `auto_resume_set` with `enabled`; dispatch
/// must parse the bool and route it.
/// Test: this test.
#[tokio::test]
async fn dispatch_auto_resume_set_tool() {
    let resp = dispatch(
        &MockBackend,
        call("auto_resume_set", json!({ "enabled": true })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("desired")
    );
}

/// Why: `auto_resume_set` must reject a call missing the required `enabled` bool.
/// Test: this test.
#[tokio::test]
async fn dispatch_auto_resume_set_requires_enabled() {
    let resp = dispatch(&MockBackend, call("auto_resume_set", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("enabled")
    );
}

#[tokio::test]
async fn dispatch_session_list_tool() {
    let resp = dispatch(&MockBackend, call("session_list", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("s1")
    );
}

#[tokio::test]
async fn dispatch_agent_delegate_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "agent_delegate",
            json!({ "session_id": "s1", "agent": "research", "task": "find" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("research")
    );
}

#[tokio::test]
async fn dispatch_missing_argument_is_tool_error() {
    // `session_id` is required; omitting it yields an isError result.
    let resp = dispatch(&MockBackend, call("session_status", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("session_id")
    );
}

#[tokio::test]
async fn dispatch_unknown_tool_is_error() {
    let resp = dispatch(&MockBackend, call("nope", json!({}))).await;
    assert_eq!(resp.result.unwrap()["isError"], true);
}

#[tokio::test]
async fn dispatch_unknown_method_returns_jsonrpc_error() {
    let req = Request {
        jsonrpc: Some("2.0".into()),
        id: Some(json!(1)),
        method: "frobnicate".into(),
        params: None,
    };
    let resp = dispatch(&MockBackend, req).await;
    assert_eq!(resp.error.unwrap().code, error_codes::METHOD_NOT_FOUND);
}

#[tokio::test]
async fn dispatch_notification_is_suppressed() {
    let req = Request {
        jsonrpc: Some("2.0".into()),
        id: None,
        method: "notifications/initialized".into(),
        params: None,
    };
    let resp = dispatch(&MockBackend, req).await;
    assert!(resp.suppress);
}

// ── Phase 3: bug-reporting dispatch tests ─────────────────────────────────

#[tokio::test]
async fn dispatch_list_recent_errors_tool() {
    let resp = dispatch(
        &MockBackend,
        call("list_recent_errors", json!({ "limit": 10 })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("errors")
    );
}

#[tokio::test]
async fn dispatch_list_recent_errors_default_limit() {
    // No limit specified — should default to 20 without error.
    let resp = dispatch(&MockBackend, call("list_recent_errors", json!({}))).await;
    assert_eq!(resp.result.unwrap()["isError"], false);
}

#[tokio::test]
async fn dispatch_preview_bug_report_tool() {
    let fp = "a".repeat(64);
    let resp = dispatch(
        &MockBackend,
        call("preview_bug_report", json!({ "fingerprint": fp })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(result["content"][0]["text"].as_str().unwrap().contains(&fp));
}

#[tokio::test]
async fn dispatch_preview_bug_report_requires_fingerprint() {
    let resp = dispatch(&MockBackend, call("preview_bug_report", json!({}))).await;
    assert_eq!(resp.result.unwrap()["isError"], true);
}

#[tokio::test]
async fn dispatch_report_bug_no_confirm_is_preview_only() {
    let fp = "b".repeat(64);
    let resp = dispatch(
        &MockBackend,
        call("report_bug", json!({ "fingerprint": fp, "confirm": false })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    // The mock returns `filed: false` with the preview-only note.
    assert!(text.contains("false"), "expected filed:false: {text}");
}

#[tokio::test]
async fn dispatch_report_bug_confirm_true_calls_backend() {
    let fp = "c".repeat(64);
    let resp = dispatch(
        &MockBackend,
        call("report_bug", json!({ "fingerprint": fp, "confirm": true })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    // Mock returns filed:false + no-token note (still a valid response shape).
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(text.contains("filed"), "expected 'filed' key: {text}");
}

// ── #1221: session-lifecycle dispatch tests ───────────────────────────────

/// Why: `session_new` is the spawn tool; it must parse the three required
/// fields and forward them to the backend.
/// What: calls the tool with repo/ref/task and asserts a non-error result
/// echoing the repo url.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_new_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_new",
            json!({ "repo_url": "https://example.com/r.git", "ref": "main", "task": "do it" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("example.com")
    );
}

/// Why: `session_new` must reject a call missing the required `repo_url`.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_new_requires_repo_url() {
    let resp = dispatch(
        &MockBackend,
        call("session_new", json!({ "ref": "main", "task": "x" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("repo_url")
    );
}

/// Why: the single-id session tools must each parse `session_id` and forward
/// it; one parameterised test covers stop/resume/decommission/delete.
/// Test: this test.
#[tokio::test]
async fn dispatch_single_id_session_tools() {
    for tool in [
        "session_stop",
        "session_resume",
        "session_decommission",
        "session_delete",
    ] {
        let resp = dispatch(&MockBackend, call(tool, json!({ "session_id": "s9" }))).await;
        let result = resp.result.unwrap();
        assert_eq!(result["isError"], false, "{tool} should succeed");
        assert!(
            result["content"][0]["text"]
                .as_str()
                .unwrap()
                .contains("s9"),
            "{tool} should echo the id"
        );
    }
}

/// Why: a single-id session tool must error when `session_id` is absent.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_stop_requires_id() {
    let resp = dispatch(&MockBackend, call("session_stop", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("session_id")
    );
}

/// Why: `session_activity` must honour an explicit `lines` value.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_activity_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_activity",
            json!({ "session_id": "s1", "lines": 25 }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("25"),
        "should reflect the requested line count"
    );
}

/// Why: `session_activity` must default `lines` to 60 when omitted (parity
/// with the HTTP activity route).
/// Test: this test.
#[tokio::test]
async fn dispatch_session_activity_default_lines() {
    let resp = dispatch(
        &MockBackend,
        call("session_activity", json!({ "session_id": "s1" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("60"),
        "should default to 60 lines"
    );
}

/// Why: `session_send` requires both `session_id` and `text`.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_send_tool() {
    let resp = dispatch(
        &MockBackend,
        call("session_send", json!({ "session_id": "s1", "text": "yes" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("yes")
    );
}

/// Why: `session_send` must error when `text` is missing.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_send_requires_text() {
    let resp = dispatch(
        &MockBackend,
        call("session_send", json!({ "session_id": "s1" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("text")
    );
}

/// Why: `session_context_catchup` requires `project_dir` — the stdio bridge
/// forwards no cwd, so a missing `project_dir` must be a clear dispatch-level
/// error, not a downstream panic.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_context_catchup_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_context_catchup",
            json!({ "project_dir": "/tmp/proj", "full": true }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("watermark_advanced")
    );
}

#[tokio::test]
async fn dispatch_session_context_catchup_requires_project_dir() {
    let resp = dispatch(&MockBackend, call("session_context_catchup", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("project_dir")
    );
}

/// Why: `session_context_pause` requires `project_dir`/`session_id`/`summary`;
/// the optional bullet-list sections and `prune_worktrees` must round-trip
/// through dispatch to the backend.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_context_pause_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_context_pause",
            json!({
                "project_dir": "/tmp/proj",
                "session_id": "s1",
                "summary": "Did the thing.",
                "next_steps": ["ship it"],
                "prune_worktrees": false,
            }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(text.contains("snapshot_path"));
    assert!(text.contains("ship it"));
    assert!(text.contains("\"prune_worktrees\":false"));
}

#[tokio::test]
async fn dispatch_session_context_pause_requires_summary() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_context_pause",
            json!({ "project_dir": "/tmp/proj", "session_id": "s1" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("summary")
    );
}

/// Why (#2012): `session_delete` must default `force` to `false` — a call that
/// omits it must be refused for the mock's "running" sentinel id, proving the
/// dispatch layer's fail-closed default reaches the backend (not just an
/// internal manager-layer default).
/// Test: this test.
#[tokio::test]
async fn dispatch_session_delete_defaults_force_false() {
    let resp = dispatch(
        &MockBackend,
        call("session_delete", json!({ "session_id": "running-id" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true, "must refuse without --force");
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("running-id")
    );
}

/// Why (#2012): `force: true` must reach the backend and bypass the mock's
/// running-session refusal, proving the dispatch layer threads the optional
/// `force` argument through to `OrchestratorBackend::session_delete`.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_delete_force_bypasses_guard() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_delete",
            json!({ "session_id": "running-id", "force": true }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false, "force:true must bypass refusal");
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("\"deleted\":true")
    );
}

/// Why (#1508): the fleet-wide `session_decommission_ephemeral` tool takes no
/// args and must route to the backend, returning the `decommissioned` count.
/// This is the dispatch wiring that was missing — the descriptor was in the
/// catalog but `try_dispatch` had no arm, so the tool returned "unknown tool".
/// Test: this test.
#[tokio::test]
async fn dispatch_session_decommission_ephemeral_tool() {
    let resp = dispatch(
        &MockBackend,
        call("session_decommission_ephemeral", json!({})),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("decommissioned")
    );
}

/// Why (#1508): `session_prune` must route its `state`/`dry_run`/`include_active`
/// args to the backend and surface the `PruneOutcome` JSON.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_prune_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_prune",
            json!({ "state": "ephemeral", "dry_run": true }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("ephemeral")
    );
}

/// Why (#1508): `session_prune` must reject an unknown `state` spelling with a
/// tool-error, mirroring the engine's `PruneFilter::parse` contract.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_prune_rejects_bad_state() {
    let resp = dispatch(
        &MockBackend,
        call("session_prune", json!({ "state": "garbage" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("unknown prune filter")
    );
}

/// Why (#1508): `session_prune` must error when the required `state` arg is missing.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_prune_requires_state() {
    let resp = dispatch(&MockBackend, call("session_prune", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("state")
    );
}

// ── #1519 WI-2: project-registry dispatch tests ───────────────────────────────

/// Why (#1519): `project_list` takes no args and must route to the backend,
/// returning the projects array.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_list_tool() {
    let resp = dispatch(&MockBackend, call("project_list", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(text.contains("projects"), "expected 'projects' in: {text}");
}

/// Why (#1519): `project_register` must accept `name` + `repo_url` (required)
/// and optional fields, and return the registered record.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_register_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "project_register",
            json!({
                "name": "my-repo",
                "repo_url": "https://github.com/o/my-repo",
                "default_branch": "develop",
                "stack_hint": "rust",
                "tags": ["backend"],
                "description": "a repo"
            }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(text.contains("my-repo"), "expected 'my-repo' in: {text}");
}

/// Why (#2081): `project_register` must accept the optional `gh_user` field
/// and thread it through to the registered record so operators can declare a
/// project's preferred `gh` account.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_register_accepts_gh_user() {
    let resp = dispatch(
        &MockBackend,
        call(
            "project_register",
            json!({
                "name": "my-repo",
                "repo_url": "https://github.com/o/my-repo",
                "gh_user": "bobmatnyc"
            }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(
        text.contains("bobmatnyc"),
        "expected 'bobmatnyc' in: {text}"
    );
}

/// Why (#3025): `project_register` must accept the optional `gh_account` field
/// (distinct from `gh_user`) and thread it through to the registered record
/// so operators can pin the account resolved into `GH_TOKEN`/`GH_USER` at
/// every session spawn/relaunch.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_register_accepts_gh_account() {
    let resp = dispatch(
        &MockBackend,
        call(
            "project_register",
            json!({
                "name": "my-repo",
                "repo_url": "https://github.com/o/my-repo",
                "gh_account": "bobmatnyc"
            }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(
        text.contains("bobmatnyc"),
        "expected 'bobmatnyc' in: {text}"
    );
}

/// Why (#1519): `project_register` must error when the required `name` arg is missing.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_register_requires_name() {
    let resp = dispatch(
        &MockBackend,
        call(
            "project_register",
            json!({ "repo_url": "https://github.com/o/repo" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("name")
    );
}

/// Why (#1519): `project_register` must error when the required `repo_url` arg is missing.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_register_requires_repo_url() {
    let resp = dispatch(
        &MockBackend,
        call("project_register", json!({ "name": "my-repo" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("repo_url")
    );
}

/// Why (#1519): `project_get` must return the project for a known name.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_get_tool() {
    let resp = dispatch(
        &MockBackend,
        call("project_get", json!({ "name": "trusty-tools" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(
        text.contains("trusty-tools"),
        "expected 'trusty-tools' in: {text}"
    );
}

/// Why (#1519): `project_get` must surface an error for an unknown project name.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_get_missing_name() {
    let resp = dispatch(
        &MockBackend,
        call("project_get", json!({ "name": "does-not-exist" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("not found")
    );
}

/// Why (#1519): `project_get` must error when the required `name` arg is missing.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_get_requires_name() {
    let resp = dispatch(&MockBackend, call("project_get", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("name")
    );
}

// ── #1517 WI-5: project_resolve dispatch tests ───────────────────────────────

/// Why (#1517 WI-5): `project_resolve` must route a matching query to the
/// backend and return a `primary` match with confidence and reason.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_resolve_tool() {
    let resp = dispatch(
        &MockBackend,
        call("project_resolve", json!({ "query": "trusty-tools" })),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(
        text.contains("trusty-tools"),
        "expected 'trusty-tools' in: {text}"
    );
    assert!(
        text.contains("confidence"),
        "expected 'confidence' field in: {text}"
    );
}

/// Why (#1517 WI-5): `project_resolve` must return a no-match response (not an
/// error) when the query does not match any project; the `primary` field must be
/// null and an `error` message must explain the failure.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_resolve_no_match() {
    let resp = dispatch(
        &MockBackend,
        call(
            "project_resolve",
            json!({ "query": "zzz-unregistered-xyz" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    // The resolver returns Ok with primary:null for no-match (not isError).
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    // Parse the JSON payload and assert the actual response shape.
    let payload: serde_json::Value = serde_json::from_str(text)
        .unwrap_or_else(|_| panic!("response text must be valid JSON, got: {text}"));
    assert_eq!(
        payload["primary"],
        serde_json::Value::Null,
        "primary must be null for a no-match response, got: {payload}"
    );
    let error_msg = payload["error"].as_str().unwrap_or_else(|| {
        panic!("no-match response must carry an 'error' explanation, got: {payload}")
    });
    assert!(
        error_msg.contains("zzz-unregistered-xyz"),
        "error message must include the query, got: {error_msg}"
    );
}

/// Why (#1517 WI-5): `project_resolve` must error at the dispatch layer when
/// the required `query` arg is absent.
/// Test: this test.
#[tokio::test]
async fn dispatch_project_resolve_requires_query() {
    let resp = dispatch(&MockBackend, call("project_resolve", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("query")
    );
}

// ── #2550: session-manager proxy dispatch tests ─────────────────────────────
//
// These assert the four proxy tool NAMES route through `proxy_dispatch` to the
// matching backend method with correctly-parsed arguments (the mock echoes its
// args). The real SessionProxy round-trip is covered hermetically in
// `daemon::mcp_proxy::tests`.

/// Why (#2550): `session_proxy_focus` must parse `conversation_key` + the
/// OPTIONAL `session_id` and route to the backend.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_proxy_focus_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_proxy_focus",
            json!({ "conversation_key": "conv-1", "session_id": "sess-abc" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(text.contains("conv-1"), "{text}");
    assert!(text.contains("sess-abc"), "{text}");
}

/// Why (#2550): `session_id` is optional — an absent value must still dispatch
/// (the empty-string current-focus query), not error.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_proxy_focus_session_id_optional() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_proxy_focus",
            json!({ "conversation_key": "conv-1" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false, "session_id must be optional");
}

/// Why (#2550): `conversation_key` is required on every proxy tool; a missing
/// key must surface as a tool error at the dispatch layer.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_proxy_focus_requires_conversation_key() {
    let resp = dispatch(&MockBackend, call("session_proxy_focus", json!({}))).await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("conversation_key")
    );
}

/// Why (#2550): `session_proxy_unfocus` routes on `conversation_key` alone.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_proxy_unfocus_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_proxy_unfocus",
            json!({ "conversation_key": "conv-9" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("conv-9")
    );
}

/// Why (#2550): `session_proxy_message` must parse both `conversation_key` and
/// the required `text` and route to the inject method.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_proxy_message_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_proxy_message",
            json!({ "conversation_key": "conv-2", "text": "run the tests" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(text.contains("conv-2"), "{text}");
    assert!(text.contains("run the tests"), "{text}");
}

/// Why (#2550): `session_proxy_message` requires `text`; a missing body must
/// error at the dispatch layer.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_proxy_message_requires_text() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_proxy_message",
            json!({ "conversation_key": "conv-2" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], true);
    assert!(
        result["content"][0]["text"]
            .as_str()
            .unwrap()
            .contains("text")
    );
}

/// Why (#2550): `session_proxy_summary` routes on `conversation_key` alone.
/// Test: this test.
#[tokio::test]
async fn dispatch_session_proxy_summary_tool() {
    let resp = dispatch(
        &MockBackend,
        call(
            "session_proxy_summary",
            json!({ "conversation_key": "conv-3" }),
        ),
    )
    .await;
    let result = resp.result.unwrap();
    assert_eq!(result["isError"], false);
    let text = result["content"][0]["text"].as_str().unwrap();
    assert!(text.contains("summary"), "{text}");
    assert!(text.contains("conv-3"), "{text}");
}