@team-agent/installer 0.5.110 → 0.5.112

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

@@ -16,8 +16,16 @@ use serde_json::json;
 fn provider_args_cases() {
     // (old case-id, input, Python golden); values[1:] of a lone "--" is empty.
     const CASES: &[(&str, &[&str], &[&str])] = &[
-        ("provider_args_strips_leading_dashdash", &["--", "-x"], &["-x"]),
-        ("provider_args_keeps_when_no_leading_dashdash", &["-x", "-y"], &["-x", "-y"]),
+        (
+            "provider_args_strips_leading_dashdash",
+            &["--", "-x"],
+            &["-x"],
+        ),
+        (
+            "provider_args_keeps_when_no_leading_dashdash",
+            &["-x", "-y"],
+            &["-x", "-y"],
+        ),
         ("provider_args_empty_is_empty", &[], &[]),
         ("provider_args_lone_dashdash_yields_empty", &["--"], &[]),
     ];
@@ -36,41 +44,73 @@ fn provider_args_cases() {
 fn leader_launcher_args_success_cases() {
     // (old case-id, argv, complete expected structure), including default false flags.
     let cases: &[(&str, &[&str], LeaderLauncherArgs)] = &[
-        ("leader_launcher_args_empty_all_default", &[], LeaderLauncherArgs::default()),
-        ("leader_launcher_args_attach_and_confirm", &["--attach", "--confirm"], LeaderLauncherArgs {
-            attach_existing: true,
-            confirm_attach: true,
-            ..Default::default()
-        }),
+        (
+            "leader_launcher_args_empty_all_default",
+            &[],
+            LeaderLauncherArgs::default(),
+        ),
+        (
+            "leader_launcher_args_attach_and_confirm",
+            &["--attach", "--confirm"],
+            LeaderLauncherArgs {
+                attach_existing: true,
+                confirm_attach: true,
+                ..Default::default()
+            },
+        ),
         // --attach-existing is an alias of --attach.
-        ("leader_launcher_args_attach_existing_alias", &["--attach-existing"], LeaderLauncherArgs {
-            attach_existing: true,
-            ..Default::default()
-        }),
-        ("leader_launcher_args_external_leader_opt_out", &["--external-leader", "--", "--model", "opus"], LeaderLauncherArgs {
-            provider_args: vec!["--model".to_string(), "opus".to_string()],
-            external_leader: true,
-            ..Default::default()
-        }),
-        ("leader_launcher_args_attach_session_spaced", &["--attach-session", "mysess"], LeaderLauncherArgs {
-            attach_session: Some("mysess".to_string()),
-            ..Default::default()
-        }),
-        ("leader_launcher_args_attach_session_equals", &["--attach-session=mysess"], LeaderLauncherArgs {
-            attach_session: Some("mysess".to_string()),
-            ..Default::default()
-        }),
+        (
+            "leader_launcher_args_attach_existing_alias",
+            &["--attach-existing"],
+            LeaderLauncherArgs {
+                attach_existing: true,
+                ..Default::default()
+            },
+        ),
+        (
+            "leader_launcher_args_external_leader_opt_out",
+            &["--external-leader", "--", "--model", "opus"],
+            LeaderLauncherArgs {
+                provider_args: vec!["--model".to_string(), "opus".to_string()],
+                external_leader: true,
+                ..Default::default()
+            },
+        ),
+        (
+            "leader_launcher_args_attach_session_spaced",
+            &["--attach-session", "mysess"],
+            LeaderLauncherArgs {
+                attach_session: Some("mysess".to_string()),
+                ..Default::default()
+            },
+        ),
+        (
+            "leader_launcher_args_attach_session_equals",
+            &["--attach-session=mysess"],
+            LeaderLauncherArgs {
+                attach_session: Some("mysess".to_string()),
+                ..Default::default()
+            },
+        ),
         // Known Team Agent launcher flags after `--` are rejected by the error table.
-        ("leader_launcher_args_dashdash_passthrough_strips_separator", &["--attach", "--", "-x", "--provider-confirm"], LeaderLauncherArgs {
-            provider_args: vec!["-x".to_string(), "--provider-confirm".to_string()],
-            attach_existing: true,
-            ..Default::default()
-        }),
-        ("leader_launcher_args_unknown_tokens_collect_as_provider_args", &["foo", "--attach", "bar"], LeaderLauncherArgs {
-            provider_args: vec!["foo".to_string(), "bar".to_string()],
-            attach_existing: true,
-            ..Default::default()
-        }),
+        (
+            "leader_launcher_args_dashdash_passthrough_strips_separator",
+            &["--attach", "--", "-x", "--provider-confirm"],
+            LeaderLauncherArgs {
+                provider_args: vec!["-x".to_string(), "--provider-confirm".to_string()],
+                attach_existing: true,
+                ..Default::default()
+            },
+        ),
+        (
+            "leader_launcher_args_unknown_tokens_collect_as_provider_args",
+            &["foo", "--attach", "bar"],
+            LeaderLauncherArgs {
+                provider_args: vec!["foo".to_string(), "bar".to_string()],
+                attach_existing: true,
+                ..Default::default()
+            },
+        ),
     ];
     for (id, input, expected) in cases {
         let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
@@ -97,7 +137,10 @@ fn leader_launcher_args_error_cases() {
     for (id, input, expected) in CASES {
         let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
         let err = leader_launcher_args(&argv).expect_err(id);
-        assert!(err.to_string().contains(*expected), "{id}: unexpected error: {err}");
+        assert!(
+            err.to_string().contains(*expected),
+            "{id}: unexpected error: {err}"
+        );
     }
 }
 
@@ -110,14 +153,31 @@ fn send_target_cases() {
     // (old case-id, targets, target, complete expected enum).
     let cases: &[(&str, Option<&str>, Option<&str>, MessageTarget)] = &[
         (
-            "send_target_fanout_strips_and_filters_empty", Some("a, b ,,c"), None,
+            "send_target_fanout_strips_and_filters_empty",
+            Some("a, b ,,c"),
+            None,
             MessageTarget::Fanout(vec!["a".to_string(), "b".to_string(), "c".to_string()]),
         ),
-        ("send_target_single_target", None, Some("agent_x"), MessageTarget::Single("agent_x".to_string())),
+        (
+            "send_target_single_target",
+            None,
+            Some("agent_x"),
+            MessageTarget::Single("agent_x".to_string()),
+        ),
         // A bare "*" means broadcast to the whole team.
-        ("send_target_broadcast_star", None, Some("*"), MessageTarget::Broadcast),
+        (
+            "send_target_broadcast_star",
+            None,
+            Some("*"),
+            MessageTarget::Broadcast,
+        ),
         // targets="" is falsy in Python, so it falls through to args.target.
-        ("send_target_empty_targets_falls_through_to_target", Some(""), Some("fallback"), MessageTarget::Single("fallback".to_string())),
+        (
+            "send_target_empty_targets_falls_through_to_target",
+            Some(""),
+            Some("fallback"),
+            MessageTarget::Single("fallback".to_string()),
+        ),
     ];
     for (id, targets, target, expected) in cases {
         assert_eq!(send_target(*targets, *target), *expected, "{id}");
@@ -133,18 +193,52 @@ fn send_target_cases() {
 fn classify_agent_bucket_cases() {
     // (old case-id, all original (raw, health) inputs, expected bucket).
     const CASES: &[(&str, &[(&str, &str)], SummaryBucket)] = &[
-        ("classify_failed_takes_priority", &[("failed", ""), ("error", ""), ("running", "error")], SummaryBucket::Failed),
-        ("classify_stopped", &[("stopped", ""), ("done", ""), ("running", "done")], SummaryBucket::Stopped),
-        ("classify_busy", &[("busy", ""), ("", "running"), ("", "working")], SummaryBucket::Busy),
+        (
+            "classify_failed_takes_priority",
+            &[("failed", ""), ("error", ""), ("running", "error")],
+            SummaryBucket::Failed,
+        ),
+        (
+            "classify_stopped",
+            &[("stopped", ""), ("done", ""), ("running", "done")],
+            SummaryBucket::Stopped,
+        ),
+        (
+            "classify_busy",
+            &[("busy", ""), ("", "running"), ("", "working")],
+            SummaryBucket::Busy,
+        ),
         // hstatus==idle precedes the raw==running branch.
-        ("classify_hstatus_idle_beats_raw_running", &[("running", "idle")], SummaryBucket::Idle),
-        ("classify_pure_running", &[("running", "")], SummaryBucket::Running),
+        (
+            "classify_hstatus_idle_beats_raw_running",
+            &[("running", "idle")],
+            SummaryBucket::Idle,
+        ),
+        (
+            "classify_pure_running",
+            &[("running", "")],
+            SummaryBucket::Running,
+        ),
         // bug-071/077/085: unmatched and blocked/stuck/missing are Unknown, NEVER idle.
-        ("classify_blocked_and_unmatched_are_unknown_never_idle", &[("blocked", ""), ("stuck", ""), ("", "missing"), ("weird_value", ""), ("", "")], SummaryBucket::Unknown),
+        (
+            "classify_blocked_and_unmatched_are_unknown_never_idle",
+            &[
+                ("blocked", ""),
+                ("stuck", ""),
+                ("", "missing"),
+                ("weird_value", ""),
+                ("", ""),
+            ],
+            SummaryBucket::Unknown,
+        ),
     ];
     for (id, inputs, expected) in CASES {
         for &(raw, health) in inputs.iter() {
-            assert_eq!(classify_agent_bucket(raw, health), *expected, "{id}: raw={raw:?}, health={health:?}");
+            assert_eq!(
+                classify_agent_bucket(raw, health),
+                *expected,
+                "{id}: raw={raw:?}, health={health:?}"
+            );
         }
     }
 }
@@ -395,7 +489,7 @@ fn cli_error_payload_plain_runtime() {
     assert_eq!(payload.error, "some other error");
     assert_eq!(
         payload.action,
-        "run `team-agent doctor` or inspect the log path shown here"
+        "先运行 team-agent doctor --workspace . 检查所选队伍，或查看此处列出的错误日志。"
     );
     assert_eq!(payload.log, "/tmp/y.log");
     assert_eq!(payload.reason, None);
@@ -417,19 +511,14 @@ fn cli_error_payload_tmux_conflict_quick_start_enrichment() {
     // context reset is only through restart --allow-fresh with explicit consent.
     assert_eq!(
             payload.action,
-            "tmux session `my-team` already exists. It may be your own existing team. \
-To resume it use `team-agent restart`. \
-If recovery is impossible, use `team-agent restart --allow-fresh` only after explicit context-loss consent. \
-Only if you want a separate team, change `name:` in TEAM.md and run quick-start again. \
-Never terminate existing tmux sessions from quick-start."
-        );
-    assert_eq!(
-            payload.next_actions,
-            Some(vec![
-                "If this is your existing team, resume it with `team-agent restart`.".to_string(),
-                "If you want a separate team, change `name:` in TEAM.md and run `team-agent quick-start` again.".to_string(),
-            ])
+            "终端会话 `my-team` 已存在，可能是你的已有队伍。恢复用 team-agent restart；只有明确同意丢弃旧对话才用 --allow-fresh。另建队伍请修改 TEAM.md 的 name 后再 quick-start；不要关闭已有队伍凑成功。"
         );
+    let next = payload.next_actions.as_ref().unwrap();
+    assert_eq!(next.len(), 2);
+    assert!(next[0].contains("team-agent restart"));
+    assert!(
+        next[1].contains("TEAM.md") && next[1].contains("name") && next[1].contains("quick-start")
+    );
 }
 
 #[test]
@@ -440,16 +529,11 @@ fn cli_error_payload_tmux_conflict_non_quick_start_enrichment() {
     assert_eq!(payload.session_name.as_deref(), Some("my-team"));
     assert_eq!(
         payload.action,
-        "tmux session `my-team` already exists. It may be an active team. \
-Do not terminate existing tmux sessions from startup; \
-use a different team name or runtime.session_name and start again."
-    );
-    assert_eq!(
-        payload.next_actions,
-        Some(vec![
-            "Use a different team name or runtime.session_name before starting again.".to_string()
-        ])
+        "终端会话 `my-team` 已存在，可能属于运行中的队伍。不要关闭它；请使用另一个队伍名称后再启动。"
     );
+    let next = payload.next_actions.as_ref().unwrap();
+    assert_eq!(next.len(), 1);
+    assert!(next[0].contains("队伍") && next[0].contains("名称"));
 }
 
 #[test]
@@ -641,19 +725,42 @@ fn cmd_status_summary_with_agent_rejected() {
 // =========================================================================
 
 #[test]
-fn cmd_leader_passthrough_help_returns_none() {
-    // parser.py:516: provider_args in (["-h"],["--help"]) -> print usage, return (no emit).
-    let r = cmd_leader_passthrough("codex", &["-h".into()], Path::new(".")).unwrap();
-    assert_eq!(r.output, CmdOutput::None);
-    assert_eq!(r.exit, ExitCode::Ok);
-    let r2 = cmd_leader_passthrough("claude", &["--help".into()], Path::new(".")).unwrap();
-    assert_eq!(r2.output, CmdOutput::None);
-    let r3 = cmd_leader_passthrough("copilot", &["--help".into()], Path::new(".")).unwrap();
-    assert_eq!(r3.output, CmdOutput::None);
-    let r4 = cmd_leader_passthrough("grok", &["-h".into()], Path::new(".")).unwrap();
-    assert_eq!(r4.output, CmdOutput::None);
-    let r5 = cmd_leader_passthrough("cursor", &["--help".into()], Path::new(".")).unwrap();
-    assert_eq!(r5.output, CmdOutput::None);
+#[serial_test::serial(env)]
+fn cmd_leader_passthrough_help_is_pure_human_guidance() {
+    let env = crate::cli::hermetic_test_support::HermeticTestEnv::enter("launcher-help-unit");
+    let cwd = env.workspace("empty");
+    let tools = [
+        "pi", "codex", "claude", "copilot", "grok", "agent", "cursor",
+    ];
+    let bin = env.root().join("canaries");
+    std::fs::create_dir(&bin).unwrap();
+    #[cfg(unix)]
+    let _path = {
+        use std::os::unix::fs::PermissionsExt;
+        for tool in tools {
+            let path = bin.join(tool);
+            std::fs::write(&path, "#!/bin/sh\nprintf called > \"$0.called\"\nexit 0\n").unwrap();
+            std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).unwrap();
+        }
+        env.with_env("PATH", &bin.to_string_lossy())
+    };
+    for provider in ["pi", "codex", "claude", "copilot", "grok", "cursor"] {
+        for alias in ["-h", "--help"] {
+            let result = cmd_leader_passthrough(provider, &[alias.into()], &cwd).unwrap();
+            assert_eq!(result.exit, ExitCode::Ok);
+            assert!(
+                matches!(&result.output, CmdOutput::Human(text) if text.contains(provider) && text.contains("用法") && text.contains("Examples") && text.contains("下一步"))
+            );
+        }
+    }
+    assert_eq!(std::fs::read_dir(&cwd).unwrap().count(), 0);
+    assert!(env.registry_entries().is_empty());
+    for tool in tools {
+        assert!(
+            !bin.join(format!("{tool}.called")).exists(),
+            "native tool invoked"
+        );
+    }
 }
 
 #[test]

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

@@ -257,8 +257,7 @@ fn inbox_excludes_leader_stage_result_notifications() {
 // the deterministic check sub-shapes (run_id is a random uuid; not value-locked). ────────────────
 #[test]
 fn comms_selftest_golden_boundary_scope_and_check_shapes() {
-    let boundary = "validates live pane binding consistency and zero-token comms contracts. \
-                        Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
+    let boundary = "这里只检查终端连接是否一致，不实际发送消息，也不证明队友已回复。";
     let ws = tmp_workspace();
     let v = diagnose_port::comms_selftest(&ws, None, None).expect("comms_selftest");
     let obj = v.as_object().expect("comms dict");

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

@@ -100,11 +100,10 @@ fn cli_shutdown_kills_team_session_real_teardown() {
 
 // =========================================================================
 // WAVE-2 Lane B — CLI leader handler delegation byte-parity (leader_port::*).
-//   The three CLI verbs are thin pass-throughs (cli/commands.py:152-161):
+//   The retained CLI verbs are thin pass-throughs (cli/commands.py:152-157):
 //     cmd_takeover     -> runtime.takeover(ws, team, confirm)
 //     cmd_claim_leader -> runtime.claim_leader(ws, team, confirm)  (Family A)
-//     cmd_identity     -> runtime.leader_identity(ws, team)
-//   leader_port::{takeover,claim_leader,leader_identity} are STUBS returning
+//   leader_port::{takeover,claim_leader} are STUBS returning
 //   the WRONG shape today -> these LOCK the golden dict so the porter wires
 //   them into leader::* / runtime.* and matches byte-for-byte.
 //   Golden re-probed @ team-agent-public (probe_claim.py / probe_rtclaim.py /
@@ -297,89 +296,6 @@ fn leader_port_claim_leader_no_pane_refuses_caller_pane_missing_family_a() {
         );
 }
 
-// RED — leader_identity(): CLI directly emits leader.leader_identity's 9-key
-// dict (runtime.leader_identity is imported from leader). golden probe_lid.py
-// keys: ok, uuid_prefix, machine_fingerprint, workspace_abspath, os_user,
-// team_id, current_pane_id, last_seen_at, source. Current stub returns
-// {ok:true, team:...} (wrong shape) -> RED.
-#[test]
-fn leader_port_leader_identity_emits_nine_key_dict() {
-    let ws = leader_port_ws("identity");
-    std::fs::create_dir_all(crate::model::paths::runtime_dir(&ws)).unwrap();
-    let v = super::leader_port::leader_identity(&ws, None).unwrap();
-    assert_eq!(v["ok"], json!(true));
-    let obj = v.as_object().expect("identity → JSON object");
-    for key in [
-        "ok",
-        "uuid_prefix",
-        "machine_fingerprint",
-        "workspace_abspath",
-        "os_user",
-        "team_id",
-        "current_pane_id",
-        "last_seen_at",
-        "source",
-    ] {
-        assert!(
-            obj.contains_key(key),
-            "golden identity dict must carry '{key}', got {obj:?}"
-        );
-    }
-    // no override/state uuid → source is the leader-plan "derived" string.
-    assert_eq!(v["source"], json!("derived"));
-    // uuid_prefix is exactly 12 hex chars (derive[:12]).
-    let prefix = v["uuid_prefix"].as_str().expect("uuid_prefix str");
-    assert_eq!(prefix.len(), 12, "uuid_prefix == derived[:12]");
-    assert!(prefix.chars().all(|c| c.is_ascii_hexdigit()));
-    // no team registered + no TMUX_PANE/receiver → these are JSON null.
-    if std::env::var_os("TMUX_PANE").is_none() {
-        assert_eq!(v["current_pane_id"], serde_json::Value::Null);
-    }
-    assert_eq!(v["last_seen_at"], serde_json::Value::Null);
-}
-
-// ── cmd_watch (cli/adapters.rs:58) [RED] — today a CmdResult::none() no-op ───────────────────────
-// Golden cmd_watch (cli/commands.py:103-109) DELEGATES to run_watch(workspace.resolve(), team) and
-// exits 0. Golden run_watch (watch/__init__.py:25-37) is a `while True` LIVE TAIL that streams
-// render_event_line output (collect_watch_lines) for the watched team. The Rust cmd_watch returns
-// CmdResult::none() — a no-op that never touches the watch subsystem. The watch LINE SHAPE is itself
-// byte-locked by coordinator::render_event_line (coordinator/tests.rs GROUP H); the cli contract here
-// is that cmd_watch must DELEGATE and surface those rendered lines. Seeded a result_received event ->
-// golden render = "result_received: <agent> -> <summary>" (render_event_line: agent_id + summary[:80]).
-//
-// RED confirmed TODAY: cmd_watch=none() returns immediately (no watch line) -> the assertion fails
-// (and does NOT hang). PORTER: wire cmd_watch -> coordinator::run_watch(resolved workspace, team,
-// interval, sink). Since golden's tail is `while True`, the cli port needs a TERMINATING / bounded
-// entry to be both byte-parity AND unit-testable (collect the current watch lines into the CmdResult,
-// or stream to stdout with a bounded test seam) — a blocking unit test is unacceptable.
-#[test]
-fn cmd_watch_delegates_and_surfaces_rendered_watch_lines_not_noop() {
-    let ws = tmp_workspace();
-    let logs = crate::model::paths::logs_dir(&ws);
-    std::fs::create_dir_all(&logs).unwrap();
-    std::fs::write(
-        logs.join("events.jsonl"),
-        "{\"event\":\"result_received\",\"agent_id\":\"alpha\",\"summary\":\"did the thing\"}\n",
-    )
-    .unwrap();
-    let r = cmd_watch(&WatchArgs {
-        workspace: ws.clone(),
-        team: None,
-    })
-    .expect("cmd_watch returns a CmdResult");
-    let text = match &r.output {
-        CmdOutput::Human(s) => s.clone(),
-        CmdOutput::Json(v) => v.to_string(),
-        CmdOutput::None => String::new(),
-    };
-    assert!(
-            text.contains("result_received: alpha -> did the thing"),
-            "cmd_watch must DELEGATE to the watch subsystem (run_watch -> render_event_line) and surface the \
-             rendered watch line; today it is a CmdResult::none() no-op. got output={:?}",
-            r.output
-        );
-}
-
 // D7 [WARN] — WAVE-2 Lane B: empty caller binds refuse as caller_pane_missing.
 #[test]
 #[serial_test::serial(env)]

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

@@ -175,58 +175,7 @@ fn inbox_matches_sender_or_recipient_and_excludes_others() {
         );
     let _ = std::fs::remove_dir_all(&ws);
 }
-// ── BUG-4 [real bug] — peek must resolve the agent terminal via state `session:window` (golden),
-// NOT a stored `pane_id` field. A live worker present in state (with a `window`, on the team's `-L`
-// socket) must NOT be fabricated as "agent pane not found". ──────────────────────────────────────
-// Golden status/peek.py:35-44: agent = state["agents"][id]; window = agent.get("window", id);
-//   if not session_name or not _tmux_window_exists(session_name, window): raise "agent terminal is
-//   not available: <id>"; else `tmux capture-pane -t session:window`. It NEVER reads a stored pane_id.
-// Probed live (/tmp/probe_peek.py): a present worker whose window is absent on the socket raises
-// `agent terminal is not available: w1`; a missing agent raises `unknown agent id: <id>`. Rust
-// cmd_peek (adapters.rs:231 + agent_pane_id:279) keys off agent_state pane_id/pane/tmux_pane_id and
-// returns {ok:false,error:"agent pane not found"} when absent — so a NORMAL live worker (window in
-// state, no pane_id field) is mis-reported as not found. That is the CP-1 pane-resolution divergence.
-//
-// Deterministic without real tmux: on a host with no live session, the golden-correct peek resolves
-// session:window, finds the window absent on the socket, and yields "agent terminal is not available:
-// w1" — NOT "agent pane not found". (The window-on-socket -> real raw-screen capture positive case is
-// real-machine; see the #[ignore] dispatch_routes_peek_real_machine.)
-#[test]
-fn peek_resolves_live_worker_via_session_window_not_pane_id_field() {
-    let ws = tmp_workspace();
-    // a live worker: present in state with a `window`, session_name set, but NO stored pane_id field.
-    // session name is unique so a real tmux session on the dev host can't accidentally satisfy it.
-    crate::state::persist::save_runtime_state(
-        &ws,
-        &json!({
-            "session_name": "team-peek-red-probe-x9q",
-            "agents": {"w1": {"status": "running", "provider": "codex", "window": "w1"}}
-        }),
-    )
-    .unwrap();
-    let args = PeekArgs {
-        agent: "w1".to_string(),
-        workspace: ws.clone(),
-        tail: 20,
-        head: None,
-        search: None,
-        allow_raw_screen: true,
-        json: true,
-    };
-    let text = outcome_text(cmd_peek(&args));
-    assert!(
-            !text.contains("agent pane not found"),
-            "peek keys off a stored pane_id field and fabricates 'agent pane not found' for a live worker \
-             that has a `window` in state; golden resolves session:window and never reads pane_id. got: {text}"
-        );
-    assert!(
-        text.contains("agent terminal is not available: w1"),
-        "golden status/peek.py: a worker whose window is not on the socket yields \
-             'agent terminal is not available: w1' (window-existence via session:window), NOT a \
-             pane_id-keyed error. got: {text}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
+
 #[test]
 fn ux_doctor_secret_scan_is_present_and_non_triggering_for_normal_paths() {
     let ws = tmp_workspace();
@@ -295,44 +244,16 @@ fn ux_doctor_secret_scan_findings_name_the_exact_trigger() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 #[test]
-fn ux_wait_ready_does_not_report_ready_true_without_ready_runtime_state() {
-    let ws = tmp_workspace();
-    crate::state::persist::save_runtime_state(
-        &ws,
-        &json!({
-            "active_team_key": "wait-ready",
-            "agents": {"w1": {"status": "starting"}},
-            "tasks": [{"id": "t1", "assignee": "w1", "status": "pending"}],
-            "leader_receiver": {"status": "attached"},
-        }),
-    )
-    .unwrap();
-    let value = json_output(
-        cmd_wait_ready(&WaitReadyArgs {
-            workspace: ws.clone(),
-            timeout: 0.0,
-            json: true,
-            team: None,
-        })
-        .expect("wait-ready"),
-    );
-    assert_eq!(
-        value["ok"],
-        json!(false),
-        "wait-ready must not fake success before workers are ready"
-    );
-    assert_eq!(value.pointer("/readiness/ready"), Some(&json!(false)));
-    assert!(
-        value["summary"]
-            .as_str()
-            .unwrap_or("")
-            .contains("not ready"),
-        "wait-ready false state should explain not-ready status, got {value:?}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
+fn runtime_readiness_rejects_starting_workers() {
+    let value = crate::cli::diagnose::wait_readiness(&json!({
+        "agents": {"w1": {"status": "starting"}},
+        "leader_receiver": {"status": "attached"},
+    }));
+    assert_eq!(value["ready"], json!(false));
+    assert_eq!(value["all_spawned"], json!(false));
 }
 #[test]
-fn wait_ready_fake_quick_start_counts_mcp_config_and_task_prompt_delivery() {
+fn runtime_readiness_counts_mcp_config_and_task_prompt_delivery() {
     let ws = tmp_workspace();
     let mcp_config = ws
         .join(".team")
@@ -342,10 +263,9 @@ fn wait_ready_fake_quick_start_counts_mcp_config_and_task_prompt_delivery() {
         .join("mcp_config.json");
     std::fs::create_dir_all(mcp_config.parent().unwrap()).unwrap();
     std::fs::write(&mcp_config, r#"{"mcpServers":{"team-agent":{}}}"#).unwrap();
-    crate::state::persist::save_runtime_state(
-        &ws,
-        &json!({
+    let state = json!({
             "session_name": "team-fake-ready",
+            "messages": {"delivered": 1},
             "agents": {
                 "fake_impl": {
                     "status": "running",
@@ -359,30 +279,9 @@ fn wait_ready_fake_quick_start_counts_mcp_config_and_task_prompt_delivery() {
                 "status": "pending",
             }],
             "leader_receiver": {"status": "attached"},
-        }),
-    )
-    .unwrap();
-    let store = crate::message_store::MessageStore::open(&ws).unwrap();
-    store
-        .create_message(
-            Some("task_impl"),
-            "leader",
-            "fake_impl",
-            "initial task prompt",
-            None,
-            true,
-            None,
-        )
-        .unwrap();
-    let value = json_output(
-        cmd_wait_ready(&WaitReadyArgs {
-            workspace: ws.clone(),
-            timeout: 0.0,
-            json: true,
-            team: None,
-        })
-        .expect("wait-ready"),
-    );
+        });
+    let readiness = crate::cli::diagnose::wait_readiness(&state);
+    let value = json!({"readiness": readiness});
     assert_eq!(
         value.pointer("/readiness/mcp_ready"),
         Some(&json!(true)),
@@ -400,31 +299,7 @@ fn wait_ready_fake_quick_start_counts_mcp_config_and_task_prompt_delivery() {
         );
     let _ = std::fs::remove_dir_all(&ws);
 }
-fn valid_result_envelope() -> serde_json::Value {
-    json!({
-        "schema_version": "result_envelope_v1",
-        "task_id": "task_impl",
-        "agent_id": "fake_impl",
-        "status": "success",
-        "summary": "done",
-        "artifacts": [],
-        "changes": [],
-        "tests": [{"command": "cargo test", "status": "passed"}],
-        "risks": [],
-        "next_actions": []
-    })
-}
-fn seed_uncollected_result(ws: &std::path::Path, result_id: &str) {
-    let store = crate::message_store::MessageStore::open(ws).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 (?1, null, 'task_impl', 'fake_impl', ?2, 'success', '2026-06-02T10:00:00+00:00')",
-            rusqlite::params![result_id, valid_result_envelope().to_string()],
-        )
-        .unwrap();
-}
+
 fn json_output(result: CmdResult) -> serde_json::Value {
     match result.output {
         CmdOutput::Json(v) => v,