@team-agent/installer 0.5.75 → 0.5.77

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

@@ -345,7 +345,7 @@ fn status_compact_reports_identity_slot_health_on_grok_identity_slot_ok() {
 }
 
 #[test]
-fn cmd_status_human_appends_harness_reminder() {
+fn cmd_status_human_is_seven_field_brief_without_diagnostics() {
     let ws = seed_status_workspace();
     let args = StatusArgs {
         agent: None,
@@ -362,7 +362,13 @@ fn cmd_status_human_appends_harness_reminder() {
         other => panic!("expected human status output, got {other:?}"),
     };
 
-    assert!(text.ends_with(crate::cli::STATUS_REMINDER), "{text}");
+    assert!(
+        text.contains(
+            "name: a1 provider: unknown runtime_status: unknown activity: unknown health: unknown session_name: null tmux_command: null"
+        ),
+        "{text}"
+    );
+    assert!(!text.contains(crate::cli::STATUS_REMINDER));
     let _ = std::fs::remove_dir_all(&ws);
 }
 

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

@@ -32,6 +32,11 @@ pub(crate) struct AppliedLeaderGrant {
     pub(crate) receiver: Value,
 }
 
+#[derive(Debug, Default)]
+struct AttachRecovery {
+    blocked_counts: crate::message_store::BlockedLeaderRequeueCounts,
+}
+
 #[derive(Debug)]
 pub(crate) struct AttachLeaderError {
     source: LeaderError,
@@ -126,8 +131,11 @@ pub fn attach_leader(
             if let Some(endpoint) = target.endpoint.as_deref() {
                 quiet_fake_leader_pane_echo(provider, &target.info, endpoint);
             }
-            let _ =
+            let recovery =
                 requeue_exhausted_watchers_after_attach(workspace, &state, &event_log, &pane_id)?;
+            let team_id = TeamKey::new(crate::state::projection::team_state_key(&state));
+            let attach_window_failures =
+                attach_window_failure_value(recovery.blocked_counts, &team_id, &pane_id);
             return Ok(LeaseResult {
                 ok: true,
                 status: LeaseStatus::Claimed,
@@ -141,6 +149,7 @@ pub fn attach_leader(
                     .map(str::to_string),
                 bound_pane_id: Some(pane_id),
                 topology_convergence: None,
+                attach_window_failures,
             });
         }
         event_log.write(
@@ -165,7 +174,10 @@ pub fn attach_leader(
         if let Some(endpoint) = target.endpoint.as_deref() {
             quiet_fake_leader_pane_echo(provider, &target.info, endpoint);
         }
-        let _ = requeue_exhausted_watchers_after_attach(workspace, &state, &event_log, &pane_id)?;
+        let recovery = requeue_exhausted_watchers_after_attach(workspace, &state, &event_log, &pane_id)?;
+        let team_id = TeamKey::new(crate::state::projection::team_state_key(&state));
+        let attach_window_failures =
+            attach_window_failure_value(recovery.blocked_counts, &team_id, &pane_id);
         return Ok(LeaseResult {
             ok: true,
             status: LeaseStatus::AlreadyBound,
@@ -176,6 +188,7 @@ pub fn attach_leader(
             action: None,
             bound_pane_id: Some(pane_id),
             topology_convergence: None,
+            attach_window_failures,
         });
     }
     let identity = leader_identity_context(workspace, None, Some(&state))?;
@@ -192,7 +205,10 @@ pub fn attach_leader(
     if let Some(endpoint) = target.endpoint.as_deref() {
         quiet_fake_leader_pane_echo(provider, &target.info, endpoint);
     }
-    let _ = requeue_exhausted_watchers_after_attach(workspace, &state, &event_log, &pane_id)?;
+    let recovery = requeue_exhausted_watchers_after_attach(workspace, &state, &event_log, &pane_id)?;
+    let team_id = TeamKey::new(crate::state::projection::team_state_key(&state));
+    let attach_window_failures =
+        attach_window_failure_value(recovery.blocked_counts, &team_id, &pane_id);
     Ok(LeaseResult {
         ok: true,
         status: LeaseStatus::Claimed,
@@ -203,6 +219,7 @@ pub fn attach_leader(
         action: None,
         bound_pane_id: Some(pane_id),
         topology_convergence: None,
+        attach_window_failures,
     })
 }
 
@@ -441,17 +458,34 @@ fn requeue_exhausted_watchers_after_attach(
     state: &Value,
     event_log: &crate::event_log::EventLog,
     pane_id: &PaneId,
-) -> Result<Vec<crate::messaging::WatcherNotice>, LeaderError> {
+) -> Result<AttachRecovery, LeaderError> {
     let store = MessageStore::open(workspace)?;
     let team_id = TeamKey::new(crate::state::projection::team_state_key(state));
-    let notices = crate::messaging::requeue_delivery_exhausted_watchers(
-        workspace, &store, event_log, &team_id, pane_id,
-    )?;
+    let (notices, blocked_counts) =
+        crate::messaging::watchers::requeue_delivery_exhausted_watchers_with_counts(
+            workspace, &store, event_log, &team_id, pane_id,
+        )?;
     event_log.write(
         super::LeaderEvent::ReceiverRequeuedExhaustedWatchers.name(),
         requeued_exhausted_watchers_event_payload(pane_id, &team_id, &notices),
     )?;
-    Ok(notices)
+    Ok(AttachRecovery { blocked_counts })
+}
+
+fn attach_window_failure_value(
+    counts: crate::message_store::BlockedLeaderRequeueCounts,
+    team_id: &TeamKey,
+    pane_id: &PaneId,
+) -> Option<Value> {
+    (counts.blocked_leader_unbound > 0).then(|| {
+        json!({
+            "team_id": team_id.as_str(),
+            "pane_id": pane_id.as_str(),
+            "reason": "leader_not_attached",
+            "count": counts.blocked_leader_unbound,
+            "status": "requeued_pending_physical_retry",
+        })
+    })
 }
 
 /// R8 D4 (decoupled for offline byte-lock — c-lite): build the `leader_receiver.requeued_exhausted_watchers`
@@ -949,6 +983,7 @@ fn claim_lease_no_incident_with_target(
             action: None,
             bound_pane_id: Some(caller_pane.clone()),
             topology_convergence,
+            attach_window_failures: None,
         });
     }
     let owner_live = bound_pane_id.as_deref().is_some_and(|pane| {
@@ -1194,6 +1229,7 @@ fn claim_lease_no_incident_with_target(
         action: None,
         bound_pane_id: Some(caller_pane.clone()),
         topology_convergence,
+        attach_window_failures: None,
     })
 }
 
@@ -1452,6 +1488,7 @@ fn convergence_persistence_refusal(
         ),
         bound_pane_id,
         topology_convergence,
+        attach_window_failures: None,
     }
 }
 
@@ -1475,6 +1512,7 @@ fn refused(
         },
         bound_pane_id,
         topology_convergence: None,
+        attach_window_failures: None,
     }
 }
 

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

@@ -419,6 +419,10 @@ pub struct LeaseResult {
     /// paths so existing lease JSON stays stable unless a convergence decision
     /// was actually evaluated.
     pub topology_convergence: Option<Value>,
+    /// Counts returned by the same attach operation when blocked leader
+    /// messages were requeued. Kept typed and team/pane-bound; omitted when
+    /// no attach-window debt was observed.
+    pub attach_window_failures: Option<Value>,
 }
 
 /// Family A 正源 owner 绑定结果(`bind_owner_from_caller_pane` 返回 dict 的 typed 版)。

package/crates/team-agent/src/lifecycle/launch/pi_mcp.rs

@@ -16,6 +16,8 @@
 use std::collections::BTreeSet;
 use std::fs::OpenOptions;
 use std::io::{Read, Write};
+#[cfg(test)]
+use std::cell::RefCell;
 use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
@@ -588,6 +590,58 @@ fn executable_file_type(path: &Path) -> Result<PiExecutableFileType, ProviderErr
     }
 }
 
+#[cfg(test)]
+#[derive(Debug, Default)]
+pub(crate) struct PiCatalogTestObservation {
+    pub(crate) spawn_count: usize,
+    pub(crate) argv: Vec<String>,
+    pub(crate) parent_pid: Option<u32>,
+    pub(crate) parent_exit_success: Option<bool>,
+    pub(crate) parent_exit_code: Option<i32>,
+    pub(crate) reader_timeout: bool,
+}
+
+#[cfg(test)]
+struct PiCatalogTestContext {
+    receipt: PathBuf,
+    helper_mode: Option<String>,
+    observation: PiCatalogTestObservation,
+}
+
+#[cfg(test)]
+thread_local! {
+    static PI_CATALOG_TEST_CONTEXT: RefCell<Option<PiCatalogTestContext>> = RefCell::new(None);
+}
+
+#[cfg(test)]
+pub(crate) fn with_pi_catalog_test_observation<T>(
+    receipt: &Path,
+    helper_mode: Option<&str>,
+    action: impl FnOnce() -> T,
+) -> (T, PiCatalogTestObservation) {
+    PI_CATALOG_TEST_CONTEXT.with(|slot| {
+        assert!(slot
+            .replace(Some(PiCatalogTestContext {
+                receipt: receipt.to_path_buf(),
+                helper_mode: helper_mode.map(str::to_owned),
+                observation: PiCatalogTestObservation::default(),
+            }))
+            .is_none());
+        let result = action();
+        let context = slot.take().expect("Pi catalog test context");
+        (result, context.observation)
+    })
+}
+
+#[cfg(test)]
+fn observe_pi_catalog_test(f: impl FnOnce(&mut PiCatalogTestContext)) {
+    PI_CATALOG_TEST_CONTEXT.with(|slot| {
+        if let Some(context) = slot.borrow_mut().as_mut() {
+            f(context);
+        }
+    });
+}
+
 /// Discover candidates with one PATH-first catalog observation. This deliberately
 /// does not resolve adapters or scan wrapper chains; callers use it only for
 /// rejecting an unqualified role model before lifecycle mutation.
@@ -596,8 +650,18 @@ pub(crate) fn run_pi_catalog(
     timeout: Duration,
     max_bytes: u64,
 ) -> Result<Vec<u8>, String> {
-    let mut child = Command::new(executable)
-        .arg("--list-models")
+    let mut command = Command::new(executable);
+    command.arg("--list-models");
+    #[cfg(test)]
+    observe_pi_catalog_test(|context| {
+        context.observation.spawn_count += 1;
+        context.observation.argv.push("--list-models".to_string());
+        command.env("TEAM_AGENT_MODELS_TIMEOUT_RECEIPT", &context.receipt);
+        if let Some(mode) = context.helper_mode.as_deref() {
+            command.env("TEAM_AGENT_MODELS_TIMEOUT_MODE", mode);
+        }
+    });
+    let mut child = command
         .stdin(Stdio::null())
         .stdout(Stdio::piped())
         .stderr(Stdio::null())
@@ -614,6 +678,8 @@ pub(crate) fn run_pi_catalog(
             let _ = error;
             "Pi executable is unavailable on PATH".to_string()
         })?;
+    #[cfg(test)]
+    observe_pi_catalog_test(|context| context.observation.parent_pid = Some(child.id()));
     let stdout = child.stdout.take().ok_or_else(|| {
         let _ = child.kill();
         let _ = child.wait();
@@ -629,8 +695,19 @@ pub(crate) fn run_pi_catalog(
     loop {
         match child.try_wait() {
             Ok(Some(status)) => {
-                let (result, bytes) = receiver.recv_timeout(timeout.saturating_sub(start.elapsed()))
-                    .map_err(|_| "Pi model catalog command timed out".to_string())?;
+                #[cfg(test)]
+                observe_pi_catalog_test(|context| {
+                    context.observation.parent_exit_success = Some(status.success());
+                    context.observation.parent_exit_code = status.code();
+                });
+                let (result, bytes) = match receiver.recv_timeout(timeout.saturating_sub(start.elapsed())) {
+                    Ok(value) => value,
+                    Err(_) => {
+                        #[cfg(test)]
+                        observe_pi_catalog_test(|context| context.observation.reader_timeout = true);
+                        return Err("Pi model catalog command timed out".to_string());
+                    }
+                };
                 if !status.success() { return Err("Pi model catalog command failed".into()); }
                 result.map_err(|_| "Pi model catalog could not be read".to_string())?;
                 if bytes.len() as u64 > max_bytes { return Err("Pi model catalog exceeds the bounded output limit".into()); }

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

@@ -1303,7 +1303,7 @@ fn restart_with_selected_team_and_transport(
         )?;
         // 0.3.30 Bug 1: auto-attach on partial restart too — workers that did
         // come up still need a leader_receiver pane to deliver report_result.
-        try_autobind_leader_after_restart(
+        let attach_window_failures = try_autobind_leader_after_restart(
             &selected.run_workspace,
             Some(selected.team_key.as_str()),
             &state,
@@ -1316,6 +1316,7 @@ fn restart_with_selected_team_and_transport(
             coordinator,
             next_actions,
             attach_commands,
+            attach_window_failures,
         });
     }
     phase_timer.emit(&selected.run_workspace, "restart.phase", "completed");
@@ -1331,7 +1332,8 @@ fn restart_with_selected_team_and_transport(
     // invoked from a tmux pane should bind that pane as leader_receiver,
     // restoring the worker→leader delivery path. Failure is non-fatal — the
     // user can still run `team-agent attach-leader` manually.
-    try_autobind_leader_after_restart(&selected.run_workspace, Some(&selected.team_key), &state);
+    let attach_window_failures =
+        try_autobind_leader_after_restart(&selected.run_workspace, Some(&selected.team_key), &state);
     if let Ok(probe) = crate::lifecycle::display::probe_display_capabilities(&selected.run_workspace)
     {
         let _ = crate::lifecycle::display::rebuild_adaptive_display_after_rebind(
@@ -1352,6 +1354,7 @@ fn restart_with_selected_team_and_transport(
         coordinator,
         next_actions,
         attach_commands,
+        attach_window_failures,
     })
 }
 
@@ -1825,9 +1828,9 @@ fn try_autobind_leader_after_restart(
     workspace: &std::path::Path,
     team: Option<&str>,
     state: &serde_json::Value,
-) {
+) -> Option<serde_json::Value> {
     if std::env::var_os("TMUX_PANE").is_none() {
-        return;
+        return None;
     }
     // Provider: prefer the existing team_owner.provider (if rebind),
     // else leader_receiver.provider (stale, but still informative),
@@ -1854,6 +1857,7 @@ fn try_autobind_leader_after_restart(
     let team_str = team;
     match crate::leader::attach_leader(workspace, team_str, None, provider) {
         Ok(result) if result.ok => {
+            let debt = result.attach_window_failures.clone();
             let _ = crate::leader::registry::register_binding_from_state_best_effort(
                 workspace,
                 team_str,
@@ -1864,18 +1868,21 @@ fn try_autobind_leader_after_restart(
                 result.bound_pane_id.as_ref().map(|p| p.as_str()),
                 team_str,
             );
+            debt
         }
         Ok(result) => {
             eprintln!(
                 "team_agent::restart auto_attach_leader skipped reason={:?} team={:?}",
                 result.reason, team_str,
             );
+            None
         }
         Err(error) => {
             eprintln!(
                 "team_agent::restart auto_attach_leader failed error={error} team={team_str:?} \
                  (run `team-agent attach-leader` from your tmux pane to bind manually)",
             );
+            None
         }
     }
 }

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

@@ -18,6 +18,8 @@ mod hermetic_guard;
 
 #[path = "../../../tests/support/composite_source.rs"]
 mod composite_source;
+#[path = "../../../tests/support/brief_probe.rs"]
+mod brief_probe;
 use std::path::{Path, PathBuf};
 
 use serde_json::{json, Value};
@@ -97,6 +99,18 @@ fn stale_snapshot_cannot_flip_status_or_diagnose_ok_readiness() {
     let case = B0HideOneCase::new("status-diagnose-hide-one");
     let root = case.current_state();
     save_runtime_state(&case.workspace, &root).expect("seed current root state");
+    let probe = brief_probe::install_trusted_nodeprobe(
+        &case.workspace.join("probe"),
+        NEW_ENDPOINT,
+        SESSION,
+        WORKER,
+        "%new",
+        "fake",
+    );
+    let _path = case.env.with_env(
+        "PATH",
+        &brief_probe::path_with_probe(&probe, std::env::var_os("PATH").as_deref()),
+    );
 
     let status_before = case.run_json(&[
         "status",
@@ -136,10 +150,20 @@ fn stale_snapshot_cannot_flip_status_or_diagnose_ok_readiness() {
         "--json",
     ]);
 
-    assert_eq!(
-        status_after.pointer("/agents/worker/pane_id").and_then(Value::as_str),
-        Some("%new"),
-        "F0-3 RED3: status must not display the stale snapshot pane as the worker authority; before={status_before} after={status_after}"
+    let node = brief_node(&status_after).unwrap_or_else(|| {
+        panic!("F0-3 RED3: status must retain the worker in the seven-field projection; before={status_before} after={status_after}")
+    });
+    assert_eq!(node.get("name").and_then(Value::as_str), Some(WORKER));
+    assert_eq!(node.get("provider").and_then(Value::as_str), Some("fake"));
+    assert_eq!(node.get("runtime_status").and_then(Value::as_str), Some("running"));
+    assert_eq!(node.get("activity").and_then(Value::as_str), Some("idle"));
+    assert_eq!(node.get("health").and_then(Value::as_str), Some("normal"));
+    assert_eq!(node.get("session_name").and_then(Value::as_str), Some(SESSION));
+    assert!(
+        node.get("tmux_command")
+            .and_then(Value::as_str)
+            .is_some_and(|command| command.contains(NEW_ENDPOINT) && command.contains("team-b0-hideone:worker.%new")),
+        "F0-3 RED3: trusted root probe must produce a non-empty exact endpoint command; node={node}"
     );
     assert_eq!(
         worker_status_tuple(&status_before),
@@ -333,18 +357,25 @@ impl B0HideOneCase {
     }
 }
 
+fn brief_node(status: &Value) -> Option<&Value> {
+    status
+        .get("nodes")
+        .and_then(Value::as_array)
+        .and_then(|nodes| nodes.iter().find(|node| {
+            node.get("name").and_then(Value::as_str) == Some(WORKER)
+        }))
+}
+
 fn worker_status_tuple(status: &Value) -> Value {
-    let worker = status
-        .get("agents")
-        .and_then(Value::as_object)
-        .and_then(|agents| agents.get(WORKER))
-        .cloned()
-        .unwrap_or(Value::Null);
+    let worker = brief_node(status).cloned().unwrap_or(Value::Null);
     json!({
-        "ok": status.get("ok").cloned().unwrap_or(Value::Null),
-        "pane_id": worker.get("pane_id").cloned().unwrap_or(Value::Null),
-        "status": worker.get("status").cloned().unwrap_or(Value::Null),
-        "readiness": status.get("readiness").cloned().unwrap_or(Value::Null),
+        "name": worker.get("name").cloned().unwrap_or(Value::Null),
+        "provider": worker.get("provider").cloned().unwrap_or(Value::Null),
+        "runtime_status": worker.get("runtime_status").cloned().unwrap_or(Value::Null),
+        "activity": worker.get("activity").cloned().unwrap_or(Value::Null),
+        "health": worker.get("health").cloned().unwrap_or(Value::Null),
+        "session_name": worker.get("session_name").cloned().unwrap_or(Value::Null),
+        "tmux_command": worker.get("tmux_command").cloned().unwrap_or(Value::Null),
     })
 }
 

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

@@ -234,6 +234,7 @@ fn clone_ok(case: &Case, source: &str, dest: &str) {
 
 /// clone 后分身 role + spec tools 必须等于源席；三件套源不得被扩成六件。
 #[test]
+#[serial_test::serial(env)]
 fn clone_agent_preserves_source_tools() {
     let case = Case::start();
     let qs = case.run(&[

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

@@ -425,7 +425,7 @@ check behind it = false green); it must reflect an actual doctor result"
 /// Mutates the process-global PATH/HOME — must not race host_cotenant's ps/tmux
 /// shims (P0 pid-probe isolation), hence `#[serial(pid_probe)]`.
 #[test]
-#[serial(pid_probe)]
+#[serial(env, pid_probe)]
 fn t3_claude_auth_hint_parse_failure_is_not_present() {
     let home = tmp_ws("t3-auth-home");
     let shim_dir = home.join("bin");

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

@@ -1,8 +1,8 @@
 use super::launch_spawn::seed_healthy_coordinator;
 use super::*;
 use crate::cli::{
-    cmd_collect, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult, CollectArgs, SendArgs,
-    StatusArgs,
+    cmd_collect, cmd_diagnose, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult,
+    CollectArgs, DiagnoseArgs, SendArgs, StatusArgs,
 };
 use crate::transport::test_support::OfflineTransport;
 use crate::transport::WindowName;
@@ -176,29 +176,28 @@ fn phase_f_golden_events_state_status_zero_drift() {
 #[test]
 #[serial_test::serial(env)]
 fn phase_golden_unbound_not_ready_requires_claim_leader() {
-    // 已废除的行为：旧实现只说不 ready、不说怎么恢复，把人晾在原地。此断言证明它确实没了。
-    // Independent of golden.json so a later regenerate cannot erase it.
-    // Companion status keys grok_slot ← 77bddb95 / 0c319cca; next_action ← 080903a2.
-    let compact = run_compact_status_after_quick_start();
-    let not_ready = compact
-        .get("not_ready")
-        .and_then(Value::as_object)
-        .unwrap_or_else(|| panic!("compact must carry not_ready; got {compact}"));
-    let reasons = not_ready
-        .get("reasons")
+    // Unbound recovery guidance belongs to the diagnose/quick-start refusal
+    // surface, not to the seven-field status brief.
+    let diagnose = run_diagnose_after_quick_start();
+    let issues = diagnose
+        .get("issues")
         .and_then(Value::as_array)
         .cloned()
         .unwrap_or_default();
     assert!(
-        reasons
-            .iter()
-            .any(|reason| reason.as_str() == Some("leader_receiver_unbound")),
-        "tombstone fixture must still produce leader_receiver_unbound; not_ready={not_ready:?}"
+        issues.iter().any(|issue| {
+            issue.as_str() == Some("leader_not_attached")
+                || issue.get("id").and_then(Value::as_str) == Some("leader_channel_unbound")
+        }),
+        "tombstone fixture must still diagnose leader_receiver_unbound; diagnose={diagnose}"
     );
-    assert_eq!(
-        not_ready.get("next_action").and_then(Value::as_str),
-        Some("claim-leader"),
-        "when not_ready.reasons contains leader_receiver_unbound, next_action must be claim-leader; not_ready={not_ready:?}"
+    let repairs = diagnose
+        .get("suggested_repairs")
+        .map(Value::to_string)
+        .unwrap_or_default();
+    assert!(
+        repairs.contains("claim-leader"),
+        "diagnose must retain claim-leader recovery guidance; diagnose={diagnose}"
     );
 }
 
@@ -474,7 +473,7 @@ fn strip_full_line_json_comments(text: &str) -> String {
         .join("\n")
 }
 
-fn run_compact_status_after_quick_start() -> Value {
+fn run_diagnose_after_quick_start() -> Value {
     let hermetic = HermeticTestEnv::enter("tombstone-claim-leader");
     let _permission_mode = EnvVarGuard::set(ANCESTRY_ENV, "[]");
     let team = two_worker_team_dir(&hermetic);
@@ -491,20 +490,17 @@ fn run_compact_status_after_quick_start() -> Value {
         false,
     )
     .expect("tombstone fixture must quick-start");
-    let status = cmd_status(&StatusArgs {
-        agent: None,
+    let diagnose = cmd_diagnose(&DiagnoseArgs {
         workspace,
-        detail: false,
-        summary: false,
         json: true,
         team: Some("teamdir".to_string()),
     });
-    match cmd_value(status) {
+    match cmd_value(diagnose) {
         Value::Object(map) => map
             .get("output")
             .cloned()
-            .unwrap_or_else(|| panic!("compact status missing output")),
-        other => panic!("compact status must be a JSON object, got {other}"),
+            .unwrap_or_else(|| panic!("diagnose missing output")),
+        other => panic!("diagnose must be a JSON object, got {other}"),
     }
 }
 

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

@@ -72,12 +72,19 @@ fn upgrade_0211_state_team_key_runtime_key_not_spec_name() {
         },
         Some(TEAM_KEY),
     ));
+    let node_names = status
+        .get("nodes")
+        .and_then(Value::as_array)
+        .expect("status brief must expose nodes")
+        .iter()
+        .filter_map(|node| node.get("name").and_then(Value::as_str))
+        .collect::<Vec<_>>();
     assert!(
-        status.pointer("/agents/upgrade_worker").is_some(),
+        node_names.contains(&"upgrade_worker"),
         "status --team upgrade-key must project the runtime-key team; status={status}"
     );
     assert!(
-        status.pointer("/agents/sibling_worker").is_none(),
+        !node_names.contains(&"sibling_worker"),
         "status --team upgrade-key must not collapse to sibling/spec-name state; status={status}"
     );
 }
@@ -216,15 +223,20 @@ fn upgrade_status_collect_scope_by_selected_team_key() {
         },
         Some(TEAM_KEY),
     ));
-    assert_eq!(
-        status.pointer("/results/total").and_then(Value::as_i64),
-        Some(2),
-        "status --team upgrade-key must count only upgrade-key results and exclude sibling rows; status={status}"
+    let node_names = status
+        .get("nodes")
+        .and_then(Value::as_array)
+        .expect("status brief must expose nodes")
+        .iter()
+        .filter_map(|node| node.get("name").and_then(Value::as_str))
+        .collect::<Vec<_>>();
+    assert!(
+        node_names.contains(&"upgrade_worker"),
+        "status --team upgrade-key must retain the selected runtime-key node; status={status}"
     );
-    assert_eq!(
-        status.pointer("/messages/accepted").and_then(Value::as_i64),
-        Some(1),
-        "status --team upgrade-key must count only upgrade-key messages; status={status}"
+    assert!(
+        !node_names.contains(&"sibling_worker"),
+        "status --team upgrade-key must not expose sibling rows; status={status}"
     );
 
     let collect = json_output(cmd_collect_for_team(

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

@@ -797,6 +797,8 @@ pub enum RestartReport {
         coordinator: CoordinatorStartSummary,
         next_actions: Vec<String>,
         attach_commands: Vec<String>,
+        /// Debt returned by this restart's best-effort auto-attach, if any.
+        attach_window_failures: Option<serde_json::Value>,
     },
     /// At least one worker failed during live spawn, but other workers were isolated
     /// and restarted. The CLI reports `status=partial` and exits non-zero.
@@ -811,6 +813,8 @@ pub enum RestartReport {
         coordinator: CoordinatorStartSummary,
         next_actions: Vec<String>,
         attach_commands: Vec<String>,
+        /// Debt returned by this restart's best-effort auto-attach, if any.
+        attach_window_failures: Option<serde_json::Value>,
     },
     /// All workers failed during live spawn. No worker is reported as restarted.
     Failed {