@team-agent/installer 0.5.111 → 0.5.112

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,

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

@@ -144,155 +144,12 @@ fn seed_leader_registry_entry(ws: &std::path::Path) {
     );
 }
 
-// =========================================================================
-// WAVE-2 NON-SUB CHECKPOINT — missing CLI subcommands (ABSENT from cli/emit.rs dispatch).
-// emit.rs `dispatch` has NO arm for sessions, peek, collect, e2e, diagnose,
-// preflight, wait-ready -> they fall to `_ => Ok(ExitCode::Error)`. These REDs
-// assert the dispatch ROUTES each subcommand: `run([sub,...]) == ExitCode::Ok` for a golden
-// EXIT-0 scenario (today unrouted -> ExitCode::Error -> RED; green once the porter adds the
-// dispatch arm + handler). Golden exit codes + JSON shapes probed via `python3 -m team_agent <sub>`.
-//
-// OBSERVABILITY NOTE: `run()` exposes only ExitCode (Ok=0/Error=1); it prints via println!, which
-// libtest intercepts (thread-local capture), so an fd-level stdout byte-capture is unreliable
-// under `cargo test`. The exact golden --json byte-shape is therefore LOCKED in each doc-comment
-// as the porter's parity obligation; the in-process assertion is the routing (exit code). A
-// follow-up can byte-lock output once each handler exists as a callable `cmd_*`/`*_port` symbol.
-//
-// Only golden-EXIT-0, tmux-SAFE scenarios make a clean RED (an exit-1 scenario's Error is
-// indistinguishable from the unknown-subcommand Error -> false-green, forbidden). preflight/
-// wait-ready/e2e/peek cannot reach golden-exit-0 on CI without real tmux/providers/a live team,
-// so they are #[ignore] real-effect seams (documented shape), NOT false-green exit-1 asserts.
-// =========================================================================
+// Retained doctor dispatch and shared status-readiness contracts.
 
 fn cli_argv(items: &[&str]) -> Vec<String> {
     items.iter().map(|s| (*s).to_string()).collect()
 }
 
-/// The exact golden fake spec (cli/e2e.py `_fake_spec`, dumped via simple_yaml) with the literal
-/// `/WS` placeholder substituted to the real workspace — the minimal VALID team.spec.yaml that
-/// `collect` accepts. (load_spec rejects partial specs: requires
-/// communication/context/leader/routing/runtime/tasks.)
-const FAKE_SPEC_YAML: &str = r#"version: 1
-team:
-  name: "fake-e2e"
-  mode: "supervisor_worker"
-  objective: "Exercise fake provider orchestration."
-  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"
-      - "fs_write"
-      - "fs_list"
-      - "execute_bash"
-      - "git_diff"
-      - "mcp_team"
-      - "provider_builtin"
-    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"
-  session_name: "team-agent-fake-e2e"
-  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"
-    requires_tools:
-      - "fs_write"
-      - "execute_bash"
-    files:
-      - "src/example.py"
-    risk: "low"
-"#;
-
-fn seed_team_spec(ws: &std::path::Path) {
-    let spec = FAKE_SPEC_YAML.replace("/WS", &ws.to_string_lossy());
-    std::fs::write(ws.join("team.spec.yaml"), spec).unwrap();
-}
-
-// ── sessions ── golden cli/parser.py:230 `cmd_sessions` -> runtime.sessions(ws). EXIT 0.
-// `team-agent sessions --workspace <ws> --json` on an empty ws ->
-//   {"ok":true,"sessions":[],"workspace":"<ws>"}  (--json sort_keys). RED: unrouted -> Error.
-#[test]
-fn dispatch_routes_sessions_subcommand() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&["sessions", "--workspace", &ws.to_string_lossy(), "--json"]),
-        &ws,
-    );
-    assert_eq!(
-            code,
-            ExitCode::Ok,
-            "`sessions` must ROUTE to cmd_sessions (golden parser.py:230, exit 0 {{ok,sessions,workspace}}); \
-             today it falls to the unknown-subcommand arm (emit.rs:77) -> Error"
-        );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
 // ── diagnose ── attached is host-registry authority, not state.json self-sign.
 // Seed leader_receiver=attached + a ~/.team-agent/leaders/ row for this workspace
 // + NO session_name + NO agents -> issues=[] -> EXIT 0.
@@ -389,120 +246,6 @@ fn dispatch_routes_diagnose_self_signed_attached_without_registry_is_not_ok() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
-// ── preflight (#[ignore] real-machine) ── golden parser.py:160 `cmd_preflight` -> runtime.preflight
-// (Path(args.team)). Validates a team role-doc dir: checks compile(TEAM.md)/tmux/ghostty/rust_core/
-// profile_dir; golden -> {"blockers":[...],"checks":[...],"details_log":...,"next_actions":[...],
-// "ok":bool,"summary":...}. Reaches ok:true (exit 0) ONLY with a valid TEAM.md + ghostty installed,
-// which CI cannot supply (ghostty absent -> blocker) -> not a clean in-process exit-0 RED.
-#[test]
-#[ignore = "real-machine: `preflight --team <dir>` needs a valid TEAM.md role-doc dir + ghostty to \
-                reach ok:true; on CI it golden-exits 1 (compile/ghostty blockers) which is \
-                indistinguishable from the unknown-subcommand Error (false-green). Routes to cmd_preflight \
-                (parser.py:160); shape {blockers,checks,details_log,next_actions,ok,summary}"]
-fn dispatch_routes_preflight_real_machine() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&["preflight", "--team", &ws.to_string_lossy(), "--json"]),
-        &ws,
-    );
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "preflight must ROUTE + exit 0 on a valid team dir"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── wait-ready (#[ignore] real-machine) ── golden parser.py:171 `cmd_wait_ready` -> runtime.wait_ready
-// (ws, timeout). Polls worker readiness; golden -> {"details_log":...,"next_actions":[...],"ok":bool,
-// "readiness":{cli_prompt_ready,mcp_ready,process_started,task_prompt_delivered},"summary":...}.
-// ok:true (exit 0) needs a LIVE ready team; CI has none -> golden-exits 1 (false-green vs unknown).
-#[test]
-#[ignore = "real-machine: `wait-ready` polls a LIVE team's readiness; with no workers golden-exits 1 \
-                (false-green vs unknown-subcommand Error). Routes to cmd_wait_ready (parser.py:171); shape \
-                {details_log,next_actions,ok,readiness{cli_prompt_ready,mcp_ready,process_started,task_prompt_delivered},summary}"]
-fn dispatch_routes_wait_ready_real_machine() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&[
-            "wait-ready",
-            "--workspace",
-            &ws.to_string_lossy(),
-            "--timeout",
-            "1",
-            "--json",
-        ]),
-        &ws,
-    );
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "wait-ready must ROUTE + exit 0 once the team is ready"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── e2e --providers fake (#[ignore] real-machine) ── golden parser.py:449 `cmd_e2e` (cli/e2e.py:12).
-// `--providers fake` runs a REAL end-to-end: runtime.launch(spec, auto_approve=True) (spawns a tmux
-// team) -> send_message -> sleep -> collect -> shutdown. Result envelope (e2e.py:16,48-56):
-//   {"workspace":str,"providers":{"fake":{"ok":bool,"launch":{...},"send":{...},"collect":{...},
-//    "shutdown":{...}}},"ok":bool}. Real tmux spawn -> #[ignore] (NOT runnable in-process).
-#[test]
-#[ignore = "real-machine: `e2e --providers fake` calls runtime.launch -> spawns a REAL tmux team \
-                (send/collect/shutdown). Routes to cmd_e2e (parser.py:449 / e2e.py:12); envelope \
-                {workspace,providers:{fake:{ok,launch,send,collect,shutdown}},ok}"]
-fn dispatch_routes_e2e_fake_real_machine() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&[
-            "e2e",
-            "--providers",
-            "fake",
-            "--workspace",
-            &ws.to_string_lossy(),
-            "--json",
-        ]),
-        &ws,
-    );
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "e2e --providers fake must ROUTE + run the fake end-to-end (ok:true)"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-// ── peek (#[ignore] real-machine) ── golden parser.py:201 `cmd_peek` (commands.py:118). Requires
-// `--allow-raw-screen` (else TeamAgentError) + a mutually-exclusive --head/--tail/--search; then
-// runtime.peek captures a LIVE tmux pane (tmux capture-pane). Real tmux -> #[ignore]. Routes to
-// cmd_peek; --json returns the peek dict (text + capture metadata).
-#[test]
-#[ignore = "real-machine: `peek <agent> --tail N --allow-raw-screen` captures a LIVE tmux pane \
-                (tmux capture-pane); needs a running worker pane. Routes to cmd_peek (parser.py:201); \
-                --json returns the peek dict (raw screen text + metadata)"]
-fn dispatch_routes_peek_real_machine() {
-    let ws = tmp_workspace();
-    let code = run(
-        &cli_argv(&[
-            "peek",
-            "fake_impl",
-            "--workspace",
-            &ws.to_string_lossy(),
-            "--tail",
-            "20",
-            "--allow-raw-screen",
-            "--json",
-        ]),
-        &ws,
-    );
-    assert_eq!(
-        code,
-        ExitCode::Ok,
-        "peek must ROUTE + capture the live pane (real machine)"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
 // CONTRACT (shared-root, real-machine-driven; golden = correct-behavior baseline): wait_readiness
 // derives cli_prompt_ready from the LIFECYCLE status — an alive worker (status="running") IS
 // cli_prompt_ready (golden quick_start.py:173 `status ∈ {running, busy}`). Rust (diagnose.rs:280)

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

@@ -129,11 +129,9 @@ mod leader_watch;
 mod main_preserved;
 mod missing_subcommands;
 mod named_address;
-mod peer_allow;
 mod run_delegation;
 mod shutdown_kill_plan;
 mod status_brief;
 mod status_send;
 mod verb_install_skill;
 mod verb_profile;
-mod verb_validate;

package/crates/team-agent/src/cli/types.rs

@@ -37,8 +37,8 @@ pub enum CliError {
     /// 委派的 runtime/lifecycle/state 错误(对应 Python `TeamAgentError`)。message == `str(exc)`。
     #[error("{0}")]
     Runtime(String),
-    /// argparse 风格用法错误 / 互斥违反(如 `--summary` + `--json`、`--fix` 缺 `--gate`、
-    /// `peek` 缺 `--allow-raw-screen`)。对应 Python 抛 `TeamAgentError` 或 parser.error。
+    /// argparse 风格用法错误 / 互斥违反(如 `--summary` + `--json`、`--fix` 缺 `--gate`)。
+    /// 对应 Python 抛 `TeamAgentError` 或 parser.error。
     #[error("usage error: {0}")]
     Usage(String),
     /// Preserve the original refusal for audit while carrying safe human guidance.
@@ -127,7 +127,6 @@ impl CliError {
 }
 
 /// CLI 进程退出码(`main`:`result.ok is False` 或异常 → `SystemExit(1)`,否则 0)。
-/// `watch` 路径直接 `SystemExit(0)`(`cmd_watch`)。
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ExitCode {
     Ok,
@@ -153,14 +152,14 @@ impl ExitCode {
 /// Python `cmd_*` 返回 `dict | str | None`:
 ///   - `Json(Value)` ← 委派 runtime 的稳定 `{ok, ...}` dict(`--json` 序列化 sort_keys+indent=2)。
 ///   - `Human(String)` ← 人读渲染(`format_status`/`cmd_advanced`/五行 summary/comms boundary text)。
-///   - `None` ← passthrough/watch 命令(`cmd_codex`/`cmd_claude`/`cmd_watch`,直接 SystemExit,无 emit)。
+///   - `None` ← passthrough 命令(`cmd_codex`/`cmd_claude`,直接 SystemExit,无 emit)。
 #[derive(Debug, Clone, PartialEq)]
 pub enum CmdOutput {
     /// 机器可读稳定 dict(`--json` 路径或 `result.get("ok") is False` 路径)。
     Json(Value),
     /// 人读字符串(`emit` 非 dict 分支直接 print)。
     Human(String),
-    /// 无输出(passthrough/watch;不经 `emit`)。
+    /// 无输出(passthrough;不经 `emit`)。
     None,
 }
 
@@ -193,19 +192,6 @@ impl CmdResult {
             preserve_json_order: false,
         }
     }
-    pub fn from_ordered_json(value: Value) -> Self {
-        let exit = if value.get("ok").and_then(Value::as_bool) == Some(false) {
-            ExitCode::Error
-        } else {
-            ExitCode::Ok
-        };
-        Self {
-            output: CmdOutput::Json(value),
-            exit,
-            as_json: true,
-            preserve_json_order: true,
-        }
-    }
     pub fn human(text: impl Into<String>) -> Self {
         Self {
             output: CmdOutput::Human(text.into()),
@@ -357,18 +343,6 @@ pub struct SendArgs {
     pub to_leader: Option<String>,
 }
 
-/// `allow-peer-talk`(`parser.py`): allow direct peer communication between two agents.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AllowPeerTalkArgs {
-    pub a: String,
-    pub b: String,
-    pub workspace: PathBuf,
-    pub json: bool,
-    /// Parsed but rejected until peer allowlist storage grows a team-scoped
-    /// backend column.
-    pub team: Option<String>,
-}
-
 /// `status`(`parser.py:182`)。`--summary`/`--json`/`--detail` 三态(summary xor json,见 `cmd_status`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StatusArgs {
@@ -382,13 +356,6 @@ pub struct StatusArgs {
     pub team: Option<String>,
 }
 
-/// `watch`(`parser.py:190`)。无 `--json`(纯 stream 到 SystemExit)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct WatchArgs {
-    pub workspace: PathBuf,
-    pub team: Option<String>,
-}
-
 /// `approvals`(`parser.py:195`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ApprovalsArgs {
@@ -452,14 +419,6 @@ pub struct AttachAppServerLeaderArgs {
     pub json: bool,
 }
 
-/// `identity`(`parser.py:256`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct IdentityArgs {
-    pub workspace: PathBuf,
-    pub team: Option<String>,
-    pub json: bool,
-}
-
 /// `shutdown`(`parser.py:355`)。`--keep-logs` 默认 true。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ShutdownArgs {
@@ -584,15 +543,6 @@ pub enum DoctorGate {
     Unknown(String),
 }
 
-/// `sessions`(`parser.py:230`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SessionsArgs {
-    pub workspace: PathBuf,
-    pub json: bool,
-    /// Stage 4: explicit `--team` scope (read-only enumeration).
-    pub team: Option<String>,
-}
-
 /// E7 (0.5.9 host-leader-registry-design §4.1): `team-agent leaders`
 /// enumerates the host discovery index and classifies each entry as
 /// LIVE, STALE, or AMBIGUOUS after re-validating against canonical
@@ -621,13 +571,6 @@ pub struct ModelsArgs {
     pub json: bool,
 }
 
-/// `validate [spec=team.spec.yaml] --json`(`parser.py:120`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ValidateArgs {
-    pub spec: PathBuf,
-    pub json: bool,
-}
-
 /// `profile {init,doctor,show}`(`parser.py:131`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ProfileArgs {
@@ -640,56 +583,9 @@ pub struct ProfileArgs {
     pub json: bool,
 }
 
-/// Read-only lookup of all stored result envelopes for one case.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ResultsArgs {
-    pub case_id: String,
-    pub workspace: PathBuf,
-    pub team: Option<String>,
-    pub json: bool,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct WaitArgs {
     pub task_id: String,
     pub workspace: PathBuf,
     pub json: bool,
 }
-
-/// `preflight`(`parser.py:160`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PreflightArgs {
-    pub team: PathBuf,
-    pub json: bool,
-}
-
-/// `wait-ready`(`parser.py:171`)。
-#[derive(Debug, Clone, PartialEq)]
-pub struct WaitReadyArgs {
-    pub workspace: PathBuf,
-    pub timeout: f64,
-    pub json: bool,
-    /// Stage 4: explicit `--team` scope (read-only readiness probe).
-    pub team: Option<String>,
-}
-
-/// `e2e`(`parser.py:449`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct E2eArgs {
-    pub workspace: PathBuf,
-    pub providers: Vec<String>,
-    pub real: bool,
-    pub json: bool,
-}
-
-/// `peek`(`parser.py:201`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PeekArgs {
-    pub agent: String,
-    pub workspace: PathBuf,
-    pub tail: usize,
-    pub head: Option<usize>,
-    pub search: Option<String>,
-    pub allow_raw_screen: bool,
-    pub json: bool,
-}