@team-agent/installer 0.2.10 → 0.3.0

package/crates/team-agent/src/cli/tests/repair_state_byte_lock.rs

@@ -0,0 +1,302 @@
+use super::*;
+
+const REPAIR_SPEC_TEMPLATE: &str = r#"version: 1
+team:
+  name: "repair-team"
+  mode: "supervisor_worker"
+  objective: "Exercise repair-state."
+  workspace: "__WS__"
+leader:
+  id: "leader"
+  role: "leader"
+  provider: "fake"
+  model: null
+  tools:
+    - "fs_read"
+    - "fs_list"
+    - "mcp_team"
+  context_policy:
+    keep_user_thread: true
+    receive_worker_outputs: "structured_only"
+    max_worker_result_tokens: 2000
+agents:
+  - id: "fake_impl"
+    role: "implementation_engineer"
+    provider: "fake"
+    model: null
+    working_directory: "__WS__"
+    system_prompt:
+      inline: "Handle fake implementation tasks."
+      file: null
+    tools:
+      - "fs_read"
+      - "mcp_team"
+    permission_mode: "restricted"
+    preferred_for:
+      - "implementation"
+    avoid_for: []
+    output_contract:
+      format: "result_envelope_v1"
+      required_fields:
+        - "task_id"
+        - "status"
+        - "summary"
+        - "artifacts"
+routing:
+  default_assignee: "leader"
+  rules:
+    - id: "implementation-to-fake"
+      match:
+        type:
+          - "implementation"
+      assign_to: "fake_impl"
+      priority: 10
+communication:
+  protocol: "mcp_inbox"
+  topology: "leader_centered"
+  worker_to_worker: true
+  ack_timeout_sec: 2
+  result_format: "result_envelope_v1"
+  message_store:
+    sqlite: ".team/runtime/team.db"
+    mirror_files: ".team/messages"
+runtime:
+  backend: "tmux"
+  display_backend: "none"
+  session_name: "team-agent-repair"
+  auto_launch: true
+  require_user_approval_before_launch: false
+  max_active_agents: 1
+  startup_order:
+    - "fake_impl"
+context:
+  state_file: "team_state.md"
+  artifact_dir: ".team/artifacts"
+  log_dir: ".team/logs"
+  summarization:
+    worker_full_logs: "retain_outside_leader_context"
+    state_update: "after_each_result"
+tasks:
+  - id: "task_impl"
+    title: "Fake implementation"
+    type: "implementation"
+    assignee: null
+    deps: []
+    acceptance:
+      - "fake result collected"
+    status: "pending"
+"#;
+
+fn seed_repair_workspace(ws: &std::path::Path) {
+    std::fs::create_dir_all(ws.join(".team").join("logs")).unwrap();
+    std::fs::create_dir_all(ws.join(".team").join("runtime")).unwrap();
+    let spec_path = ws.join("team.spec.yaml");
+    std::fs::write(
+        &spec_path,
+        REPAIR_SPEC_TEMPLATE.replace("__WS__", &ws.to_string_lossy()),
+    )
+    .unwrap();
+    crate::state::persist::save_runtime_state(
+        ws,
+        &json!({
+            "spec_path": spec_path.to_string_lossy(),
+            "session_name": "team-agent-repair",
+            "leader": {"id": "leader"},
+            "agents": {"fake_impl": {"status": "stopped", "provider": "fake"}},
+            "tasks": [{
+                "id": "task_impl",
+                "title": "Fake implementation",
+                "type": "implementation",
+                "assignee": null,
+                "deps": [],
+                "acceptance": ["fake result collected"],
+                "status": "pending"
+            }]
+        }),
+    )
+    .unwrap();
+}
+
+fn repair_args(
+    ws: &std::path::Path,
+    status: &str,
+    summary: Option<&str>,
+    json: bool,
+) -> RepairStateArgs {
+    RepairStateArgs {
+        workspace: ws.to_path_buf(),
+        task_id: "task_impl".to_string(),
+        assignee: Some("fake_impl".to_string()),
+        status: status.to_string(),
+        summary: summary.map(str::to_string),
+        json,
+    }
+}
+
+// Golden source:
+// - cli/parser.py:303-310 registers `repair-state --workspace --task --assignee --status --summary --json`.
+// - cli/commands.py:196-203 delegates all five args to `runtime.repair_state`.
+// - diagnose/quick_start.py:285-324:
+//   * loads state + spec, validates assignee against spec agents plus leader id,
+//   * validates status against task_graph.py TASK_STATUSES,
+//   * before/after are three-field projections `{assignee,status,last_result_summary}`,
+//   * summary writes `last_result_summary` (not `summary`),
+//   * writes EventLog event `repair_state.task` with task_id/before/after,
+//   * returns `{ok,task_id,before,after,state_file}` in that insertion order.
+// - task_graph.py:5-14 legal statuses are exactly:
+//   blocked,cancelled,done,failed,needs_retry,pending,ready,running.
+//
+// Golden probe:
+//   PYTHONPATH=/Users/alauda/Documents/code/team-agent-public/src python3 /tmp/probe_repair_state_cli.py
+#[test]
+fn repair_state_success_json_human_and_event_byte_shape() {
+    let ws = tmp_workspace();
+    seed_repair_workspace(&ws);
+
+    let json_result = cmd_repair_state(&repair_args(&ws, "done", Some("patched"), true))
+        .expect("repair-state success should return ok");
+    assert_eq!(json_result.exit, ExitCode::Ok);
+    assert_eq!(
+        emit(&json_result.output, true).unwrap(),
+        format!(
+            "{{\n  \"after\": {{\n    \"assignee\": \"fake_impl\",\n    \"last_result_summary\": \"patched\",\n    \"status\": \"done\"\n  }},\n  \"before\": {{\n    \"assignee\": null,\n    \"last_result_summary\": null,\n    \"status\": \"pending\"\n  }},\n  \"ok\": true,\n  \"state_file\": \"{}\",\n  \"task_id\": \"task_impl\"\n}}",
+            ws.join("team_state.md").to_string_lossy()
+        ),
+        "repair-state --json must match Python pretty sorted JSON byte shape",
+    );
+
+    let event_line = std::fs::read_to_string(ws.join(".team/logs/events.jsonl"))
+        .expect("repair-state must write events.jsonl")
+        .lines()
+        .last()
+        .expect("repair-state must append an event")
+        .to_string();
+    assert!(
+        event_line.starts_with("{\"after\": {\"assignee\": \"fake_impl\", \"last_result_summary\": \"patched\", \"status\": \"done\"}, \"before\": {\"assignee\": null, \"last_result_summary\": null, \"status\": \"pending\"}, \"event\": \"repair_state.task\", \"task_id\": \"task_impl\", \"ts\": \""),
+        "repair_state.task event must be Python sort_keys JSON with after/before/event/task_id/ts order; got {event_line}",
+    );
+    assert!(event_line.ends_with("\"}"), "event line must end with timestamp string; got {event_line}");
+
+    let ws_human = tmp_workspace();
+    seed_repair_workspace(&ws_human);
+    let human_result = cmd_repair_state(&repair_args(&ws_human, "done", Some("patched"), false))
+        .expect("repair-state human success should return ok");
+    assert_eq!(
+        emit(&human_result.output, false).unwrap(),
+        format!(
+            "ok: True\ntask_id: task_impl\nbefore: {{\"assignee\": null, \"status\": \"pending\", \"last_result_summary\": null}}\nafter: {{\"assignee\": \"fake_impl\", \"status\": \"done\", \"last_result_summary\": \"patched\"}}\nstate_file: {}",
+            ws_human.join("team_state.md").to_string_lossy()
+        ),
+        "repair-state human output must preserve Python returned-dict and nested-dict insertion order",
+    );
+
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    assert_eq!(
+        state["tasks"][0]["last_result_summary"],
+        json!("patched"),
+        "golden writes summary into last_result_summary, not summary",
+    );
+    assert!(
+        state["tasks"][0].get("summary").is_none(),
+        "golden does not create a task.summary field during repair-state",
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+    let _ = std::fs::remove_dir_all(&ws_human);
+}
+
+#[test]
+fn repair_state_rejects_status_outside_task_statuses() {
+    let ws = tmp_workspace();
+    seed_repair_workspace(&ws);
+    let legal_statuses = vec![
+        "blocked",
+        "cancelled",
+        "done",
+        "failed",
+        "needs_retry",
+        "pending",
+        "ready",
+        "running",
+    ];
+    assert_eq!(
+        legal_statuses,
+        vec![
+            "blocked",
+            "cancelled",
+            "done",
+            "failed",
+            "needs_retry",
+            "pending",
+            "ready",
+            "running"
+        ],
+        "golden TASK_STATUSES from task_graph.py:5 must stay locked",
+    );
+
+    let err = cmd_repair_state(&repair_args(&ws, "assigned", None, true))
+        .expect_err("status outside TASK_STATUSES must error");
+    assert_eq!(err.to_string(), "unknown task status for repair: assigned");
+    let payload = err.to_payload(&ws.join(".team/logs/cli-error-123.log"), "repair-state");
+    assert_eq!(
+        serde_json::to_string(&payload).unwrap(),
+        format!(
+            "{{\"ok\":false,\"error\":\"unknown task status for repair: assigned\",\"action\":\"run `team-agent doctor` or inspect the log path shown here\",\"log\":\"{}\"}}",
+            ws.join(".team/logs/cli-error-123.log").to_string_lossy()
+        ),
+        "repair-state --json error envelope must match Python compact key order and text",
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+// CONTRACT (real-machine repair_state product FAIL): rt-host-d ran `repair-state --task rp1 --status done`
+// in a quick-start workspace whose spec lives in a teamdir (state.spec_path -> <ws>/teamdir/team.spec.yaml),
+// NOT at <ws>/team.spec.yaml. Rust cmd_repair_state calls load_team_spec(workspace) which HARDCODES
+// workspace.join("team.spec.yaml") (adapters.rs:982) -> read_to_string fails 'No such file or directory'.
+// golden (quick_start.py:295) resolves spec_path = state.get("spec_path", workspace/"team.spec.yaml") and
+// SUCCEEDS. NB: golden ALSO writes team_state.md (write_team_state -> state.py mkdir+write) and returns
+// state_file=team_state.md, so the fix is NOT to drop write_team_state (that diverges from golden and breaks
+// repair_state_success_json_human_and_event_byte_shape) — it is to resolve the spec from state.spec_path
+// (Rust already has load_team_spec_optional(workspace, state) that does exactly this).
+#[test]
+fn contract_repair_state_resolves_spec_from_state_spec_path_teamdir_layout() {
+    let ws = tmp_workspace();
+    std::fs::create_dir_all(ws.join(".team").join("logs")).unwrap();
+    std::fs::create_dir_all(ws.join(".team").join("runtime")).unwrap();
+    let teamdir = ws.join("teamdir");
+    std::fs::create_dir_all(&teamdir).unwrap();
+    let spec_path = teamdir.join("team.spec.yaml");
+    std::fs::write(
+        &spec_path,
+        REPAIR_SPEC_TEMPLATE.replace("__WS__", &ws.to_string_lossy()),
+    )
+    .unwrap();
+    // NOTE: NO <ws>/team.spec.yaml (the hardcoded path) and NO pre-existing team_state.md.
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "spec_path": spec_path.to_string_lossy(),
+            "session_name": "team-agent-repair",
+            "leader": {"id": "leader"},
+            "agents": {"fake_impl": {"status": "running", "provider": "fake"}},
+            "tasks": [{
+                "id": "task_impl", "title": "x", "type": "implementation",
+                "assignee": null, "deps": [], "acceptance": ["a"], "status": "pending"
+            }]
+        }),
+    )
+    .unwrap();
+
+    let cmd = cmd_repair_state(&repair_args(&ws, "done", Some("patched"), true)).expect(
+        "CONTRACT: repair-state --status done must resolve the spec from state.spec_path (golden \
+         quick_start.py:295), not the hardcoded <ws>/team.spec.yaml (adapters.rs:982) which is absent in \
+         the teamdir layout -> currently io 'No such file or directory'",
+    );
+    assert_eq!(cmd.exit, ExitCode::Ok);
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    assert_eq!(
+        state["tasks"][0]["status"],
+        json!("done"),
+        "the task must persist status=done after repair"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}

package/crates/team-agent/src/cli/tests/run_delegation.rs

@@ -0,0 +1,305 @@
+use super::*;
+
+struct TeamSocketGuard {
+    ws: std::path::PathBuf,
+}
+
+impl Drop for TeamSocketGuard {
+    fn drop(&mut self) {
+        crate::tmux_backend::TmuxBackend::for_workspace(&self.ws).kill_server();
+        if let Some(uid) = current_uid() {
+            let socket = crate::tmux_backend::socket_name_for_workspace(&self.ws);
+            for root in ["/private/tmp", "/tmp"] {
+                let path = std::path::Path::new(root).join(format!("tmux-{uid}")).join(&socket);
+                let _ = std::fs::remove_file(path);
+            }
+        }
+    }
+}
+
+fn current_uid() -> Option<String> {
+    let output = std::process::Command::new("id").arg("-u").output().ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    String::from_utf8(output.stdout).ok().map(|s| s.trim().to_string()).filter(|s| !s.is_empty())
+}
+
+    // =========================================================================
+    // (A) CLI dispatch — run(argv, cwd) parses each subcommand and routes to its (already-tested)
+    // cmd_*, mapping the exit code. Today run() only handles codex/claude passthrough + help, else
+    // ExitCode::Error. These prove run DISPATCHES (observable per-command effect + exit). Golden
+    // cli/parser.py:main. OS-safe handlers only; spawn-bearing routes are #[ignore] real-machine.
+    // =========================================================================
+
+    #[test]
+    fn run_dispatches_status_to_handler_returns_ok() {
+        // run([status --workspace <seeded> --json]) -> cmd_status -> status_port::status (reads state)
+        // -> ExitCode::Ok. Today: Error (no dispatch). OS-safe (status only reads runtime state).
+        let ws = seed_status_workspace();
+        let argv = vec![
+            "status".to_string(),
+            "--workspace".to_string(),
+            ws.to_string_lossy().to_string(),
+            "--json".to_string(),
+        ];
+        assert_eq!(
+            run(&argv, Path::new(".")),
+            ExitCode::Ok,
+            "run must dispatch `status` to cmd_status and return Ok (not today's hardcoded Error)"
+        );
+    }
+
+    #[test]
+    fn run_dispatches_send_to_handler_returns_ok() {
+        // run([send w1 hello --sender leader --workspace <seeded>]) -> cmd_send -> messaging::send_message
+        // -> ok (w1 is an in-team agent) -> ExitCode::Ok. w1 must be seeded: golden refuses non-team targets.
+        //
+        // OLD seed: flat `{"agents": {"w1": ...}}`.
+        // NEW seed (Bug 1/2 — team-in-team state scope, see
+        // tests/team_in_team_state_scope_red.rs): send_message projects the raw state
+        // through the active team_key, so the in-team agent now lives under
+        // `teams[<key>].agents`. Behavior under test (dispatch + ok exit) unchanged.
+        let ws = deleg_uniq_dir("run-send");
+        let _ = crate::message_store::MessageStore::open(&ws).unwrap();
+        crate::state::persist::save_runtime_state(
+            &ws,
+            &serde_json::json!({
+                "active_team_key": "current",
+                "teams": {"current": {"agents": {"w1": {"provider": "codex"}}}}
+            }),
+        )
+        .unwrap();
+        let argv = vec![
+            "send".to_string(),
+            "w1".to_string(),
+            "hello".to_string(),
+            "--sender".to_string(),
+            "leader".to_string(),
+            "--workspace".to_string(),
+            ws.to_string_lossy().to_string(),
+        ];
+        assert_eq!(
+            run(&argv, Path::new(".")),
+            ExitCode::Ok,
+            "run must dispatch `send` to cmd_send and derive ExitCode::Ok from the delivery outcome"
+        );
+    }
+
+    #[test]
+    fn run_unknown_subcommand_is_usage() {
+        // An unknown subcommand routes to argparse-style usage (exit 2), never a handler.
+        assert_eq!(
+            run(&["totally-not-a-subcommand".to_string()], Path::new(".")),
+            ExitCode::Usage,
+            "an unknown subcommand must map to ExitCode::Usage"
+        );
+    }
+
+    #[test]
+    #[ignore = "real-machine: `coordinator --once` dispatches to run_daemon which drives a real \
+                Coordinator (TmuxBackend); in-process needs a run_daemon_with_coordinator seam"]
+    fn run_dispatches_coordinator_once_writes_meta() {
+        // run([coordinator --workspace <ws> --once]) -> run_daemon(DaemonArgs{once:true}) -> writes the
+        // coordinator boot metadata + ExitCode::Ok. (real machine — drives a real backend.)
+        let ws = seed_status_workspace();
+        let argv = vec![
+            "coordinator".to_string(),
+            "--workspace".to_string(),
+            ws.to_string_lossy().to_string(),
+            "--once".to_string(),
+        ];
+        let exit = run(&argv, Path::new("."));
+        let wp = crate::coordinator::WorkspacePath::new(ws);
+        assert!(
+            crate::coordinator::coordinator_meta_path(&wp).exists(),
+            "coordinator --once must dispatch to run_daemon and write the coordinator metadata"
+        );
+        assert_eq!(exit, ExitCode::Ok);
+    }
+
+    #[test]
+    #[ignore = "real-machine: quick-start --yes spawns a real team (tmux) + coordinator daemon"]
+    fn run_dispatches_quick_start_compiles_spec() {
+        // The full quick-start path spawns workers + the coordinator; on a real machine we assert it
+        // dispatched to cmd_quick_start (team.spec.yaml compiled under the team dir) + ExitCode::Ok.
+        let dir = std::env::temp_dir().join(format!("ta-cli-qs-{}", std::process::id()));
+        std::fs::create_dir_all(dir.join("agents")).unwrap();
+        std::fs::write(dir.join("TEAM.md"), "---\nname: t\nobjective: o\nprovider: codex\n---\n\nteam.\n").unwrap();
+        std::fs::write(
+            dir.join("agents").join("implementer.md"),
+            "---\nname: implementer\nrole: Impl\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nImpl.\n",
+        )
+        .unwrap();
+        let argv = vec!["quick-start".to_string(), dir.to_string_lossy().to_string(), "--yes".to_string()];
+        let exit = run(&argv, Path::new("."));
+        assert!(dir.join("team.spec.yaml").exists(), "quick-start must compile the spec under the team dir");
+        assert_eq!(exit, ExitCode::Ok);
+    }
+
+    // =========================================================================
+    // (DELEGATION) cli *_port handlers must DELEGATE TO THE REAL SUBSYSTEMS (crate::lifecycle /
+    // crate::coordinator / crate::message_store), not the placeholder stubs in cli/mod.rs (which do
+    // `let _ = (...)` and fabricate canned Values). Each test asserts the REAL subsystem's effect
+    // (spec compiled, real error text, real coordinator_health, real DB counts) appears in the
+    // handler's CmdResult/Value — distinguishable from the placeholder's canned output. OS edge mocked;
+    // real tmux spawn / real daemon = #[ignore]. Golden: lifecycle/launch.rs+restart.rs, compiler.rs,
+    // coordinator/health.rs, message_store.
+    // =========================================================================
+    #[test]
+    fn cli_quick_start_invokes_real_lifecycle_compiles_spec() {
+        let team = deleg_team_dir_with_healthy_coordinator();
+        let ws = crate::model::paths::team_workspace(&team).unwrap();
+        let _guard = TeamSocketGuard { ws };
+        let args = QuickStartArgs {
+            agents_dir: team.clone(),
+            name: None,
+            team_id: None,
+            yes: true,
+            fresh: false,
+            json: true,
+        };
+        let _ = cmd_quick_start(&args); // real quick_start compiles the spec before any coordinator/launch step
+        assert!(
+            team.join("team.spec.yaml").exists(),
+            "cmd_quick_start must delegate to crate::lifecycle::quick_start, which compiles team.spec.yaml \
+             under the team dir; the placeholder never writes it"
+        );
+    }
+
+    // 2 [P0] — cmd_quick_start over an INVALID role doc surfaces the REAL compiler error (missing
+    // `provider`), proving delegation to crate::lifecycle (compile fails before any spawn). The
+    // placeholder returns a canned {ok:true} with no error -> RED. OS-safe (compile fails early).
+    #[test]
+    fn cli_quick_start_invalid_spec_surfaces_real_compile_error() {
+        let team = deleg_uniq_dir("qsbad");
+        std::fs::create_dir_all(team.join("agents")).unwrap();
+        std::fs::write(team.join("TEAM.md"), DELEG_TEAM_MD).unwrap();
+        std::fs::write(team.join("agents").join("broken.md"), DELEG_INVALID_ROLE).unwrap();
+        let args = QuickStartArgs {
+            agents_dir: team,
+            name: None,
+            team_id: None,
+            yes: false,
+            fresh: false,
+            json: true,
+        };
+        let text = outcome_text(cmd_quick_start(&args));
+        assert!(
+            text.contains("provider"),
+            "cmd_quick_start must surface the REAL compiler error for a role doc missing `provider` \
+             (proving delegation to crate::lifecycle, not the placeholder's canned ok:true); got {text}"
+        );
+    }
+
+    // 3 [P1] — cmd_restart on a no-spec workspace surfaces the REAL crate::lifecycle::restart error
+    // "missing spec for restart" (restart.rs:147). The placeholder returns {ok:true, allow_fresh, team}
+    // -> RED. OS-safe (restart errors on the missing spec before any spawn).
+    #[test]
+    fn cli_restart_missing_spec_surfaces_real_teamselect() {
+        let ws = deleg_uniq_dir("restart"); // no team.spec.yaml
+        let args = RestartArgs { workspace: ws, team: None, allow_fresh: false, json: true };
+        let text = outcome_text(cmd_restart(&args));
+        assert!(
+            text.contains("missing spec for restart"),
+            "cmd_restart must surface the REAL crate::lifecycle::restart 'missing spec for restart' error \
+             (not the placeholder's canned ok:true); got {text}"
+        );
+    }
+
+    // 4 [P1] — cmd_add_agent with a DUPLICATE agent id surfaces the REAL crate::lifecycle::add_agent
+    // "agent id already exists" error (launch.rs:252). The placeholder returns {ok:true} -> RED.
+    // OS-safe (the dup check fires before compile/spawn).
+    #[test]
+    fn cli_add_agent_duplicate_id_surfaces_real_error() {
+        let team = deleg_uniq_dir("addagent");
+        std::fs::create_dir_all(team.join("agents")).unwrap();
+        std::fs::write(team.join("TEAM.md"), DELEG_TEAM_MD).unwrap();
+        std::fs::write(team.join("agents").join("implementer.md"), DELEG_VALID_ROLE).unwrap(); // 'implementer' already exists
+        let dup_role = team.join("dup-role.md");
+        std::fs::write(&dup_role, DELEG_VALID_ROLE).unwrap(); // role file must exist
+        let args = AddAgentArgs {
+            agent: "implementer".to_string(),
+            workspace: team,
+            team: None,
+            role_file: dup_role.to_string_lossy().to_string(),
+            no_display: false,
+            json: true,
+        };
+        let text = outcome_text(cmd_add_agent(&args));
+        assert!(
+            text.contains("already exists"),
+            "cmd_add_agent must surface the REAL crate::lifecycle::add_agent 'agent id already exists' error \
+             (not the placeholder's canned ok:true); got {text}"
+        );
+    }
+
+    // 5 [P1] — cmd_status --json reflects the REAL coordinator_health + real DB message/result counts.
+    // The placeholder status_port::status hardcodes coordinator={status:stopped, schema_ok:false} and
+    // messages/results={count:0}. Seed: state.json + a real team.db (2 messages + 1 result) + a healthy
+    // coordinator (this pid + metadata) -> the real path must surface running-coordinator + non-zero
+    // counts. OS-safe (all reads/seeds, no spawn).
+    #[test]
+    fn cli_status_reflects_real_coordinator_health_and_db_counts() {
+        let ws = seed_status_workspace(); // writes .team/runtime/state.json
+        let store = crate::message_store::MessageStore::open(&ws).unwrap();
+        let _ = store.create_message(Some("t1"), "leader", "a1", "hi", None, true, None).unwrap();
+        let _ = store.create_message(Some("t1"), "leader", "a1", "again", None, true, None).unwrap();
+        let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+        conn.execute(
+            "insert into results(result_id, owner_team_id, task_id, agent_id, envelope, status, created_at) \
+             values ('r1', null, 't1', 'a1', '{}', 'success', '2026-01-01T00:00:00Z')",
+            [],
+        )
+        .unwrap();
+        drop(store);
+        // a HEALTHY coordinator at the status workspace (this process's pid + matching metadata).
+        let wp = crate::coordinator::WorkspacePath::new(ws.clone());
+        let me = crate::coordinator::Pid::new(std::process::id());
+        crate::coordinator::write_coordinator_metadata(&wp, me, crate::coordinator::MetadataSource::Boot).unwrap();
+        std::fs::write(crate::coordinator::coordinator_pid_path(&wp), me.to_string()).unwrap();
+
+        let args = StatusArgs { agent: None, workspace: ws, detail: true, summary: false, json: true };
+        let r = cmd_status(&args).expect("cmd_status");
+        let value = match r.output {
+            CmdOutput::Json(v) => v,
+            other => panic!("status --json must yield a Json CmdOutput; got {other:?}"),
+        };
+        assert_ne!(
+            value["coordinator"],
+            json!({"status": "stopped", "schema_ok": false}),
+            "status `coordinator` must reflect the REAL coordinator_health (seeded running), not the \
+             placeholder's hardcoded {{status:stopped, schema_ok:false}}; got {}",
+            value["coordinator"]
+        );
+        assert_ne!(
+            value["messages"],
+            json!({"count": 0}),
+            "status `messages` must reflect the REAL DB rows (2 seeded), not the placeholder's {{count:0}}; got {}",
+            value["messages"]
+        );
+        assert_ne!(
+            value["results"],
+            json!({"count": 0}),
+            "status `results` must reflect the REAL DB result row, not the placeholder's {{count:0}}; got {}",
+            value["results"]
+        );
+    }
+
+    // 6 [P1] — cmd_shutdown delegates to the REAL crate::coordinator::stop_coordinator (+ tmux
+    // kill-session). The placeholder lifecycle_port::shutdown returns only {ok:true, keep_logs, team}.
+    // #[ignore] real-machine: the real shutdown spawns `tmux kill-session` (and SIGTERMs the coordinator);
+    // on a no-coordinator workspace the real stop_coordinator outcome (stopped/missing) must surface.
+    #[test]
+    #[ignore = "real-machine: cmd_shutdown runs the real tmux kill-session + SIGTERMs the coordinator daemon"]
+    fn cli_shutdown_invokes_real_stop_coordinator() {
+        let ws = seed_status_workspace();
+        let args = ShutdownArgs { workspace: ws, team: None, keep_logs: true, json: true };
+        let text = outcome_text(cmd_shutdown(&args));
+        let lower = text.to_lowercase();
+        assert!(
+            lower.contains("coordinator") || lower.contains("stopped") || lower.contains("missing"),
+            "cmd_shutdown must delegate to the real coordinator::stop_coordinator and surface its outcome \
+             (no coordinator -> stopped/missing); the placeholder returns only {{ok,keep_logs,team}}; got {text}"
+        );
+    }