@team-agent/installer 0.5.29 → 0.5.32

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.29"
+version = "0.5.32"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.29"
+version = "0.5.32"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -295,13 +295,33 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
         )?;
         return Ok(CmdResult::from_json(value, true));
     }
-    Ok(CmdResult::human(append_reminder(
-        status_port::format_status_scoped(
+    let mut text = status_port::format_status_scoped(
+        &selected.run_workspace,
+        &selected.state,
+        Some(&selected.team_key),
+        args.agent.as_deref(),
+    )?;
+    if args.detail {
+        let value = status_port::status_scoped(
             &selected.run_workspace,
             &selected.state,
             Some(&selected.team_key),
-            args.agent.as_deref(),
-        )?,
+            false,
+            true,
+        )?;
+        if let Some(hint) = value
+            .pointer("/runtime/hint")
+            .and_then(serde_json::Value::as_str)
+            .filter(|hint| !hint.is_empty())
+        {
+            if !text.is_empty() {
+                text.push('\n');
+            }
+            text.push_str(hint);
+        }
+    }
+    Ok(CmdResult::human(append_reminder(
+        text,
         crate::cli::STATUS_REMINDER,
     )))
 }
@@ -378,33 +398,6 @@ pub fn cmd_sessions(args: &SessionsArgs) -> Result<CmdResult, CliError> {
     ))
 }
 
-/// `cmd_validate_result`(`commands.py:206`)。
-pub fn cmd_validate_result(args: &ValidateResultArgs) -> Result<CmdResult, CliError> {
-    let raw = if let Some(path) = &args.file {
-        std::fs::read_to_string(path)?
-    } else if let Some(envelope) = &args.envelope {
-        envelope.clone()
-    } else if let Some(result) = &args.result {
-        result.clone()
-    } else {
-        let mut input = String::new();
-        std::io::Read::read_to_string(&mut std::io::stdin(), &mut input)?;
-        input
-    };
-    let envelope: Value = serde_json::from_str(&raw)?;
-    crate::model::spec::validate_result_envelope(&envelope)
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    Ok(CmdResult::from_json(
-        json!({
-            "ok": true,
-            "task_id": envelope.get("task_id").cloned().unwrap_or(Value::Null),
-            "agent_id": envelope.get("agent_id").cloned().unwrap_or(Value::Null),
-            "status": envelope.get("status").cloned().unwrap_or(Value::Null),
-        }),
-        args.json,
-    ))
-}
-
 /// `cmd_collect`(`parser.py:292`)。
 pub fn cmd_collect(args: &CollectArgs) -> Result<CmdResult, CliError> {
     cmd_collect_for_team(args, args.team.as_deref())
@@ -481,162 +474,6 @@ pub fn cmd_collect_for_team(args: &CollectArgs, team: Option<&str>) -> Result<Cm
     ))
 }
 
-/// `cmd_settle`(`commands.py:86`)。
-pub fn cmd_settle(args: &SettleArgs) -> Result<CmdResult, CliError> {
-    match settle_value(&args.workspace, args.team.as_deref()) {
-        Ok(value) => Ok(CmdResult::from_json(value, args.json)),
-        Err(error) => Ok(CmdResult::from_json(
-            json!({
-                "ok": false,
-                "error": error.to_string(),
-                "workspace": args.workspace.to_string_lossy().to_string(),
-            }),
-            args.json,
-        )),
-    }
-}
-
-fn settle_value(workspace: &Path, team: Option<&str>) -> Result<Value, CliError> {
-    // Bug #6 (prerelease 0.4.0 gate review §6): pass explicit team through to
-    // resolve_active_team so settle scopes collect/status/team-state to the
-    // requested team. Without this, the selector falls back to top-level
-    // active_team_key and settle operates on the wrong team. resolve_active_team
-    // logic unchanged per 不可改项.
-    let selected = crate::state::selector::resolve_active_team(
-        workspace,
-        team,
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    )
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let mut collect = messaging::collect_for_team(
-        &selected.run_workspace,
-        None,
-        false,
-        Some(&selected.team_key),
-    )?;
-    if collect.get("ok").and_then(Value::as_bool) == Some(false) {
-        let message = collect
-            .get("error")
-            .and_then(Value::as_str)
-            .unwrap_or("collect failed");
-        return Err(CliError::Runtime(message.to_string()));
-    }
-    let coordinator_log = crate::coordinator::coordinator_log_path(
-        &crate::coordinator::WorkspacePath::new(selected.run_workspace.clone()),
-    );
-    let collect_object = collect
-        .as_object_mut()
-        .ok_or_else(|| CliError::Runtime("collect returned non-object output".to_string()))?;
-    collect_object.insert(
-        "coordinator".to_string(),
-        json!({
-            "ok": true,
-            "status": "started",
-            "log": coordinator_log.to_string_lossy().to_string(),
-        }),
-    );
-    collect_object.insert("team_key".to_string(), json!(selected.team_key.clone()));
-    collect_object.insert("active_team_key".to_string(), json!(selected.team_key.clone()));
-    collect_object.insert("team".to_string(), json!(selected.team_key.clone()));
-    if let Some(collected_results) = collect_object.get("collected_results").cloned() {
-        collect_object.insert("collected".to_string(), collected_results);
-    }
-    let status_state =
-        crate::state::projection::select_runtime_state(&selected.run_workspace, Some(&selected.team_key))?;
-    let state_file = match (selected.spec_path.as_ref(), selected.spec_workspace.as_ref()) {
-        (Some(spec_path), Some(spec_workspace)) => match load_team_spec_at(spec_path)? {
-            Some(spec) => crate::lifecycle::restart::write_team_state(spec_workspace, &spec, &status_state)
-                .map_err(|e| CliError::Runtime(e.to_string()))?
-                .to_string_lossy()
-                .to_string(),
-            None => collect
-                .get("state_file")
-                .and_then(Value::as_str)
-                .unwrap_or("")
-                .to_string(),
-        },
-        _ => collect
-            .get("state_file")
-            .and_then(Value::as_str)
-            .unwrap_or("")
-            .to_string(),
-    };
-    if let Some(obj) = collect.as_object_mut() {
-        obj.insert("state_file".to_string(), json!(state_file.clone()));
-    }
-    let mut status = status_port::status_scoped(
-        &selected.run_workspace,
-        &status_state,
-        Some(&selected.team_key),
-        true,
-        false,
-    )?;
-    if let Some(obj) = status.as_object_mut() {
-        obj.insert("team_key".to_string(), json!(selected.team_key.clone()));
-        obj.insert("active_team_key".to_string(), json!(selected.team_key.clone()));
-        obj.insert("team".to_string(), json!(selected.team_key.clone()));
-    }
-    let details_log = write_settle_details_log(&selected.run_workspace, &collect, &status)?;
-    let collected_count = collect
-        .get("collected")
-        .and_then(Value::as_array)
-        .map_or(0, Vec::len);
-    let settled_results = settle_collected_results_for_team(
-        collect.get("collected_results"),
-        &selected.team_key,
-    );
-    Ok(json!({
-        "ok": true,
-        "summary": format!("collected {collected_count} result(s)"),
-        "next_actions": ["Review team_state.md and decide whether to continue or shutdown."],
-        "details_log": details_log.to_string_lossy().to_string(),
-        "collected_results": settled_results,
-        "collected": collect.get("collected").cloned().unwrap_or_else(|| json!([])),
-        "results": collect.get("results").cloned().unwrap_or_else(|| json!({})),
-        "state_file": state_file,
-        "status": status,
-        "collect": collect,
-        "team_key": selected.team_key,
-        "active_team_key": selected.team_key,
-        "team": selected.team_key,
-        "workspace": selected.run_workspace.to_string_lossy().to_string(),
-    }))
-}
-
-fn settle_collected_results_for_team(value: Option<&Value>, team_key: &str) -> Value {
-    let Some(Value::Array(results)) = value else {
-        return json!([]);
-    };
-    Value::Array(
-        results
-            .iter()
-            .map(|result| {
-                let mut result = result.clone();
-                if let Some(obj) = result.as_object_mut() {
-                    obj.insert("owner_team_id".to_string(), json!(team_key));
-                }
-                result
-            })
-            .collect(),
-    )
-}
-
-fn write_settle_details_log(workspace: &Path, collect: &Value, status: &Value) -> Result<PathBuf, CliError> {
-    let logs = workspace.join(".team").join("logs");
-    std::fs::create_dir_all(&logs)?;
-    let timestamp = std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .map_or(0, |duration| duration.as_secs());
-    let path = logs.join(format!("settle-{timestamp}.json"));
-    let details = json!({
-        "collect": collect,
-        "status": status,
-    });
-    let text = serde_json::to_string_pretty(&crate::cli::sort_json(&details))?;
-    std::fs::write(&path, text)?;
-    Ok(path)
-}
-
 /// `cmd_allow_peer_talk`(`parser.py allow-peer-talk`).
 pub fn cmd_allow_peer_talk(args: &AllowPeerTalkArgs) -> Result<CmdResult, CliError> {
     if args.team.is_some() {
@@ -648,65 +485,6 @@ pub fn cmd_allow_peer_talk(args: &AllowPeerTalkArgs) -> Result<CmdResult, CliErr
     Ok(CmdResult::from_json(value, args.json))
 }
 
-/// `cmd_repair_state`(`parser.py:303`)。
-pub fn cmd_repair_state(args: &RepairStateArgs) -> Result<CmdResult, CliError> {
-    if !is_repair_task_status(&args.status) {
-        return Err(CliError::Runtime(format!(
-            "unknown task status for repair: {}",
-            args.status
-        )));
-    }
-    let selected = crate::state::selector::resolve_active_team(
-        &args.workspace,
-        args.team.as_deref(),
-        crate::state::selector::SelectorMode::RequireSpec,
-    )
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let mut state = selected.state;
-    let before = find_task_projection(&state, &args.task_id).unwrap_or_else(repair_task_projection_null);
-    update_task(
-        &mut state,
-        &args.task_id,
-        args.assignee.as_deref(),
-        &args.status,
-        args.summary.as_deref(),
-    );
-    let after = find_task_projection(&state, &args.task_id).unwrap_or_else(repair_task_projection_null);
-    crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)?;
-    let spec_path = selected
-        .spec_path
-        .as_ref()
-        .ok_or_else(|| CliError::Runtime("team.spec.yaml not found".to_string()))?;
-    let spec = load_team_spec_at(spec_path)?
-        .ok_or_else(|| CliError::Runtime("team.spec.yaml not found".to_string()))?;
-    let spec_workspace = selected
-        .spec_workspace
-        .as_ref()
-        .ok_or_else(|| CliError::Runtime("active team spec workspace not found".to_string()))?;
-    let state_file = crate::lifecycle::restart::write_team_state(spec_workspace, &spec, &state)
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    crate::event_log::EventLog::new(&selected.run_workspace)
-        .write(
-            "repair_state.task",
-            json!({
-                "task_id": args.task_id,
-                "before": before,
-                "after": after,
-            }),
-        )
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    Ok(CmdResult::from_json(
-        json!({
-            "ok": true,
-            "task_id": args.task_id,
-            "before": before,
-            "after": after,
-            "state_file": state_file.to_string_lossy().to_string(),
-        }),
-        args.json,
-    ))
-}
-
 /// `cmd_diagnose`(`parser.py:298`)。
 pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
     let selected = crate::state::selector::resolve_active_team(
@@ -1290,77 +1068,6 @@ fn window_target(agent_state: &Value, agent_id: &str) -> Value {
 }
 
 
-fn find_task_projection(state: &Value, task_id: &str) -> Option<Value> {
-    state
-        .get("tasks")
-        .and_then(Value::as_array)
-        .and_then(|tasks| tasks.iter().find(|task| task.get("id").and_then(Value::as_str) == Some(task_id)))
-        .map(repair_task_projection)
-}
-
-fn update_task(
-    state: &mut Value,
-    task_id: &str,
-    assignee: Option<&str>,
-    status: &str,
-    summary: Option<&str>,
-) -> Value {
-    if let Some(tasks) = state.get_mut("tasks").and_then(Value::as_array_mut) {
-        for task in tasks {
-            if task.get("id").and_then(Value::as_str) == Some(task_id) {
-                if let Some(obj) = task.as_object_mut() {
-                    if let Some(assignee) = assignee {
-                        obj.insert("assignee".to_string(), Value::String(assignee.to_string()));
-                    }
-                    obj.insert("status".to_string(), Value::String(status.to_string()));
-                    if let Some(summary) = summary {
-                        obj.insert("last_result_summary".to_string(), Value::String(summary.to_string()));
-                    }
-                    return Value::Object(obj.clone());
-                }
-            }
-        }
-    }
-    json!({
-        "id": task_id,
-        "assignee": assignee.unwrap_or(""),
-        "status": status,
-        "summary": summary.unwrap_or(""),
-    })
-}
-
-fn is_repair_task_status(status: &str) -> bool {
-    matches!(
-        status,
-        "blocked" | "cancelled" | "done" | "failed" | "needs_retry" | "pending" | "ready" | "running"
-    )
-}
-
-fn repair_task_projection(task: &Value) -> Value {
-    let mut map = serde_json::Map::new();
-    map.insert(
-        "assignee".to_string(),
-        task.get("assignee").cloned().unwrap_or(Value::Null),
-    );
-    map.insert(
-        "status".to_string(),
-        task.get("status").cloned().unwrap_or(Value::Null),
-    );
-    map.insert(
-        "last_result_summary".to_string(),
-        task.get("last_result_summary").cloned().unwrap_or(Value::Null),
-    );
-    Value::Object(map)
-}
-
-fn repair_task_projection_null() -> Value {
-    let mut map = serde_json::Map::new();
-    map.insert("assignee".to_string(), Value::Null);
-    map.insert("status".to_string(), Value::Null);
-    map.insert("last_result_summary".to_string(), Value::Null);
-    Value::Object(map)
-}
-
 fn load_team_spec_optional(workspace: &Path, state: &Value) -> Result<Option<crate::model::yaml::Value>, CliError> {
     let spec_path = state
         .get("spec_path")

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

@@ -276,7 +276,7 @@ fn coordinator_issue_value(
 
 fn coordinator_repair_hint(id: &str, _health: &crate::coordinator::HealthReport) -> Value {
     let hint_action = match id {
-        "coordinator_schema_incompatible" => "team-agent repair-state --schema",
+        "coordinator_schema_incompatible" => "team-agent doctor --fix-schema --json",
         _ => "team-agent restart",
     };
     json!({

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

@@ -96,12 +96,6 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "quick-start" => cmd_quick_start(&quick_start_args(args, cwd)?).map(emit_result),
         "compile" => cmd_compile(&compile_args(args, cwd)?).map(emit_result),
         "send" => cmd_send(&send_args(args, cwd)?).map(emit_result),
-        "fallback-send-leader" => {
-            cmd_fallback_send_leader(&fallback_send_leader_args(args, cwd)?).map(emit_result)
-        }
-        "fallback-report-result" => {
-            cmd_fallback_report_result(&fallback_report_result_args(args, cwd)?).map(emit_result)
-        }
         "allow-peer-talk" => {
             cmd_allow_peer_talk(&allow_peer_talk_args(args, cwd)?).map(emit_result)
         }
@@ -147,17 +141,10 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "validate" => cmd_validate(&validate_args(args, cwd)).map(emit_result),
         "install-skill" => cmd_install_skill(&install_skill_args(args)?).map(emit_result),
         "profile" => cmd_profile(&profile_args(args, cwd)?).map(emit_result),
-        "validate-result" if has_arg(args, "--result") => {
-            eprintln!("team-agent: error: unrecognized arguments: --result");
-            Ok(ExitCode::Usage)
-        }
-        "validate-result" => cmd_validate_result(&validate_result_args(args)?).map(emit_result),
         "collect" => {
             cmd_collect_for_team(&collect_args(args, cwd)?, parse_args(args).team.as_deref())
                 .map(emit_result)
         }
-        "settle" => cmd_settle(&settle_args(args, cwd)).map(emit_result),
-        "repair-state" => cmd_repair_state(&repair_state_args(args, cwd)?).map(emit_result),
         "diagnose" => cmd_diagnose(&diagnose_args(args, cwd)).map(emit_result),
         "preflight" => cmd_preflight(&preflight_args(args, cwd)).map(emit_result),
         "wait-ready" => cmd_wait_ready(&wait_ready_args(args, cwd)).map(emit_result),
@@ -173,8 +160,6 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "quick-start",
     "compile",
     "send",
-    "fallback-send-leader",
-    "fallback-report-result",
     "allow-peer-talk",
     "status",
     "stop",
@@ -205,10 +190,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "validate",
     "install-skill",
     "profile",
-    "validate-result",
     "collect",
-    "settle",
-    "repair-state",
     "diagnose",
     "preflight",
     "wait-ready",
@@ -327,8 +309,6 @@ fn command_help(command: Option<&str>) -> String {
         Some("start") => compat_hidden_help("start", "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]"),
         Some("compile") => "usage: team-agent compile --team TEAM [--out FILE] [--json]".to_string(),
         Some("send") => "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--to-name NAME] [--pane PANE] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]\n\nMVP: name-based cross-workspace addressing assumes trusted local caller; no auth gate.".to_string(),
-        Some("fallback-send-leader") => compat_hidden_help("fallback-send-leader", "usage: team-agent fallback-send-leader --workspace WORKSPACE --team TEAM --sender AGENT --message-id ID --content TEXT --primary-error ERROR [--task TASK] [--json]\n\nEmergency one-shot fallback only after a leader-bound MCP send transport failure; restart-agent after use."),
-        Some("fallback-report-result") => compat_hidden_help("fallback-report-result", "usage: team-agent fallback-report-result --workspace WORKSPACE --team TEAM --agent-id AGENT --task-id TASK --result-json JSON --primary-error ERROR [--json]\n\nEmergency one-shot fallback only after a report_result MCP transport failure; persists the result DB row, then restart-agent after use."),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
         Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n默认输出: worker,空闲|工作|错误；错误细分走 status --summary".to_string(),
         Some("stop") => compat_hidden_help("stop", "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]"),
@@ -358,10 +338,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("validate") => "usage: team-agent validate [SPEC] [--json]".to_string(),
         Some("install-skill") => "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]".to_string(),
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]".to_string(),
-        Some("validate-result") => "usage: team-agent validate-result [ENVELOPE] [--file FILE|--result JSON] [--json]".to_string(),
         Some("collect") => "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]".to_string(),
-        Some("settle") => "usage: team-agent settle [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
-        Some("repair-state") => "usage: team-agent repair-state --task TASK --status STATUS [SUMMARY] [--assignee AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("diagnose") => "usage: team-agent diagnose [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("preflight") => "usage: team-agent preflight [TEAMDIR] [--json]".to_string(),
         Some("wait-ready") => "usage: team-agent wait-ready [--workspace WORKSPACE] [--team TEAM] [--timeout SECONDS] [--json]".to_string(),
@@ -1059,60 +1036,6 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
     })
 }
 
-fn fallback_send_leader_args(
-    args: &[String],
-    cwd: &Path,
-) -> Result<FallbackSendLeaderArgs, CliError> {
-    let parsed = parse_args(args);
-    Ok(FallbackSendLeaderArgs {
-        workspace: workspace(&parsed, cwd),
-        team: parsed.team,
-        sender: parsed
-            .sender
-            .or(parsed.agent_id)
-            .ok_or_else(|| CliError::Usage("missing --sender <agent>".to_string()))?,
-        task: parsed.task.or(parsed.task_id),
-        message_id: parsed
-            .message_id
-            .ok_or_else(|| CliError::Usage("missing --message-id <id>".to_string()))?,
-        content: parsed
-            .content
-            .or_else(|| (!parsed.positionals.is_empty()).then(|| parsed.positionals.join(" ")))
-            .ok_or_else(|| CliError::Usage("missing --content <text>".to_string()))?,
-        primary_error: parsed
-            .primary_error
-            .ok_or_else(|| CliError::Usage("missing --primary-error <error>".to_string()))?,
-        json: parsed.json,
-    })
-}
-
-fn fallback_report_result_args(
-    args: &[String],
-    cwd: &Path,
-) -> Result<FallbackReportResultArgs, CliError> {
-    let parsed = parse_args(args);
-    Ok(FallbackReportResultArgs {
-        workspace: workspace(&parsed, cwd),
-        team: parsed.team,
-        agent_id: parsed
-            .agent_id
-            .or(parsed.sender)
-            .ok_or_else(|| CliError::Usage("missing --agent-id <agent>".to_string()))?,
-        task_id: parsed
-            .task_id
-            .or(parsed.task)
-            .ok_or_else(|| CliError::Usage("missing --task-id <task>".to_string()))?,
-        result_json: parsed
-            .result_json
-            .or_else(|| parsed.result)
-            .ok_or_else(|| CliError::Usage("missing --result-json <json>".to_string()))?,
-        primary_error: parsed
-            .primary_error
-            .ok_or_else(|| CliError::Usage("missing --primary-error <error>".to_string()))?,
-        json: parsed.json,
-    })
-}
-
 /// Stage 4 of identity-boundary unified plan (architect direction
 /// 2026-06-24, .team/artifacts/identity-boundary-unified-plan.md §2 Stage
 /// 4): destructive command ambiguity gate. When the workspace has 2+
@@ -1471,16 +1394,6 @@ fn profile_args(args: &[String], cwd: &Path) -> Result<ProfileArgs, CliError> {
     })
 }
 
-fn validate_result_args(args: &[String]) -> Result<ValidateResultArgs, CliError> {
-    let parsed = parse_args(args);
-    Ok(ValidateResultArgs {
-        envelope: parsed.positionals.first().cloned(),
-        file: parsed.file,
-        result: parsed.result,
-        json: parsed.json,
-    })
-}
-
 fn collect_args(args: &[String], cwd: &Path) -> Result<CollectArgs, CliError> {
     let parsed = parse_args(args);
     let workspace = workspace(&parsed, cwd);
@@ -1493,34 +1406,6 @@ fn collect_args(args: &[String], cwd: &Path) -> Result<CollectArgs, CliError> {
     })
 }
 
-fn settle_args(args: &[String], cwd: &Path) -> SettleArgs {
-    let parsed = parse_args(args);
-    SettleArgs {
-        workspace: workspace(&parsed, cwd),
-        team: parsed.team.clone(),
-        json: parsed.json,
-    }
-}
-
-fn repair_state_args(args: &[String], cwd: &Path) -> Result<RepairStateArgs, CliError> {
-    let parsed = parse_args(args);
-    let workspace = workspace(&parsed, cwd);
-    refuse_if_multi_alive_team_missing_scope("repair-state", &workspace, parsed.team.as_deref())?;
-    Ok(RepairStateArgs {
-        workspace,
-        task_id: parsed
-            .task
-            .ok_or_else(|| CliError::Usage("missing --task".to_string()))?,
-        assignee: parsed.assignee,
-        status: parsed
-            .status_value
-            .ok_or_else(|| CliError::Usage("missing --status".to_string()))?,
-        summary: option_value(args, "--summary").or_else(|| parsed.positionals.first().cloned()),
-        json: parsed.json,
-        team: parsed.team,
-    })
-}
-
 fn option_value(args: &[String], flag: &str) -> Option<String> {
     let prefix = format!("{flag}=");
     let mut i = 0usize;
@@ -1789,11 +1674,6 @@ mod tests {
         let top_help = command_help(None);
         let visible = visible_help_commands(&top_help);
         for command in [
-            "fallback-send-leader",
-            "fallback-report-result",
-            "repair-state",
-            "settle",
-            "validate-result",
             "leaders",
             "doctor",
             "e2e",
@@ -1809,14 +1689,7 @@ mod tests {
 
     #[test]
     fn compat_hidden_help_has_sunset_action() {
-        for command in [
-            "fallback-send-leader",
-            "fallback-report-result",
-            "stop",
-            "restart-agent",
-            "start",
-            "init",
-        ] {
+        for command in ["stop", "restart-agent", "start", "init"] {
             let help = command_help(Some(command)).to_lowercase();
             assert!(help.contains("status: hidden compatibility command"));
             assert!(help.contains("sunset: c2"));
@@ -1980,17 +1853,6 @@ mod tests {
                 &["--workspace", "--team", "--limit", "--since", "--json"][..],
             ),
             ("sessions", &["--workspace", "--team", "--json"][..]),
-            (
-                "repair-state",
-                &[
-                    "--task",
-                    "--status",
-                    "--assignee",
-                    "--workspace",
-                    "--team",
-                    "--json",
-                ][..],
-            ),
             ("diagnose", &["--workspace", "--team", "--json"][..]),
             (
                 "wait-ready",
@@ -2203,7 +2065,7 @@ mod tests {
     fn refuse_helper_refuses_when_multi_alive_team_and_no_explicit_team() {
         let ws = tmp_workspace();
         seed_two_alive_teams_in(&ws);
-        let err = refuse_if_multi_alive_team_missing_scope("repair-state", &ws, None)
+        let err = refuse_if_multi_alive_team_missing_scope("collect", &ws, None)
             .expect_err("multi-alive-team must refuse without --team");
         let message = err.to_string();
         assert!(
@@ -2215,7 +2077,7 @@ mod tests {
             "refusal must list candidate teams; got: {message}"
         );
         assert!(
-            message.contains("repair-state"),
+            message.contains("collect"),
             "refusal must name the command for diagnostic clarity; got: {message}"
         );
     }
@@ -2244,22 +2106,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn repair_state_args_builder_refuses_on_multi_alive_team_before_task_validation() {
-        let ws = tmp_workspace();
-        seed_two_alive_teams_in(&ws);
-        // The ambiguity gate must fire BEFORE `--task` / `--status` validation
-        // so the operator sees the multi-team confusion before any other
-        // usage error.
-        let argv = cli_argv(&["--workspace", &ws.to_string_lossy()]);
-        let err = repair_state_args(&argv, &ws).expect_err("must refuse");
-        let message = err.to_string();
-        assert!(
-            message.contains("multiple alive teams"),
-            "ambiguity gate must precede --task/--status validation; got: {message}"
-        );
-    }
-
     #[test]
     fn shutdown_args_builder_refuses_on_multi_alive_team() {
         let ws = tmp_workspace();