@team-agent/installer 0.5.99 → 0.5.100

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

@@ -106,92 +106,6 @@ fn seed_team_spec(ws: &std::path::Path) {
     std::fs::write(ws.join("team.spec.yaml"), spec).unwrap();
 }
 
-// ── ACK-CRACK [P1 byte-shape] — acknowledge_idle must write golden's TTL suppression shape ───────
-// golden runtime.py:680-688: manual-acknowledge persists
-//   coordinator.idle_acknowledged[team] = {acknowledged_at, expires_at, ttl_seconds}
-//   coordinator.suppressed_idle_alerts[team][worker].idle_fallback =
-//     {suppressed_at, suppressed_by:"manual_acknowledge", manual_acknowledge:true, expires_at, ttl_seconds}
-// The clear logic does datetime.fromisoformat(entry["expires_at"]); a MISSING expires_at -> ValueError
-// -> "invalid_suppression_timestamp" -> immediate self-clear (latent crack once detect_idle_fallbacks
-// is ported). So BOTH idle_acknowledged and the entry MUST carry a non-empty expires_at.
-#[test]
-fn acknowledge_idle_writes_golden_ttl_suppression_shape() {
-    let ws = tmp_workspace();
-    crate::state::persist::save_runtime_state(
-        &ws,
-        &serde_json::json!({
-            "active_team_key": "teamX",
-            "agents": {"w1": {"status": "running", "provider": "codex"}}
-        }),
-    )
-    .unwrap();
-    let _ = lifecycle_port::acknowledge_idle(&ws, None).expect("acknowledge_idle ok");
-    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    let ack = &state["coordinator"]["idle_acknowledged"]["teamX"];
-    assert!(
-        ack.get("expires_at")
-            .and_then(serde_json::Value::as_str)
-            .is_some_and(|s| !s.is_empty()),
-        "ACK-CRACK: idle_acknowledged[team] must carry a non-empty expires_at (golden); got {ack}"
-    );
-    assert!(
-        ack.get("ttl_seconds").is_some(),
-        "idle_acknowledged[team] must carry ttl_seconds; got {ack}"
-    );
-    let entry = &state["coordinator"]["suppressed_idle_alerts"]["teamX"]["w1"]["idle_fallback"];
-    assert!(
-            entry.get("expires_at").and_then(serde_json::Value::as_str).is_some_and(|s| !s.is_empty()),
-            "ACK-CRACK: the manual-ack suppression entry must carry expires_at (else clear logic ValueErrors \
-             -> instant self-clear); got {entry}"
-        );
-    assert_eq!(
-        entry["suppressed_by"],
-        serde_json::json!("manual_acknowledge"),
-        "golden suppressed_by; got {entry}"
-    );
-    assert_eq!(
-        entry["manual_acknowledge"],
-        serde_json::json!(true),
-        "golden manual_acknowledge:true; got {entry}"
-    );
-}
-// ── ACK return-shape [P1 byte-parity] — acknowledge_idle must RETURN golden's keys ───────────────
-// golden runtime.py:691: return {ok, team, agent_id, acknowledged_at, expires_at, ttl_seconds}.
-// Rust (cli/mod.rs) returns only {ok, team, ttl_seconds} -> missing agent_id, acknowledged_at,
-// expires_at. RED. (acknowledged_at/expires_at are the same values written into idle_acknowledged.)
-#[test]
-fn acknowledge_idle_return_carries_golden_keys() {
-    let ws = tmp_workspace();
-    crate::state::persist::save_runtime_state(
-            &ws,
-            &serde_json::json!({ "active_team_key": "teamX", "agents": {"w1": {"status": "running", "provider": "codex"}} }),
-        )
-        .unwrap();
-    let r = lifecycle_port::acknowledge_idle(&ws, None).expect("acknowledge_idle ok");
-    let obj = r.as_object().expect("ack returns a dict");
-    for key in [
-        "ok",
-        "team",
-        "agent_id",
-        "acknowledged_at",
-        "expires_at",
-        "ttl_seconds",
-    ] {
-        assert!(
-            obj.contains_key(key),
-            "ACK return-shape: golden return carries `{key}` (runtime.py:691: ok/team/agent_id/\
-                 acknowledged_at/expires_at/ttl_seconds); Rust omits it. got keys {:?}",
-            obj.keys().collect::<Vec<_>>()
-        );
-    }
-    assert!(
-        obj.get("expires_at")
-            .and_then(serde_json::Value::as_str)
-            .is_some_and(|s| !s.is_empty()),
-        "ACK return-shape: expires_at must be a non-empty timestamp; got {r}"
-    );
-    let _ = std::fs::remove_dir_all(&ws);
-}
 // ── BUG-2 [real bug] — inbox must RETURN the stored messages, not a hardcoded []. ────────────────
 // Golden status/inbox.py:35-38 -> MessageStore.inbox(agent_id) (core.py:242, owner_team_id=None):
 //   select <MESSAGE_SELECT> from messages where sender = ? or recipient = ? order by created_at desc
@@ -680,16 +594,7 @@ fn remove_agent_from_spec_refusal_is_not_success_envelope() {
 fn stuck_cancel_persists_suppression_and_stuck_list_reads_state() {
     let ws = tmp_workspace();
     seed_collect_state(&ws);
-    let out = json_output(
-        cmd_stuck_cancel(&StuckCancelArgs {
-            agent: "fake_impl".to_string(),
-            workspace: ws.clone(),
-            alert_type: None,
-            json: true,
-            team: None,
-        })
-        .unwrap(),
-    );
+    let out = messaging::stuck_cancel(&ws, "fake_impl", None, "leader").unwrap();
     let team_key = seeded_team_key(&ws);
     assert_eq!(out["ok"], json!(true));
     assert_eq!(
@@ -715,98 +620,10 @@ fn stuck_cancel_persists_suppression_and_stuck_list_reads_state() {
                 && e["agent_id"] == json!("fake_impl")),
         "stuck_cancel must write coordinator.idle_alert_suppressed"
     );
-    let listed = json_output(
-        cmd_stuck_list(&StuckListArgs {
-            workspace: ws.clone(),
-            json: true,
-            team: None,
-        })
-        .unwrap(),
-    );
+    let listed = messaging::stuck_list(&ws).unwrap();
     assert_eq!(
         listed["suppressed_idle_alerts"]["fake_impl"]["stuck"]["suppressed_by"],
         json!("leader"),
         "stuck-list must read the persisted state mirror, not return a hard-coded empty list"
     );
 }
-
-#[test]
-fn stuck_cancel_explicit_team_is_rejected_until_backend_is_scoped() {
-    let ws = tmp_workspace();
-    seed_collect_state(&ws);
-    let err = cmd_stuck_cancel(&StuckCancelArgs {
-        agent: "fake_impl".to_string(),
-        workspace: ws.clone(),
-        alert_type: None,
-        json: true,
-        team: Some("current".to_string()),
-    })
-    .expect_err("explicit --team must not silently write global stuck suppression");
-    assert!(
-            err.to_string().contains("not supported yet"),
-            "stuck-cancel --team must be an explicit refusal until backend supports scoped writes; got {err}"
-        );
-    let _ = std::fs::remove_dir_all(&ws);
-}
-
-#[test]
-fn stuck_cancel_invalid_alert_type_is_rejected() {
-    let ws = tmp_workspace();
-    seed_collect_state(&ws);
-    let code = run(
-        &cli_argv(&[
-            "stuck-cancel",
-            "fake_impl",
-            "--workspace",
-            &ws.to_string_lossy(),
-            "--alert-type",
-            "bogus",
-            "--json",
-        ]),
-        &ws,
-    );
-    assert_eq!(
-            code,
-            ExitCode::Error,
-            "Python rejects alert_type outside stuck/idle_fallback/cross_worker_deadlock/all; Rust must not silently coerce bogus to stuck"
-        );
-}
-#[test]
-fn acknowledge_idle_records_manual_idle_fallback_suppression_and_event() {
-    let ws = tmp_workspace();
-    seed_collect_state(&ws);
-    let out = json_output(
-        cmd_acknowledge_idle(&AcknowledgeIdleArgs {
-            team: None,
-            workspace: ws.clone(),
-            json: true,
-        })
-        .unwrap(),
-    );
-    let team_key = seeded_team_key(&ws);
-    assert_eq!(out["ok"], json!(true));
-    assert_eq!(out["team"], json!(team_key));
-    assert_eq!(out["ttl_seconds"], json!(1800));
-    let state = read_state(&ws);
-    let ack = &state["coordinator"]["idle_acknowledged"][&team_key];
-    assert_eq!(ack["ttl_seconds"], json!(1800));
-    assert!(ack["acknowledged_at"].as_str().is_some());
-    assert_eq!(
-        state["coordinator"]["suppressed_idle_alerts"][&team_key]["fake_impl"]["idle_fallback"]
-            ["suppressed_by"],
-        json!("manual_acknowledge")
-    );
-    assert_eq!(
-        state["coordinator"]["suppressed_idle_alerts"][&team_key]["fake_impl"]["idle_fallback"]
-            ["manual_acknowledge"],
-        json!(true)
-    );
-    assert!(
-        read_events(&ws)
-            .iter()
-            .any(|e| e["event"] == json!("coordinator.idle_acknowledged")
-                && e["team"] == json!(team_key)
-                && e["ttl_seconds"] == json!(1800)),
-        "acknowledge-idle must emit coordinator.idle_acknowledged"
-    );
-}

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

@@ -332,15 +332,15 @@ fn dispatch_routes_diagnose_checks_runtime_beyond_healthy_leader() {
             leader_env: Default::default(),
         }]);
     crate::transport_factory::with_leader_endpoint_transport(endpoint, transport, || {
-        for command in ["doctor", "diagnose"] {
-            let code = run(
-                &cli_argv(&[command, "--workspace", &ws.to_string_lossy(), "--json"]),
-                &ws,
-            );
-            assert_eq!(code, ExitCode::Error, "healthy binding alone cannot hide missing coordinator");
-        }
-        let result = cmd_diagnose(&DiagnoseArgs {
+        let code = run(
+            &cli_argv(&["doctor", "--workspace", &ws.to_string_lossy(), "--json"]),
+            &ws,
+        );
+        assert_eq!(code, ExitCode::Error, "healthy binding alone cannot hide missing coordinator");
+        let result = cmd_doctor(&DoctorArgs {
             workspace: ws.clone(), json: true, team: None,
+            spec: None, gate: None, comms: false, fix: false,
+            fix_schema: false, cleanup_orphans: false, confirm: false,
         }).expect("diagnostic report");
         let CmdOutput::Json(report) = result.output else {
             panic!("expected JSON diagnostic report");
@@ -377,7 +377,7 @@ fn dispatch_routes_diagnose_self_signed_attached_without_registry_is_not_ok() {
     let ws = tmp_workspace();
     seed_self_signed_attached_leader(&ws);
     let code = run(
-        &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
+        &cli_argv(&["doctor", "--workspace", &ws.to_string_lossy(), "--json"]),
         &ws,
     );
     assert_ne!(

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

@@ -138,7 +138,7 @@ mod tests {
             "providers": {"claude": {"version": "secret"}},
             "runtime": {"workspace": "/tmp/secret"}
         });
-        let output = render("diagnose", &report);
+        let output = render("doctor", &report);
         assert!(output.contains("issue: short_issue"));
         assert!(output.contains("issue: code=object_issue"));
         assert!(output.contains("repair: action=run repair"));

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

@@ -312,14 +312,6 @@ pub struct QuickStartArgs {
     // user-confirmed. quick-start is now an initial-creation-only verb.
 }
 
-/// `init`(`parser.py` bootstrap verb)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct InitArgs {
-    pub workspace: PathBuf,
-    pub force: bool,
-    pub json: bool,
-}
-
 /// `send`(`parser.py:262`)。`target` xor `--to`(fanout);`message` 多 token join 空格。
 #[derive(Debug, Clone, PartialEq)]
 pub struct SendArgs {
@@ -554,36 +546,6 @@ pub struct RemoveAgentArgs {
     pub json: bool,
 }
 
-/// `stuck-list`(`parser.py:424`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StuckListArgs {
-    pub workspace: PathBuf,
-    pub json: bool,
-    /// Stage 4: explicit `--team` scope (read-only enumeration).
-    pub team: Option<String>,
-}
-
-/// `stuck-cancel`(`parser.py:429`)。`--alert-type` ∈ {stuck, idle_fallback, all},默认 stuck。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StuckCancelArgs {
-    pub agent: String,
-    pub workspace: PathBuf,
-    /// `None` 表 `all`(展开全集);`Some(AlertType)` 表单类型。
-    pub alert_type: Option<AlertType>,
-    pub json: bool,
-    /// Parsed but rejected until stuck suppression storage grows a team-scoped
-    /// backend selector.
-    pub team: Option<String>,
-}
-
-/// `acknowledge-idle`(`parser.py:436`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AcknowledgeIdleArgs {
-    pub team: Option<String>,
-    pub workspace: PathBuf,
-    pub json: bool,
-}
-
 /// `doctor`(`parser.py:318`)。`--gate` ∈ {orphans, comms};`--fix` 须配 `--gate`(`cmd_doctor` 校验)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DoctorArgs {
@@ -683,17 +645,6 @@ pub struct WaitArgs {
     pub json: bool,
 }
 
-/// `diagnose` compatibility spelling for the canonical `doctor` health report.
-/// The CLI normalizes it to `DoctorArgs`; this narrow type remains for direct
-/// Rust callers that used the pre-unification API.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct DiagnoseArgs {
-    pub workspace: PathBuf,
-    pub json: bool,
-    /// Stage 4: explicit `--team` scope (read-only health report).
-    pub team: Option<String>,
-}
-
 /// `preflight`(`parser.py:160`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PreflightArgs {

package/crates/team-agent/src/leader/lease.rs

@@ -1313,7 +1313,7 @@ fn apply_endpoint_convergence(
                 "persisted": false,
                 "checked_paths": convergence_checked_paths(team_id.as_str()),
                 "action": format!(
-                    "old tmux endpoint {old_endpoint} still has this team's session or pane tuple; run team-agent diagnose --json before retrying restart"
+                    "old tmux endpoint {old_endpoint} still has this team's session or pane tuple; run team-agent doctor --json before retrying restart"
                 ),
             })),
             false,

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -336,7 +336,7 @@ fn restart_with_selected_team_and_transport(
                 .first()
                 .cloned()
                 .unwrap_or_else(|| "dirty_topology".to_string()),
-            error: "restart refused: tmux endpoint/socket topology is inconsistent; run diagnose from the intended leader socket before restarting".to_string(),
+            error: "restart refused: tmux endpoint/socket topology is inconsistent; run doctor from the intended leader socket before restarting".to_string(),
             issue_ids: topology_issue_ids,
         });
     }
@@ -1804,7 +1804,7 @@ fn restart_readiness_timeout_message(
          - tmux session created: {session}\n\
          - worker pane addressable: {pane}\n\
          - coordinator alive: {coordinator}\n\
-         Action: check coordinator log {log}, then inspect this workspace with `team-agent diagnose --workspace '{workspace}'`\n\
+         Action: check coordinator log {log}, then inspect this workspace with `team-agent doctor --workspace '{workspace}'`\n\
          Log: coordinator_log={log} state={state} pid_file={pid}",
         missing = restart_readiness_missing_summary(readiness),
         session = yes_no(readiness.session_created),
@@ -2703,7 +2703,7 @@ fn restart_failure_phase(
     // 0.5.39 Slice 1 (tmux-server-death-locate §11.1 B): promote
     // spawn/readiness errors whose stderr contains "server exited
     // unexpectedly" to `tmux_server_crashed`, so downstream event
-    // classification and diagnose next_actions ("team-agent diagnose")
+    // classification and doctor next_actions ("team-agent doctor")
     // don't misattribute a whole-server death to a per-agent provider
     // failure. Restart itself does not recover from server crashes in
     // 0.5.39 (§11.1 C is Slice 3, later car); it just classifies clearly.
@@ -2776,7 +2776,7 @@ fn write_restart_agent_failed_event(
                 "phase": phase,
                 "error": error,
                 "action": format!(
-                    "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                    "inspect worker {} output, then reset that worker with `team-agent reset-agent {} --discard-session` or rerun `team-agent restart --allow-fresh`",
                     decision.agent_id,
                     decision.agent_id
                 ),
@@ -3262,7 +3262,7 @@ fn restart_failure_next_actions(failed_agents: &[RestartFailedAgent]) -> Vec<Str
         .iter()
         .map(|failure| {
             format!(
-                "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                "inspect worker {} output, then reset that worker with `team-agent reset-agent {} --discard-session` or rerun `team-agent restart --allow-fresh`",
                 failure.agent_id, failure.agent_id
             )
         })
@@ -4911,7 +4911,7 @@ tasks:
             },
             std::time::Duration::from_secs(30),
         );
-        assert!(message.contains("team-agent diagnose --workspace"));
+        assert!(message.contains("team-agent doctor --workspace"));
         assert!(message.contains(workspace.to_string_lossy().as_ref()));
         assert!(!message.contains("--allow-fresh"));
         assert!(!message.contains("restart <agent>"));

package/crates/team-agent/src/lifecycle/tests/b0_reader_hideone_audit_contract.rs

@@ -122,7 +122,7 @@ fn stale_snapshot_cannot_flip_status_or_diagnose_ok_readiness() {
         "--json",
     ]);
     let diagnose_before = case.run_json(&[
-        "diagnose",
+        "doctor",
         "--workspace",
         case.workspace_str(),
         "--team",
@@ -142,7 +142,7 @@ fn stale_snapshot_cannot_flip_status_or_diagnose_ok_readiness() {
         "--json",
     ]);
     let diagnose_after = case.run_json(&[
-        "diagnose",
+        "doctor",
         "--workspace",
         case.workspace_str(),
         "--team",

package/crates/team-agent/src/lifecycle/tests/claude_profile_launch_red.rs

@@ -182,7 +182,7 @@ fn diagnose_missing_profile_is_rc1_ok_false_and_zero_token() {
     .unwrap();
 
     let output = Command::new(crate::lifecycle::tests::test_binary_path())
-        .args(["diagnose", team.to_str().unwrap(), "--workspace", ws.to_str().unwrap(), "--json"])
+        .args(["doctor", team.to_str().unwrap(), "--workspace", ws.to_str().unwrap(), "--json"])
         .current_dir(&team)
         .output()
         .expect("diagnose subprocess should run");

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -1,7 +1,7 @@
 use super::launch_spawn::seed_healthy_coordinator;
 use super::*;
 use crate::cli::{
-    cmd_diagnose, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult, DiagnoseArgs,
+    cmd_doctor, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult, DoctorArgs,
     SendArgs, StatusArgs,
 };
 use crate::transport::test_support::OfflineTransport;
@@ -582,10 +582,17 @@ fn run_diagnose_after_quick_start() -> Value {
             .is_some(),
         "index-missing diagnose requires a persisted seeded owner"
     );
-    let diagnose = cmd_diagnose(&DiagnoseArgs {
+    let diagnose = cmd_doctor(&DoctorArgs {
         workspace,
         json: true,
         team: Some("teamdir".to_string()),
+        spec: None,
+        gate: None,
+        comms: false,
+        fix: false,
+        fix_schema: false,
+        cleanup_orphans: false,
+        confirm: false,
     });
     match cmd_value(diagnose) {
         Value::Object(map) => map

package/crates/team-agent/src/lifecycle/tests/realmachine_clusters_1_6_red.rs

@@ -272,66 +272,6 @@ fn c1_runtime_commands_resolve_active_team_for_status_send_and_collect() {
     );
 }
 
-#[test]
-#[ignore = "real-machine: command-file gate uses real team-agent binary/lifecycle"]
-fn c2_stop_team_level_command_exists_and_keeps_state_while_stopping_runtime() {
-    let ws = tmp_dir("c2-stop");
-    seed_runtime_state(&ws);
-
-    let out = run(
-        &["stop", "--workspace", ws.to_str().unwrap(), "--json"],
-        &ws,
-    );
-    let err = String::from_utf8_lossy(&out.stderr);
-    assert!(
-        !err.contains("invalid choice: 'stop'"),
-        "CR-005: canonical `team-agent stop --workspace <ws> --json` must be a registered team-level stop verb, not argparse invalid-choice; stderr={err:?}"
-    );
-    assert_eq!(
-        out.status.code(),
-        Some(0),
-        "CR-005: stop should stop the runtime while keeping state on a valid workspace; stdout={} stderr={}",
-        String::from_utf8_lossy(&out.stdout),
-        err
-    );
-    let value = stdout_json(&out);
-    assert_eq!(
-        value["ok"],
-        json!(true),
-        "stop must return a successful JSON envelope"
-    );
-    assert!(
-        team_agent::state::persist::runtime_state_path(&ws).exists(),
-        "stop keeps runtime state for later restart"
-    );
-}
-
-#[test]
-#[ignore = "real-machine: command-file gate uses real team-agent binary/lifecycle"]
-fn c2_canonical_verbs_expose_help_instead_of_invalid_choice() {
-    let cwd = tmp_dir("c2-help-verbs");
-    let mut failures = Vec::new();
-    for verb in ["start", "restart-agent", "purge-agent"] {
-        let out = run(&[verb, "--help"], &cwd);
-        let stdout = String::from_utf8_lossy(&out.stdout);
-        let stderr = String::from_utf8_lossy(&out.stderr);
-        if out.status.code() != Some(0)
-            || stderr.contains("invalid choice:")
-            || !(stdout.contains("usage") || stderr.contains("usage"))
-        {
-            failures.push(format!(
-                "{verb}: code={:?} stdout={stdout:?} stderr={stderr:?}",
-                out.status.code()
-            ));
-        }
-    }
-    assert!(
-        failures.is_empty(),
-        "CR-030/032/035/063: canonical lifecycle verbs must be registered and expose help, not invalid-choice:\n{}",
-        failures.join("\n")
-    );
-}
-
 #[test]
 #[ignore = "real-machine: command-file gate uses real team-agent binary/lifecycle"]
 fn c2_quick_start_help_is_zero_token_help_only_and_does_not_compile_workspace() {

package/crates/team-agent/src/lifecycle/tests/team_in_team_identity_scope_red.rs

@@ -80,7 +80,7 @@ fn quick_start_workspace_override_is_not_dropped_before_runtime_state_write() {
     let quick_start_args = source_section(
         &cli_types,
         "pub struct QuickStartArgs",
-        "pub struct InitArgs",
+        "pub struct SendArgs",
     );
     assert!(
         quick_start_args.contains("pub workspace: PathBuf"),
@@ -97,7 +97,7 @@ fn quick_start_workspace_override_is_not_dropped_before_runtime_state_write() {
 
     let emit =
         std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/cli/emit.rs")).unwrap();
-    let quick_start_args_fn = source_section(&emit, "fn quick_start_args", "fn init_args");
+    let quick_start_args_fn = source_section(&emit, "fn quick_start_args", "fn resolve_cli_path");
     assert!(
         quick_start_args_fn.contains("workspace: workspace.clone()")
             || quick_start_args_fn.contains("workspace,"),

package/crates/team-agent/src/messaging/send.rs

@@ -551,11 +551,11 @@ fn coordinator_unavailable_outcome(
     );
     let warning = if persist {
         format!(
-            "coordinator is not running; message was queued for {recipient} and will retry. Run `team-agent diagnose` or restart the team."
+            "coordinator is not running; message was queued for {recipient} and will retry. Run `team-agent doctor` or restart the team."
         )
     } else {
         format!(
-            "coordinator protocol or schema is incompatible; message was not queued for {recipient}. Run `team-agent diagnose` or upgrade the runtime."
+            "coordinator protocol or schema is incompatible; message was not queued for {recipient}. Run `team-agent doctor` or upgrade the runtime."
         )
     };
     event_log.write(

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

@@ -172,7 +172,7 @@ pub enum AuthHintStatus {
 pub enum NoPingReason {
     /// worker 从未 open 过 turn(`idle_predicate.py:61`)。
     NotArmedNoWorkerTurn,
-    /// suppress flag 置位(acknowledge-idle 后,`idle_predicate.py:63`)。
+    /// Suppress flag from a legacy idle acknowledgement (`idle_predicate.py:63`).
     Acknowledged,
     /// armed 但 elapsed < debounce(`idle_predicate.py:65`)。
     DebounceActive,

package/crates/team-agent/src/state/repository.rs

@@ -419,9 +419,6 @@ pub enum StateWriteIntent<'a> {
     SchedulerSuppression {
         owner_team_id: Option<&'a str>,
     },
-    IdleAck {
-        team_key: Option<&'a str>,
-    },
     TaskRepair {
         team_key: Option<&'a str>,
     },
@@ -650,8 +647,6 @@ fn route_direct(
         },
         // SchedulerSuppression -> root save (messaging/scheduler.rs:259).
         StateWriteIntent::SchedulerSuppression { .. } => helper_write_root(workspace, state),
-        // IdleAck -> root save (cli/mod.rs:2544).
-        StateWriteIntent::IdleAck { .. } => helper_write_root(workspace, state),
         // TaskRepair -> `save_team_scoped_state` (cli/adapters.rs:675).
         StateWriteIntent::TaskRepair { .. } => helper_write_team_scoped(workspace, state),
         // FakeE2eSeed / SelfMigration are diagnostic seams. The current

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.99",
+  "version": "0.5.100",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.99",
-    "@team-agent/cli-darwin-x64": "0.5.99",
-    "@team-agent/cli-linux-x64": "0.5.99"
+    "@team-agent/cli-darwin-arm64": "0.5.100",
+    "@team-agent/cli-darwin-x64": "0.5.100",
+    "@team-agent/cli-linux-x64": "0.5.100"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/skills/team-agent/references/recovery-runbook.md

@@ -157,10 +157,10 @@ Resume/repair:
 team-agent restart "$WORKSPACE" --team "$TEAM" --json
 ```
 
-For a single worker where the leader has explicitly selected that worker:
+A single-worker clean-context reset is not a resume operation. Only after the user explicitly approves discarding that worker's session, use:
 
 ```bash
-team-agent restart-agent "$AGENT_ID" --workspace "$WORKSPACE" --team "$TEAM" --json
+team-agent reset-agent "$AGENT_ID" --workspace "$WORKSPACE" --team "$TEAM" --discard-session --json
 ```
 
 Validate:

package/skills/team-agent/references/team-in-team.md

@@ -112,12 +112,6 @@ For an existing worker that should restart with a blank provider context, the le
 team-agent reset-agent "$AGENT_ID" --workspace "$WORKSPACE" --team "$TEAM" --discard-session --json
 ```
 
-or the equivalent restart form:
-
-```bash
-team-agent restart-agent "$AGENT_ID" --workspace "$WORKSPACE" --team "$TEAM" --discard-session --json
-```
-
 Use this only when the user intentionally wants a clean context. For incident recovery, follow `recovery-runbook.md`, where context-preserving repair comes first.
 
 ## Framework Gaps To Track