@team-agent/installer 0.5.99 → 0.5.101

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.99"
+version = "0.5.101"
 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.99"
+version = "0.5.101"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -6,100 +6,6 @@
 use super::*;
 use crate::transport::Transport;
 
-const INIT_SPEC_TEMPLATE: &str = include_str!("../model/testdata/team.spec.yaml");
-const INIT_STATE_TEMPLATE: &str = r#"# Team State
-
-Updated: not launched
-
-## Objective
-
-Pending.
-
-## Team
-
-- Name: pending
-- Runtime session: pending
-
-## Agents
-
-- Pending launch.
-
-## Task Graph
-
-- Pending task graph.
-
-## Latest Results
-
-- None.
-
-## Blockers
-
-- None.
-
-## Next Step
-
-- Run `team-agent validate team.spec.yaml`, review permissions, then run `team-agent launch team.spec.yaml --yes`.
-"#;
-
-pub fn cmd_init(args: &InitArgs) -> Result<CmdResult, CliError> {
-    let team_root = args.workspace.join(".team");
-    let spec_path = team_root.join("current").join("team.spec.yaml");
-    let state_path = args.workspace.join("team_state.md");
-    let team_md_path = args.workspace.join("TEAM.md");
-    let agents_dir = args.workspace.join("agents");
-    let default_agent_path = agents_dir.join("worker.md");
-    if spec_path.exists() && !args.force {
-        return Err(CliError::Runtime(format!(
-            "{} already exists; pass --force to overwrite",
-            spec_path.display()
-        )));
-    }
-    for dir in [
-        team_root.clone(),
-        team_root.join("current"),
-        team_root.join("runtime"),
-        team_root.join("logs"),
-        team_root.join("messages"),
-        team_root.join("artifacts"),
-        agents_dir.clone(),
-    ] {
-        std::fs::create_dir_all(&dir)?;
-    }
-    std::fs::write(&spec_path, INIT_SPEC_TEMPLATE)?;
-    if args.force || !team_md_path.exists() {
-        std::fs::write(
-            &team_md_path,
-            "---\nname: current\nobjective: Pending.\nprovider: fake\n---\n\nPending.\n",
-        )?;
-    }
-    if args.force || !default_agent_path.exists() {
-        std::fs::write(
-            &default_agent_path,
-            "---\nname: worker\nrole: Worker\nprovider: fake\ndangerously_skip_permissions: false\ntools:\n  - mcp_team\n---\n\nWait for instructions.\n",
-        )?;
-    }
-    if args.force || !state_path.exists() {
-        std::fs::write(&state_path, INIT_STATE_TEMPLATE)?;
-    }
-    crate::event_log::EventLog::new(&args.workspace)
-        .write(
-            "init",
-            json!({
-                "spec_path": spec_path.to_string_lossy().to_string(),
-                "state_path": state_path.to_string_lossy().to_string(),
-            }),
-        )
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    Ok(CmdResult::from_json(
-        json!({
-            "ok": true,
-            "spec": spec_path.to_string_lossy().to_string(),
-            "state": state_path.to_string_lossy().to_string(),
-        }),
-        args.json,
-    ))
-}
-
 /// `cmd_quick_start`(`commands.py:18`)。`--json` 或 `!ok` → 整 dict;否则 `result["summary"]`。
 pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
     let mut value = lifecycle_port::quick_start(
@@ -437,24 +343,6 @@ pub fn cmd_allow_peer_talk(args: &AllowPeerTalkArgs) -> Result<CmdResult, CliErr
     Ok(CmdResult::from_json(value, args.json))
 }
 
-/// `diagnose` is the permanent compatibility spelling for `doctor`.
-/// Keep this wrapper free of probing/reporting logic so direct Rust callers and
-/// the CLI both converge on the canonical handler.
-pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
-    cmd_doctor(&DoctorArgs {
-        spec: None,
-        workspace: args.workspace.clone(),
-        gate: None,
-        comms: false,
-        team: args.team.clone(),
-        fix: false,
-        fix_schema: false,
-        cleanup_orphans: false,
-        confirm: false,
-        json: args.json,
-    })
-}
-
 /// `cmd_preflight`(`parser.py:160`)。
 pub fn cmd_preflight(args: &PreflightArgs) -> Result<CmdResult, CliError> {
     let report = build_preflight_report(&args.team)?;
@@ -1309,50 +1197,7 @@ pub fn cmd_remove_agent(args: &RemoveAgentArgs) -> Result<CmdResult, CliError> {
     ))
 }
 
-/// `cmd_stuck_list`(`commands.py:405`)。REUSE `messaging::stuck_list`。
-pub fn cmd_stuck_list(args: &StuckListArgs) -> Result<CmdResult, CliError> {
-    let selected = crate::state::selector::resolve_active_team(
-        &args.workspace,
-        args.team.as_deref(),
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    )
-    .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let suppressed = selected
-        .state
-        .get("coordinator")
-        .and_then(|v| v.get("suppressed_idle_alerts"))
-        .and_then(|v| v.get(&selected.team_key))
-        .cloned()
-        .unwrap_or_else(|| json!({}));
-    Ok(CmdResult::from_json(
-        json!({"ok": true, "suppressed_idle_alerts": suppressed}),
-        args.json,
-    ))
-}
-
-/// `cmd_stuck_cancel`(`commands.py:409`)。REUSE `messaging::stuck_cancel`(suppressed_by="leader")。
-pub fn cmd_stuck_cancel(args: &StuckCancelArgs) -> Result<CmdResult, CliError> {
-    if args.team.is_some() {
-        return Err(CliError::Usage(
-            "stuck-cancel --team is not supported yet because stuck suppression storage is not team-scoped".to_string(),
-        ));
-    }
-    Ok(CmdResult::from_json(
-        messaging::stuck_cancel(&args.workspace, &args.agent, args.alert_type, "leader")?,
-        args.json,
-    ))
-}
-
-/// `cmd_acknowledge_idle`(`commands.py:418`)。
-pub fn cmd_acknowledge_idle(args: &AcknowledgeIdleArgs) -> Result<CmdResult, CliError> {
-    Ok(CmdResult::from_json(
-        lifecycle_port::acknowledge_idle(&args.workspace, args.team.as_deref())?,
-        args.json,
-    ))
-}
-
-/// `doctor` is the single health/diagnostic pipeline. `diagnose` enters here
-/// through the compatibility wrapper above; it never gets a second facts engine.
+/// `doctor` is the single health/diagnostic pipeline.
 pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
     if let Some(DoctorGate::Unknown(raw)) = &args.gate {
         let value = json!({

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

@@ -94,6 +94,14 @@ pub(crate) fn classify_tmux_server_error(error_text: &str) -> &'static str {
 }
 
 pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value, Value) {
+    diagnose_runtime_with_workspace(None, state, backend)
+}
+
+fn diagnose_runtime_with_workspace(
+    workspace: Option<&std::path::Path>,
+    state: &Value,
+    backend: &dyn Transport,
+) -> (Value, Value) {
     let mut issues = Vec::new();
     let mut repairs = Vec::new();
 
@@ -144,7 +152,7 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
                     let error_str = error.to_string();
                     let issue_id = classify_tmux_server_error(&error_str);
                     issues.push(json!(issue_id));
-                    let mut hint = recovery_hint(session_name, issue_id, "team-agent diagnose");
+                    let mut hint = recovery_hint(session_name, issue_id, "team-agent doctor");
                     if let Some(obj) = hint.as_object_mut() {
                         obj.insert("reason".to_string(), Value::String(error_str));
                     }
@@ -248,12 +256,25 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
                         .and_then(Value::as_str)
                         .filter(|path| !path.is_empty())
                         .map(crate::provider::RolloutPath::new);
-                    let identity_probe =
-                        crate::lifecycle::restart::session_identity_probe_for_agent(
-                            &crate::model::ids::AgentId::new(agent_id.clone()),
-                            provider,
-                            rollout_path.as_ref(),
-                        );
+                    let agent_identity = crate::model::ids::AgentId::new(agent_id.clone());
+                    let identity_probe = workspace
+                        .map(|workspace| {
+                            crate::lifecycle::restart::session_identity_probe_for_agent_with_fork_ancestry(
+                                workspace,
+                                state,
+                                &agent_identity,
+                                agent_state,
+                                provider,
+                                rollout_path.as_ref(),
+                            )
+                        })
+                        .unwrap_or_else(|| {
+                            crate::lifecycle::restart::session_identity_probe_for_agent(
+                                &agent_identity,
+                                provider,
+                                rollout_path.as_ref(),
+                            )
+                        });
                     if identity_probe.identity_ok == Some(false) {
                         let issue = format!("session_identity_mismatch:{agent_id}");
                         issues.push(json!(issue));
@@ -304,7 +325,8 @@ pub(crate) fn diagnose_runtime_for_workspace(
     selected_team_key: Option<&str>,
     coordinator_health: &crate::coordinator::HealthReport,
 ) -> (Value, Value) {
-    let (mut issues, mut repairs) = diagnose_runtime(state, backend);
+    let (mut issues, mut repairs) =
+        diagnose_runtime_with_workspace(Some(workspace), state, backend);
     append_live_leader_workspace_mismatch_issue(
         workspace,
         state,
@@ -947,7 +969,7 @@ fn topology_repair_hint(issue: &str) -> Value {
         "action_required": true,
         "advisory": true,
         "broken_class": issue,
-        "hint_action": "team-agent diagnose --json",
+        "hint_action": "team-agent doctor --json",
         "dedupe_key": issue,
         "action": "repair the tmux topology mismatch, then rerun team-agent restart",
     })
@@ -1605,7 +1627,7 @@ pub(crate) fn build_wait_ready_report(
             "workers_not_ready",
             "workers not ready before timeout",
             vec![json!(
-                "inspect team-agent diagnose output and worker terminals"
+                "inspect team-agent doctor output and worker terminals"
             )],
         )
     };

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

@@ -2,8 +2,10 @@
 //! cli · emit — `emit`(--json vs 人读 dict 逐键)+ 顶层 `run` 调度(parser.py `main`)+
 //! 人读标量/集合渲染(`human_value` / `json_dumps_like`)。
 
-use super::spec::{command_spec, CommandKind, CommandTier, ALL_DISPATCH_KINDS, COMMAND_SPECS};
 use super::models::cmd_models;
+use super::spec::{command_spec, CommandKind, COMMAND_SPECS};
+#[cfg(test)]
+use super::spec::{CommandTier, ALL_DISPATCH_KINDS};
 use super::*;
 use std::io::{ErrorKind, Write as _};
 
@@ -171,16 +173,11 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
     };
     match spec.kind {
         CommandKind::Dispatch(_) => {}
-        CommandKind::SpecOnlyAlias { .. } => {
-            eprintln!("{}", command_help(Some(command)));
-            return Ok(ExitCode::Usage);
-        }
         CommandKind::LeaderPassthrough { .. } => {
             return Ok(emit_unknown_subcommand_usage(command));
         }
     }
     match command {
-        "init" => cmd_init(&init_args(args, cwd)).map(emit_result),
         "quick-start" => cmd_quick_start(&quick_start_args(args, cwd)?).map(emit_result),
         "send" => cmd_send(&send_args(args, cwd)?).map(emit_result),
         "allow-peer-talk" => {
@@ -188,10 +185,8 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         }
         "status" => cmd_status_for_team(&status_args(args, cwd), parse_args(args).team.as_deref())
             .map(emit_result),
-        "stop" => cmd_shutdown(&shutdown_args(args, cwd)?).map(emit_result),
         "shutdown" => cmd_shutdown(&shutdown_args(args, cwd)?).map(emit_result),
         "restart" => cmd_restart(&restart_args(args, cwd)?).map(emit_result),
-        "restart-agent" => cmd_reset_agent(&reset_agent_args(args, cwd)?).map(emit_result),
         "start-agent" => cmd_start_agent(&start_agent_args(args, cwd)?).map(emit_result),
         "stop-agent" => cmd_stop_agent(&stop_agent_args(args, cwd)?).map(emit_result),
         "reset-agent" => cmd_reset_agent(&reset_agent_args(args, cwd)?).map(emit_result),
@@ -199,11 +194,6 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "clone-agent" => cmd_clone_agent(&clone_agent_args(args, cwd)?).map(emit_result),
         "fork-agent" => cmd_fork_agent(&fork_agent_args(args, cwd)?).map(emit_result),
         "remove-agent" => cmd_remove_agent(&remove_agent_args(args, cwd)?).map(emit_result),
-        "stuck-list" => cmd_stuck_list(&stuck_list_args(args, cwd)).map(emit_result),
-        "stuck-cancel" => cmd_stuck_cancel(&stuck_cancel_args(args, cwd)?).map(emit_result),
-        "acknowledge-idle" => {
-            cmd_acknowledge_idle(&acknowledge_idle_args(args, cwd)).map(emit_result)
-        }
         "takeover" => cmd_takeover(&takeover_args(args, cwd)).map(emit_result),
         "claim-leader" => cmd_claim_leader(&claim_leader_args(args, cwd)).map(emit_result),
         // Real dispatch: `cmd_attach_leader` writes the `leader_receiver` binding.
@@ -232,8 +222,6 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "profile" => cmd_profile(&profile_args(args, cwd)?).map(emit_result),
         "results" => cmd_results(&results_args(args, cwd)?).map(emit_result),
         "wait" => cmd_wait(&wait_args(args, cwd)?).map(emit_result),
-        // Compatibility spelling: parse and execute the exact doctor contract.
-        "diagnose" => cmd_doctor(&doctor_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),
         "e2e" => cmd_e2e(&e2e_args(args, cwd)).map(emit_result),
@@ -243,58 +231,6 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
     }
 }
 
-const DISPATCH_COMMANDS: &[&str] = &[
-    "init",
-    "quick-start",
-    "send",
-    "allow-peer-talk",
-    "status",
-    "stop",
-    "shutdown",
-    "restart",
-    "restart-agent",
-    "start-agent",
-    "stop-agent",
-    "reset-agent",
-    "add-agent",
-    "fork-agent",
-    "remove-agent",
-    "stuck-list",
-    "stuck-cancel",
-    "acknowledge-idle",
-    "takeover",
-    "claim-leader",
-    "attach-leader",
-    "attach-app-server-leader",
-    "identity",
-    "approvals",
-    "inbox",
-    "doctor",
-    "watch",
-    "sessions",
-    // 0.5.9 E7: host leader discovery command surface.
-    "leaders",
-    "models",
-    "validate",
-    "install-skill",
-    "profile",
-    "results",
-    "wait",
-    "diagnose",
-    "preflight",
-    "wait-ready",
-    "e2e",
-    "peek",
-    "coordinator",
-];
-
-// 0.5.26 (`.team/artifacts/stale-team-saveconflict-locate.md` §7.6):
-// `purge-agent` was previously listed in help but had no dispatch arm,
-// so it read as a supported recovery command while actually failing with
-// "invalid choice". The dispatch registration remains out of scope for
-// 0.5.26 (destructive semantics deserve their own CR); keep the help
-// consistent with the dispatch table so it is no longer advertised.
-const SPEC_ONLY_HELP_COMMANDS: &[&str] = &["start"];
 // Command grammar, not provider identity parsing: these are top-level CLI
 // passthrough verbs for starting a leader under a provider executable.
 const LEADER_PASSTHROUGH_COMMANDS: &[&str] =
@@ -370,18 +306,6 @@ fn append_help_section(out: &mut String, title: &str, names: &[&str]) {
     }
 }
 
-fn compat_hidden_help(command: &str, usage: &str) -> String {
-    let Some(spec) = command_spec(command) else {
-        return usage.to_string();
-    };
-    if spec.tier != CommandTier::CompatHidden {
-        return usage.to_string();
-    }
-    let sunset = spec.sunset.unwrap_or("C2");
-    let action = spec.action.unwrap_or("use a supported command");
-    format!("{usage}\n\nstatus: hidden compatibility command\nsunset: {sunset}\naction: {action}")
-}
-
 ///
 /// Test-only public accessor for `command_help` — allows integration
 /// tests to grep the help copy without depending on internal parser
@@ -404,9 +328,7 @@ pub fn __test_quick_start_args(
 fn command_help(command: Option<&str>) -> String {
     match command {
         None => default_help(),
-        Some("init") => compat_hidden_help("init", "usage: team-agent init [--workspace WORKSPACE] [--force] [--json]"),
         Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--backend tmux|conpty] [--json] [--detail]\n\n--backend selects the worker transport: tmux (default on POSIX) or conpty (Windows-native ConPTY worker transport; requires the shim binary and Windows host).\n\n--detail includes internal receiver/topology diagnostics in JSON output.\n\nAfter a successful start, use the returned `send_commands` (or choose an agent explicitly) with `team-agent send AGENT MESSAGE`.".to_string(),
-        Some("start") => compat_hidden_help("start", "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]"),
         Some("send") => concat!(
             "usage: team-agent send TO MESSAGE... ",
             "[--workspace WORKSPACE] [--team TEAM] ",
@@ -420,10 +342,8 @@ fn command_help(command: Option<&str>) -> String {
         Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出七字段：name/provider/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。缺少可靠定位或原生 tmux/process 采样时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
         Some("models") => "usage: team-agent models [--provider pi|cursor_agent] [QUERY|--search TEXT] [--json]\n\nLists exact provider model ids with case-insensitive multi-word search across provider, vendor, id, and display name. Cursor uses the local `agent --list-models` catalog.".to_string(),
         Some("leaders") => "usage: team-agent leaders [QUERY|--search TEXT] [--all|--stale] [--json] | --prune [--dry-run] [--json]\n\nLists LIVE leaders by default. Use --all to include retained STALE entries, --stale to inspect only STALE entries, QUERY or --search TEXT to match workspace/team/name fields, and --prune to remove only entries proven terminal by canonical state. --dry-run is valid only with --prune.".to_string(),
-        Some("stop") => compat_hidden_help("stop", "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]"),
         Some("shutdown") => "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
         Some("restart") => "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json] [--detail]".to_string(),
-        Some("restart-agent") => compat_hidden_help("restart-agent", "usage: team-agent restart-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--discard-session] [--json]"),
         Some("reset-agent") => "usage: team-agent reset-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--discard-session] [--json]".to_string(),
         Some("start-agent") => "usage: team-agent start-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--force] [--allow-fresh] [--json]\n\nAfter a successful start, use the returned `send_commands` with `team-agent send AGENT MESSAGE`.".to_string(),
         Some("stop-agent") => "usage: team-agent stop-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
@@ -432,9 +352,6 @@ fn command_help(command: Option<&str>) -> String {
         Some("fork-agent") => "usage: team-agent fork-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("remove-agent") => "usage: team-agent remove-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--from-spec] [--confirm] [--force] [--json]".to_string(),
         // 0.5.26 (§7.6): removed from help; dispatch was never wired.
-        Some("stuck-list") => "usage: team-agent stuck-list [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
-        Some("stuck-cancel") => "usage: team-agent stuck-cancel AGENT [--workspace WORKSPACE] [--alert-type stuck|idle_fallback|cross_worker_deadlock|all] [--json]".to_string(),
-        Some("acknowledge-idle") => "usage: team-agent acknowledge-idle [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("takeover") => "usage: team-agent takeover [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]".to_string(),
         Some("claim-leader") => "usage: team-agent claim-leader [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json] [--detail]".to_string(),
         Some("attach-leader") => "usage: team-agent attach-leader [--workspace WORKSPACE] [--team TEAM] [--pane PANE] [--provider PROVIDER] [--confirm] [--json]".to_string(),
@@ -450,7 +367,6 @@ fn command_help(command: Option<&str>) -> String {
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--proxy-mode direct|inherit] [--json]".to_string(),
         Some("results") => "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("wait") => "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]".to_string(),
-        Some("diagnose") => "usage: team-agent doctor [SPEC] [--workspace WORKSPACE] [--team TEAM] [--gate orphans|comms] [--comms] [--fix] [--fix-schema] [--cleanup-orphans] [--confirm] [--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(),
         Some("e2e") => "usage: team-agent e2e [--workspace WORKSPACE] [--providers LIST] [--real] [--json]".to_string(),
@@ -838,7 +754,6 @@ struct ParsedArgs {
     label: Option<String>,
     from_spec: bool,
     confirm: bool,
-    alert_type: Option<String>,
     limit: Option<usize>,
     gate: Option<String>,
     comms: bool,
@@ -929,7 +844,6 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--label" => parsed.label = next_arg(args, &mut i),
             "--from-spec" => parsed.from_spec = true,
             "--confirm" => parsed.confirm = true,
-            "--alert-type" => parsed.alert_type = next_arg(args, &mut i),
             "-n" | "--limit" => {
                 parsed.limit = next_arg(args, &mut i).and_then(|v| v.parse::<usize>().ok())
             }
@@ -1136,15 +1050,6 @@ fn models_args(args: &[String]) -> Result<ModelsArgs, CliError> {
     })
 }
 
-fn init_args(args: &[String], cwd: &Path) -> InitArgs {
-    let parsed = parse_args(args);
-    InitArgs {
-        workspace: workspace(&parsed, cwd),
-        force: parsed.force,
-        json: parsed.json,
-    }
-}
-
 fn resolve_cli_path(cwd: &Path, path: &Path) -> PathBuf {
     if path.is_absolute() {
         path.to_path_buf()
@@ -1616,48 +1521,6 @@ fn remove_agent_args(args: &[String], cwd: &Path) -> Result<RemoveAgentArgs, Cli
     })
 }
 
-fn stuck_list_args(args: &[String], cwd: &Path) -> StuckListArgs {
-    let parsed = parse_args(args);
-    StuckListArgs {
-        workspace: workspace(&parsed, cwd),
-        json: parsed.json,
-        team: parsed.team,
-    }
-}
-
-fn stuck_cancel_args(args: &[String], cwd: &Path) -> Result<StuckCancelArgs, CliError> {
-    let parsed = parse_args(args);
-    let workspace = workspace(&parsed, cwd);
-    refuse_if_multi_alive_team_missing_scope("stuck-cancel", &workspace, parsed.team.as_deref())?;
-    Ok(StuckCancelArgs {
-        agent: required_pos(&parsed, 0, "agent")?,
-        workspace,
-        alert_type: alert_type(parsed.alert_type.as_deref())?,
-        json: parsed.json,
-        team: parsed.team,
-    })
-}
-
-fn alert_type(raw: Option<&str>) -> Result<Option<AlertType>, CliError> {
-    match raw {
-        Some("stuck") => Ok(Some(AlertType::Stuck)),
-        Some("idle_fallback") => Ok(Some(AlertType::IdleFallback)),
-        Some("cross_worker_deadlock") => Ok(Some(AlertType::CrossWorkerDeadlock)),
-        Some("all") | None => Ok(None),
-        Some(other) => Err(CliError::Usage(format!("invalid --alert-type: {other}"))),
-    }
-}
-
-fn acknowledge_idle_args(args: &[String], cwd: &Path) -> AcknowledgeIdleArgs {
-    let parsed = parse_args(args);
-    let workspace = workspace(&parsed, cwd);
-    AcknowledgeIdleArgs {
-        team: parsed.team,
-        workspace,
-        json: parsed.json,
-    }
-}
-
 fn doctor_args(args: &[String], cwd: &Path) -> DoctorArgs {
     let parsed = parse_args(args);
     DoctorArgs {
@@ -1863,15 +1726,6 @@ fn option_value(args: &[String], flag: &str) -> Option<String> {
     None
 }
 
-fn diagnose_args(args: &[String], cwd: &Path) -> DiagnoseArgs {
-    let parsed = parse_args(args);
-    DiagnoseArgs {
-        workspace: workspace(&parsed, cwd),
-        json: parsed.json,
-        team: parsed.team,
-    }
-}
-
 fn preflight_args(args: &[String], cwd: &Path) -> PreflightArgs {
     let parsed = parse_args(args);
     let team = parsed
@@ -2064,7 +1918,7 @@ mod tests {
     }
 
     #[test]
-    fn command_specs_have_unique_names_and_valid_aliases() {
+    fn command_specs_have_unique_names() {
         let mut names = std::collections::BTreeSet::new();
         for spec in COMMAND_SPECS {
             assert!(
@@ -2073,15 +1927,6 @@ mod tests {
                 spec.name
             );
         }
-        for spec in COMMAND_SPECS {
-            if let Some(alias_of) = spec.alias_of {
-                assert!(
-                    names.contains(alias_of),
-                    "`{}` aliases missing command `{alias_of}`",
-                    spec.name
-                );
-            }
-        }
     }
 
     #[test]
@@ -2152,7 +1997,7 @@ mod tests {
         let top_help = command_help(None);
         let visible = visible_help_commands(&top_help);
         assert!(visible.iter().any(|command| command == "doctor"));
-        for command in ["leaders", "diagnose", "e2e", "peek", "coordinator"] {
+        for command in ["leaders", "e2e", "peek", "coordinator"] {
             assert!(
                 !visible.iter().any(|visible| visible == command),
                 "`{command}` must stay hidden from default help"
@@ -2170,16 +2015,6 @@ mod tests {
         assert!(help.contains("--dry-run"));
     }
 
-    #[test]
-    fn compat_hidden_help_has_sunset_action() {
-        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"));
-            assert!(help.contains("action:"));
-        }
-    }
-
     #[test]
     fn observation_a_commands_have_terminal_tiers() {
         for (command, tier) in [
@@ -2187,7 +2022,6 @@ mod tests {
             ("approvals", CommandTier::Secondary),
             ("profile", CommandTier::Secondary),
             ("install-skill", CommandTier::Secondary),
-            ("init", CommandTier::CompatHidden),
         ] {
             assert_eq!(command_spec(command).map(|spec| spec.tier), Some(tier));
         }
@@ -2309,14 +2143,13 @@ mod tests {
                     "--json",
                 ][..],
             ),
-            ("stuck-list", &["--workspace", "--team", "--json"][..]),
+            ("stop-agent", &["--workspace", "--team", "--json"][..]),
             ("approvals", &["--workspace", "--team", "--json"][..]),
             (
                 "inbox",
                 &["--workspace", "--team", "-n", "--limit", "--json"][..],
             ),
             ("sessions", &["--workspace", "--team", "--json"][..]),
-            ("diagnose", &["--workspace", "--team", "--json"][..]),
             (
                 "wait-ready",
                 &["--workspace", "--team", "--timeout", "--json"][..],
@@ -2621,18 +2454,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn stuck_cancel_args_builder_refuses_on_multi_alive_team() {
-        let ws = tmp_workspace();
-        seed_two_alive_teams_in(&ws);
-        let argv = cli_argv(&["worker_a", "--workspace", &ws.to_string_lossy()]);
-        let err = stuck_cancel_args(&argv, &ws).expect_err("must refuse");
-        assert!(
-            err.to_string().contains("multiple alive teams"),
-            "stuck-cancel args builder must surface the refusal; got: {err}"
-        );
-    }
-
     #[test]
     fn shutdown_args_builder_refuses_on_multi_alive_team() {
         let ws = tmp_workspace();