@team-agent/installer 0.5.92 → 0.5.97

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

@@ -1,7 +1,7 @@
 //! E12 (P0) · `sessions_to_kill` 纯决策单测(kill 决策下沉)。
 //!
 //! spare = state 锚 session(anchor_sessions) ∪ `team-agent-leader-` 命名前缀(并集,锚优先)。
-//! 独享 socket(无 spare)才允许整 server 拆;共享/leader 在 → 逐 session kill。
+//! Cleanup is always per-session and ownership-gated; a socket is never sufficient authority for kill-server.
 //! 集成面由 tests/b5_leader_terminal_kill_red.rs 的真 tmux 契约覆盖,此处锁纯决策 + 4 反向 case。
 
 use crate::cli::lifecycle_port::{sessions_to_kill, KillDecision};
@@ -23,12 +23,58 @@ fn anchors(raw: &[&str]) -> BTreeSet<String> {
     raw.iter().map(|s| s.to_string()).collect()
 }
 
-// RC-4(独享 socket):仅目标 session(无 spare)→ 整 server 拆。
 #[test]
-fn rc4_exclusive_socket_kills_server() {
+fn leader_anchors_are_endpoint_scoped_and_unknown_anchors_stay_protected() {
+    use crate::cli::lifecycle_port::collect_state_leader_anchor_pane_ids as collect;
+    let state = json!({
+        "team_owner": {"pane_id": "%2"},
+        "leader_receiver": {"pane_id": "%2", "tmux_socket": "/tmp/s4-host.sock"},
+        "teams": {
+            "local": {
+                "team_owner": {"pane_id": "%3", "tmux_socket": "/tmp/s4-worker.sock"},
+                "leader_receiver": {"pane_id": "%3"}
+            },
+            "legacy": {"team_owner": {"pane_id": "%4"}}
+        }
+    });
+    assert_eq!(collect(&state, Some("/tmp/s4-worker.sock")), anchors(&["%3", "%4"]));
+    assert_eq!(collect(&state, Some("/tmp/s4-host.sock")), anchors(&["%2", "%4"]));
+    assert_eq!(collect(&state, None), anchors(&["%2", "%3", "%4"]));
+
+    // An unrelated receiver's socket is not evidence about the owner's pane.
+    let different_panes = json!({
+        "team_owner": {"pane_id": "%5"},
+        "leader_receiver": {"pane_id": "%2", "tmux_socket": "/tmp/s4-host.sock"}
+    });
+    assert_eq!(collect(&different_panes, Some("/tmp/s4-worker.sock")), anchors(&["%5"]));
+}
+
+#[test]
+#[cfg(unix)]
+fn leader_anchor_endpoint_aliases_preserve_same_server_protection() {
+    use crate::cli::lifecycle_port::collect_state_leader_anchor_pane_ids as collect;
+    let ws = tmp_shutdown_workspace("anchor-endpoint-alias");
+    let socket = ws.join("server.sock");
+    let alias = ws.join("alias.sock");
+    std::fs::write(&socket, b"fixture").unwrap();
+    std::os::unix::fs::symlink(&socket, &alias).unwrap();
+    let state = json!({"leader_receiver": {"pane_id": "%2", "tmux_socket": alias}});
+    assert_eq!(collect(&state, socket.to_str()), anchors(&["%2"]));
+    let short_name = format!("s4-anchor-{}", std::process::id());
+    let full_path = crate::tmux_backend::socket_path_for_name(&short_name).unwrap();
+    let state = json!({"leader_receiver": {"pane_id": "%2", "tmux_socket": short_name}});
+    assert_eq!(collect(&state, full_path.to_str()), anchors(&["%2"]));
+}
+
+// RC-4: even an apparently exclusive socket uses per-session cleanup.
+#[test]
+fn rc4_exclusive_socket_is_fail_closed() {
     assert_eq!(
         sessions_to_kill(&names(&["team-x", "team-y"]), &BTreeSet::new()),
-        KillDecision::KillServerExclusive
+        KillDecision::KillIndividually {
+            to_kill: names(&["team-x", "team-y"]),
+            spared: vec![]
+        }
     );
     // 空 session 集 → 逐 kill(no-op),不整 server 拆(没东西可拆)。
     assert_eq!(
@@ -87,10 +133,13 @@ fn rc2_no_anchor_falls_back_to_naming() {
         &BTreeSet::new(),
     );
     assert!(matches!(with_leader, KillDecision::KillIndividually { .. }));
-    // 无锚 + 无前缀(真损坏且 in_tmux 无前缀)→ 无 spare → 独享拆(退化兜底,与历史一致)。
+    // 无锚 + 无前缀仍只能逐 session 返回，实际 shutdown 会因 marker 缺失拒绝杀灭。
     assert_eq!(
         sessions_to_kill(&names(&["team-x"]), &BTreeSet::new()),
-        KillDecision::KillServerExclusive
+        KillDecision::KillIndividually {
+            to_kill: names(&["team-x"]),
+            spared: vec![]
+        }
     );
 }
 
@@ -169,6 +218,8 @@ fn owned_empty_endpoint_cleanup_removes_socket_file_before_reporting_ok() {
         &ws,
         &json!({
             "session_name": "team-owned-clean",
+            "team_key": "team-owned-clean",
+            "generation": "team-owned-clean",
             "tmux_endpoint": socket.to_string_lossy(),
             "tmux_socket": socket.to_string_lossy(),
             "tmux_socket_source": "workspace",
@@ -177,7 +228,12 @@ fn owned_empty_endpoint_cleanup_removes_socket_file_before_reporting_ok() {
         }),
     )
     .unwrap();
-    let transport = CleanShutdownTransport::new();
+    let transport = CleanShutdownTransport::new().with_owned_session(
+        &ws,
+        "team-owned-clean",
+        "team-owned-clean",
+        "team-owned-clean",
+    );
 
     let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
         .expect("shutdown should complete");
@@ -186,12 +242,12 @@ fn owned_empty_endpoint_cleanup_removes_socket_file_before_reporting_ok() {
     assert_eq!(out["status"], json!("ok"));
     assert_eq!(out["residuals"]["owned_files"], json!([]));
     assert!(
-        !socket.exists(),
-        "owned empty endpoint socket file must be removed"
+        socket.exists(),
+        "fail-closed endpoint cleanup must preserve the socket file"
     );
     assert!(
-        transport.kill_server_called(),
-        "owned empty endpoint should be torn down after session cleanup"
+        !transport.kill_server_called(),
+        "endpoint ownership must not authorize server teardown"
     );
 }
 
@@ -235,6 +291,8 @@ fn owned_file_residual_makes_shutdown_failed_not_partial() {
         &ws,
         &json!({
             "session_name": "team-owned-residual",
+            "team_key": "team-owned-residual",
+            "generation": "team-owned-residual",
             "tmux_endpoint": socket_dir.to_string_lossy(),
             "tmux_socket": socket_dir.to_string_lossy(),
             "tmux_socket_source": "workspace",
@@ -243,18 +301,22 @@ fn owned_file_residual_makes_shutdown_failed_not_partial() {
         }),
     )
     .unwrap();
-    let transport = CleanShutdownTransport::new();
+    let transport = CleanShutdownTransport::new().with_owned_session(
+        &ws,
+        "team-owned-residual",
+        "team-owned-residual",
+        "team-owned-residual",
+    );
 
     let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
         .expect("shutdown should complete");
 
-    assert_eq!(out["ok"], json!(false));
-    assert_eq!(out["status"], json!("failed"));
+    assert_eq!(out["ok"], json!(true));
+    assert_eq!(out["status"], json!("ok"));
     assert_eq!(out["phase"], json!(null));
-    assert_eq!(
-        out["residuals"]["owned_files"],
-        json!([{ "path": socket_dir.display().to_string() }])
-    );
+    assert_eq!(out["residuals"]["owned_files"], json!([]));
+    assert!(socket_dir.exists(), "fail-closed cleanup preserves residual files");
+    assert!(!transport.kill_server_called());
 }
 
 #[test]
@@ -340,6 +402,7 @@ fn scoped_clean_shutdown_persists_team_shutdown_status_after_disk_roundtrip() {
             "schema_version": 1,
             "active_team_key": "current",
             "team_key": "current",
+            "generation": "current",
             "session_name": "team-current",
             "team_dir": ws.display().to_string(),
             "workspace": ws.display().to_string(),
@@ -354,6 +417,7 @@ fn scoped_clean_shutdown_persists_team_shutdown_status_after_disk_roundtrip() {
             "teams": {
                 "current": {
                     "team_key": "current",
+                    "generation": "current",
                     "session_name": "team-current",
                     "team_dir": ws.display().to_string(),
                     "workspace": ws.display().to_string(),
@@ -375,7 +439,12 @@ fn scoped_clean_shutdown_persists_team_shutdown_status_after_disk_roundtrip() {
         &ws,
         true,
         Some("current"),
-        &CleanShutdownTransport::new(),
+        &CleanShutdownTransport::new().with_owned_session(
+            &ws,
+            "team-current",
+            "current",
+            "current",
+        ),
     )
     .expect("shutdown should complete");
 
@@ -414,6 +483,7 @@ fn scoped_degraded_shutdown_does_not_persist_team_shutdown_status() {
             "schema_version": 1,
             "active_team_key": "current",
             "team_key": "current",
+            "generation": "current",
             "session_name": "team-current",
             "agents": {
                 "adminweb": {
@@ -426,6 +496,7 @@ fn scoped_degraded_shutdown_does_not_persist_team_shutdown_status() {
             "teams": {
                 "current": {
                     "team_key": "current",
+                    "generation": "current",
                     "session_name": "team-current",
                     "agents": {
                         "adminweb": {
@@ -445,7 +516,9 @@ fn scoped_degraded_shutdown_does_not_persist_team_shutdown_status() {
         &ws,
         true,
         Some("current"),
-        &CleanShutdownTransport::new().with_probe_timeout("ps_table"),
+        &CleanShutdownTransport::new()
+            .with_owned_session(&ws, "team-current", "current", "current")
+            .with_probe_timeout("ps_table"),
     )
     .expect("shutdown should complete");
 
@@ -519,6 +592,8 @@ fn repeated_owned_endpoint_shutdowns_leave_no_socket_file_growth() {
             &ws,
             &json!({
                 "session_name": "team-owned-loop",
+                "team_key": "team-owned-loop",
+                "generation": "team-owned-loop",
                 "tmux_endpoint": socket.to_string_lossy(),
                 "tmux_socket": socket.to_string_lossy(),
                 "tmux_socket_source": "workspace",
@@ -535,7 +610,12 @@ fn repeated_owned_endpoint_shutdowns_leave_no_socket_file_growth() {
             &ws,
             true,
             None,
-            &CleanShutdownTransport::new(),
+            &CleanShutdownTransport::new().with_owned_session(
+                &ws,
+                "team-owned-loop",
+                "team-owned-loop",
+                "team-owned-loop",
+            ),
         );
         let out = match &result {
             Ok(out) if !shutdown_result_is_degraded(out) => out,
@@ -573,8 +653,9 @@ fn repeated_owned_endpoint_shutdowns_leave_no_socket_file_growth() {
     }
     let ending = sockets.iter().filter(|path| path.exists()).count();
     assert_eq!(
-        ending, starting,
-        "owned socket files must not grow across loops"
+        ending,
+        starting + sockets.len(),
+        "fail-closed endpoint cleanup must not remove unverified socket files"
     );
     #[cfg(unix)]
     if expected_probe_failure {
@@ -793,6 +874,7 @@ struct CleanShutdownTransport {
     probe_timeout_kind: Option<&'static str>,
     targets_persist_after_kill: bool,
     kill_session_error: Option<String>,
+    owner: Option<crate::transport::SessionOwner>,
     // E49 (0.3.24 P0, shutdown kills leader CLI): record per-pane / per-window /
     // per-session kill targets so RED contracts can assert (a) the leader pane is
     // never killed and (b) worker panes ARE killed via the new per-pane path.
@@ -810,6 +892,7 @@ impl CleanShutdownTransport {
             probe_timeout_kind: None,
             targets_persist_after_kill: false,
             kill_session_error: None,
+            owner: None,
             killed_panes: Mutex::new(Vec::new()),
             killed_window_targets: Mutex::new(Vec::new()),
             killed_sessions: Mutex::new(Vec::new()),
@@ -821,6 +904,46 @@ impl CleanShutdownTransport {
         self
     }
 
+    fn with_owned_session(
+        mut self,
+        workspace: &Path,
+        session: &str,
+        team: &str,
+        generation: &str,
+    ) -> Self {
+        self.owner = Some(crate::transport::SessionOwner {
+            workspace: workspace
+                .canonicalize()
+                .unwrap_or_else(|_| workspace.to_path_buf())
+                .to_string_lossy()
+                .into_owned(),
+            team: team.to_string(),
+            generation: generation.to_string(),
+        });
+        if self.targets.is_empty() {
+            self.targets.push(PaneInfo {
+                pane_id: PaneId::new("%owned"),
+                session: SessionName::new(session),
+                window_index: Some(0),
+                window_name: Some(WindowName::new("owned")),
+                pane_index: Some(0),
+                tty: None,
+                current_command: Some("codex".to_string()),
+                current_path: Some(workspace.to_path_buf()),
+                active: true,
+                pane_pid: None,
+                leader_env: BTreeMap::new(),
+            });
+        } else {
+            for target in &mut self.targets {
+                if target.current_path.is_none() {
+                    target.current_path = Some(workspace.to_path_buf());
+                }
+            }
+        }
+        self
+    }
+
     fn kill_server_called(&self) -> bool {
         *self.kill_server_called.lock().unwrap()
     }
@@ -931,6 +1054,13 @@ impl Transport for CleanShutdownTransport {
         Ok(*self.session_present.lock().unwrap())
     }
 
+    fn session_owner(
+        &self,
+        _session: &SessionName,
+    ) -> Result<Option<crate::transport::SessionOwner>, TransportError> {
+        Ok(self.owner.clone())
+    }
+
     fn list_windows(&self, _session: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         Ok(Vec::new())
     }
@@ -1001,6 +1131,8 @@ fn lsof_cwd_timeout_is_diagnostic_not_shutdown_partial() {
         &ws,
         &json!({
             "session_name": "team-lsof-cwd-timeout",
+            "team_key": "team-lsof-cwd-timeout",
+            "generation": "team-lsof-cwd-timeout",
             "is_external_leader": true,
             "agents": {
                 "fake_impl": {
@@ -1017,7 +1149,14 @@ fn lsof_cwd_timeout_is_diagnostic_not_shutdown_partial() {
         &ws,
         true,
         None,
-        &CleanShutdownTransport::new().with_probe_timeout("lsof_cwd"),
+        &CleanShutdownTransport::new()
+            .with_owned_session(
+                &ws,
+                "team-lsof-cwd-timeout",
+                "team-lsof-cwd-timeout",
+                "team-lsof-cwd-timeout",
+            )
+            .with_probe_timeout("lsof_cwd"),
     )
     .expect("shutdown should complete");
 
@@ -1051,6 +1190,8 @@ fn ps_table_timeout_still_degrades_shutdown_truth() {
         &ws,
         &json!({
             "session_name": "team-ps-table-timeout",
+            "team_key": "team-ps-table-timeout",
+            "generation": "team-ps-table-timeout",
             "agents": {
                 "fake_impl": {
                     "status": "running",
@@ -1066,7 +1207,14 @@ fn ps_table_timeout_still_degrades_shutdown_truth() {
         &ws,
         true,
         None,
-        &CleanShutdownTransport::new().with_probe_timeout("ps_table"),
+        &CleanShutdownTransport::new()
+            .with_owned_session(
+                &ws,
+                "team-ps-table-timeout",
+                "team-ps-table-timeout",
+                "team-ps-table-timeout",
+            )
+            .with_probe_timeout("ps_table"),
     )
     .expect("shutdown should complete");
 
@@ -1169,6 +1317,9 @@ fn leader_env_tmux_socket_never_kills_server_even_when_sessions_look_exclusive()
         &ws,
         &json!({
             "is_external_leader": true,
+            "team_key": "team-layout",
+            "generation": "team-layout",
+            "session_name": "team-layout",
             "tmux_socket_source": "leader_env",
             "agents": {
                 "fake_impl": {
@@ -1193,6 +1344,7 @@ fn leader_env_tmux_socket_never_kills_server_even_when_sessions_look_exclusive()
         pane_pid: None,
         leader_env: BTreeMap::new(),
     }]);
+    let transport = transport.with_owned_session(&ws, "team-layout", "team-layout", "team-layout");
 
     let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
         .expect("shutdown should complete");
@@ -1239,6 +1391,8 @@ fn e49_managed_leader_shutdown_spares_leader_session_and_kills_workers_per_pane(
         &ws,
         &json!({
             "session_name": "team-current",
+            "team_key": "current",
+            "generation": "current",
             "is_external_leader": false,
             "leader_receiver": {"pane_id": "%leader"},
             "team_owner": {"pane_id": "%leader"},
@@ -1294,7 +1448,8 @@ fn e49_managed_leader_shutdown_spares_leader_session_and_kills_workers_per_pane(
                 leader_env: BTreeMap::new(),
             },
         ])
-        .with_targets_persist_after_kill();
+        .with_targets_persist_after_kill()
+        .with_owned_session(&ws, "team-current", "current", "current");
 
     let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
         .expect("shutdown should complete");
@@ -1381,6 +1536,8 @@ fn e49_external_leader_shutdown_still_kills_team_session_unconditionally() {
         &ws,
         &json!({
             "session_name": "team-external",
+            "team_key": "team-external",
+            "generation": "team-external",
             "is_external_leader": true,
             "leader_receiver": {"pane_id": "%leaderelsewhere"},
             "agents": {
@@ -1420,7 +1577,8 @@ fn e49_external_leader_shutdown_still_kills_team_session_unconditionally() {
                 leader_env: BTreeMap::new(),
             },
         ])
-        .with_targets_persist_after_kill();
+        .with_targets_persist_after_kill()
+        .with_owned_session(&ws, "team-external", "team-external", "team-external");
 
     let event_log = crate::event_log::EventLog::new(&ws);
     let event_start = event_log.tail(0).expect("events before shutdown").len();
@@ -1455,6 +1613,8 @@ fn e49_external_leader_non_clean_diagnostic_is_bounded_and_still_kills() {
         &ws,
         &json!({
             "session_name": "team-external",
+            "team_key": "team-external",
+            "generation": "team-external",
             "is_external_leader": true,
             "leader_receiver": {"pane_id": "%leaderelsewhere"},
             "agents": {
@@ -1477,7 +1637,8 @@ fn e49_external_leader_non_clean_diagnostic_is_bounded_and_still_kills() {
             pane_pid: None,
             leader_env: BTreeMap::new(),
         }])
-        .with_kill_session_error("deterministic E49 kill-session failure");
+        .with_kill_session_error("deterministic E49 kill-session failure")
+        .with_owned_session(&ws, "team-external", "team-external", "team-external");
 
     let event_log = crate::event_log::EventLog::new(&ws);
     let event_start = event_log.tail(0).expect("events before shutdown").len();
@@ -1537,6 +1698,8 @@ fn e49_managed_leader_without_anchor_in_session_still_kills_session() {
         &ws,
         &json!({
             "session_name": "team-orphan",
+            "team_key": "team-orphan",
+            "generation": "team-orphan",
             "is_external_leader": false,
             "agents": {
                 "w1": {"status": "running", "provider": "codex", "window": "w1", "pane_id": "%w1"}
@@ -1558,7 +1721,8 @@ fn e49_managed_leader_without_anchor_in_session_still_kills_session() {
             pane_pid: None,
             leader_env: BTreeMap::new(),
         }])
-        .with_targets_persist_after_kill();
+        .with_targets_persist_after_kill()
+        .with_owned_session(&ws, "team-orphan", "team-orphan", "team-orphan");
 
     let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
         .expect("shutdown should complete");
@@ -1580,6 +1744,8 @@ fn shutdown_missing_topology_marker_defaults_to_managed_cleanup() {
         &ws,
         &json!({
             "session_name": "team-current",
+            "team_key": "team-current",
+            "generation": "team-current",
             "agents": {}
         }),
     )
@@ -1598,7 +1764,8 @@ fn shutdown_missing_topology_marker_defaults_to_managed_cleanup() {
             pane_pid: None,
             leader_env: BTreeMap::new(),
         }])
-        .with_targets_persist_after_kill();
+        .with_targets_persist_after_kill()
+        .with_owned_session(&ws, "team-current", "team-current", "team-current");
 
     let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
         .expect("shutdown should complete");

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

@@ -35,43 +35,27 @@ pub(crate) fn render(command: &str, report: &Value) -> String {
     // generic emitter redacts again for defense in depth.
     let report = crate::redaction::redact_external_value(report);
     let ok = report.get("ok").and_then(Value::as_bool).unwrap_or(false);
-    let mut lines = vec![bounded(format!(
+    let runtime = report
+        .get("runtime")
+        .and_then(|runtime| runtime.get("status"))
+        .and_then(Value::as_str);
+    let issues = array_items(report.get("issues"));
+    let repairs = array_items(report.get("suggested_repairs"));
+    let mut summary = format!(
         "{command}: {}",
         if ok { "ok" } else { "needs attention" }
-    ))];
-
-    if command == "doctor" {
-        for finding in array_items(
-            report
-                .get("secret_scan")
-                .and_then(|scan| scan.get("findings")),
-        ) {
-            let Some(object) = finding.as_object() else {
-                continue;
-            };
-            let (Some(rule), Some(path), Some(line)) = (
-                object.get("rule").and_then(Value::as_str),
-                object.get("path").and_then(Value::as_str),
-                object.get("line").and_then(Value::as_u64),
-            ) else {
-                continue;
-            };
-            lines.push(bounded(format!("warn: {rule} in {path}:{line}")));
-        }
+    );
+    if let Some(runtime) = runtime {
+        summary.push_str(&format!("; runtime={runtime}"));
     }
-
-    for issue in array_items(report.get("issues")) {
+    summary.push_str(&format!("; issues={}; repairs={}", issues.len(), repairs.len()));
+    let mut lines = vec![bounded(summary)];
+    for issue in issues {
         lines.push(bounded(format!("issue: {}", summarize(issue, false))));
     }
-    for repair in array_items(report.get("suggested_repairs")) {
+    for repair in repairs {
         lines.push(bounded(format!("repair: {}", summarize(repair, true))));
     }
-    if let Some(error) = report.get("error").filter(|value| !value.is_null()) {
-        lines.push(bounded(format!("detail: {}", summarize(error, false))));
-    }
-    if lines.len() == 1 {
-        lines.push(bounded("detail: no issues detected".to_string()));
-    }
     lines.join("\n")
 }
 
@@ -95,6 +79,15 @@ fn summarize(value: &Value, repair: bool) -> String {
                     .as_slice()
             };
             let mut parts = Vec::new();
+            if let Some(path) = object.get("path").and_then(Value::as_str) {
+                let location = match object.get("line").and_then(Value::as_u64) {
+                    Some(line) => format!("{path}:{line}"),
+                    None => path.to_string(),
+                };
+                // Keep the target ahead of prose so bounded human lines retain
+                // the distinguishing location rather than only the issue id.
+                parts.push(format!("at={location}"));
+            }
             for key in keys {
                 if let Some(value) = object.get(*key).and_then(Value::as_str) {
                     parts.push(format!("{key}={value}"));
@@ -166,6 +159,13 @@ mod tests {
     fn renderer_projects_secret_findings_without_values() {
         let report = json!({
             "ok": false,
+            "issues": [{
+                "id": "secret_scan_finding",
+                "rule": "api_key_assignment",
+                "path": "leaky-role.md",
+                "line": 7,
+            }],
+            "suggested_repairs": [{"issue": "secret_scan_finding", "action": "remove secret finding at leaky-role.md:7"}],
             "secret_scan": {
                 "findings": [{
                     "rule": "api_key_assignment",
@@ -176,7 +176,7 @@ mod tests {
             }
         });
         let output = render("doctor", &report);
-        assert!(output.contains("warn: api_key_assignment in leaky-role.md:7"));
+        assert!(output.contains("issue: at=leaky-role.md:7; id=secret_scan_finding"));
         assert!(!output.contains("match_excerpt"));
         assert!(!output.contains("OPENAI_API_KEY=secret"));
     }

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

@@ -697,7 +697,9 @@ pub struct WaitArgs {
     pub json: bool,
 }
 
-/// `diagnose`(`parser.py:298`) runtime health report, distinct from `doctor`.
+/// `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,