@team-agent/installer 0.5.78 → 0.5.80

package/crates/team-agent/src/state/abnormal_watch/tests/mod.rs

@@ -0,0 +1,248 @@
+use super::*;
+use crate::state::persist::{load_runtime_state, runtime_state_path, save_runtime_state};
+
+fn workspace() -> std::path::PathBuf {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    static NEXT: AtomicUsize = AtomicUsize::new(0);
+    let path = std::env::temp_dir().join(format!(
+        "watch-188-{}-{}",
+        std::process::id(),
+        NEXT.fetch_add(1, Ordering::Relaxed)
+    ));
+    std::fs::create_dir_all(path.join(".team/runtime")).unwrap();
+    path
+}
+
+#[test]
+fn complete_empty_roster_prunes_but_missing_roster_and_paused_members_survive() {
+    let mut state = json!({
+        "agents": {},
+        "teams": {
+            "empty": {"agents": {}, "coordinator": {"abnormal_exit_watch": {"old": {}}}},
+            "unknown": {"coordinator": {"abnormal_exit_watch": {"old": {}}}},
+            "paused": {"agents": {"p": {"status": "paused"}}, "coordinator": {
+                "abnormal_exit_watch": {"p": {"last_notified_key": "keep"}, "gone": {}}
+            }}
+        },
+        "coordinator": {"abnormal_exit_watch": {"unknown": {}}}
+    });
+    compact_after_merge(&mut state, None, &[]);
+    assert_eq!(
+        state["teams"]["empty"]["coordinator"]["abnormal_exit_watch"],
+        json!({})
+    );
+    assert_eq!(
+        state["teams"]["unknown"]["coordinator"]["abnormal_exit_watch"],
+        json!({"old": {}})
+    );
+    assert_eq!(
+        state["teams"]["paused"]["coordinator"]["abnormal_exit_watch"],
+        json!({"p": {"last_notified_key": "keep"}})
+    );
+    assert_eq!(
+        state["coordinator"]["abnormal_exit_watch"],
+        json!({"unknown": {}})
+    );
+    assert!(!needs_compaction(&state));
+}
+
+#[test]
+fn root_legacy_union_is_not_migrated_by_bare_agent_name() {
+    let mut state = json!({"agents": {}, "teams": {
+        "a": {"agents": {"w": {}}}, "b": {"agents": {"w": {}}}
+    }, "coordinator": {"abnormal_exit_watch": {"w": {"last_notified_key": "legacy"}, "gone": {}}}});
+    compact_after_merge(&mut state, None, &[]);
+    assert_eq!(
+        state["coordinator"]["abnormal_exit_watch"]
+            .as_object()
+            .unwrap()
+            .len(),
+        1
+    );
+    for team in ["a", "b"] {
+        let projection = crate::state::projection::project_top_level_view(&state, team);
+        assert!(projection["coordinator"]
+            .get("abnormal_exit_watch")
+            .is_none());
+    }
+}
+
+#[test]
+fn fallback_preserves_other_coordinator_fields_and_owned_watch() {
+    let state = json!({"coordinator": {"tick": 9, "abnormal_exit_watch": {"w": {}}}, "teams": {
+        "a": {"agents": {}},
+        "b": {"agents": {}, "coordinator": {"abnormal_exit_watch": {"owned": {}}, "tick": 2}}
+    }});
+    let a = crate::state::projection::project_top_level_view(&state, "a");
+    let b = crate::state::projection::project_top_level_view(&state, "b");
+    assert_eq!(a["coordinator"], json!({"tick": 9}));
+    assert_eq!(b["coordinator"], state["teams"]["b"]["coordinator"]);
+}
+
+fn observed() -> Value {
+    let mut state = json!({"active_team_key": "a", "agents": {"w": {
+        "provider": "codex", "rollout_path": "/fixture/w.jsonl", "spawn_epoch": 1
+    }}, "coordinator": {"abnormal_exit_watch": {"w": {"last_notified_key": "keep"}}}});
+    state["coordinator"]["abnormal_exit_watch"]["w"]["watch_identity"] =
+        observation_identity(&state, "w").unwrap();
+    state
+}
+
+#[test]
+fn observation_identity_separates_same_name_team_path_and_spawn_generation() {
+    let initial = observed();
+    let mut unchanged = initial.clone();
+    begin_observation(&mut unchanged, "w");
+    begin_observation(&mut unchanged, "w");
+    assert_eq!(
+        unchanged, initial,
+        "same observation retains notification dedupe"
+    );
+    for (pointer, value) in [
+        ("/active_team_key", json!("b")),
+        ("/agents/w/rollout_path", json!("/fixture/other.jsonl")),
+        ("/agents/w/spawn_epoch", json!(2)),
+        ("/agents/w/provider", json!("claude")),
+        ("/agents/w/spawned_at", json!("new-incarnation")),
+    ] {
+        let mut changed = initial.clone();
+        if pointer.ends_with("spawned_at") {
+            changed["agents"]["w"]["spawned_at"] = value;
+        } else {
+            *changed.pointer_mut(pointer).unwrap() = value;
+        }
+        begin_observation(&mut changed, "w");
+        assert!(changed["coordinator"]["abnormal_exit_watch"]
+            .get("w")
+            .is_none());
+    }
+}
+
+#[test]
+fn legacy_unknown_identity_is_retained_until_member_is_observed() {
+    let mut state = observed();
+    state["coordinator"]["abnormal_exit_watch"]["w"]
+        .as_object_mut()
+        .unwrap()
+        .remove("watch_identity");
+    let legacy = state.clone();
+    compact_after_merge(&mut state, None, &[]);
+    assert_eq!(
+        state, legacy,
+        "membership compaction cannot guess legacy identity"
+    );
+    begin_observation(&mut state, "w");
+    assert!(state["coordinator"]["abnormal_exit_watch"]
+        .get("w")
+        .is_none());
+}
+
+#[test]
+fn unchanged_normal_save_compacts_large_old_snapshots_and_cannot_resurrect_them() {
+    let ws = workspace();
+    let watch: serde_json::Map<String, Value> = (0..100)
+        .map(|n| {
+            (
+                format!("old-{n}"),
+                json!({"last_notified_key": "x".repeat(100)}),
+            )
+        })
+        .collect();
+    let mut state =
+        json!({"agents": {}, "teams": {}, "coordinator": {"abnormal_exit_watch": watch}});
+    for n in 0..8 {
+        state["teams"][format!("team-{n}")] =
+            json!({"agents": {}, "coordinator": state["coordinator"].clone()});
+    }
+    let original = serde_json::to_vec(&state).unwrap().len();
+    // Warm the old cache without invoking the load-time migrations, which
+    // could otherwise compact before the no-change save under test.
+    crate::state::persist::save_runtime_state_without_migrations(&ws, &state).unwrap();
+    let stale = state;
+    assert_eq!(
+        serde_json::from_slice::<Value>(&std::fs::read(runtime_state_path(&ws)).unwrap())
+            .unwrap(),
+        stale
+    );
+    save_runtime_state(&ws, &stale).unwrap();
+    let first = std::fs::read(runtime_state_path(&ws)).unwrap();
+    assert!(
+        first.len() < original / 10,
+        "size must depend on actual members, not watch x teams"
+    );
+    save_runtime_state(&ws, &stale).unwrap();
+    assert_eq!(std::fs::read(runtime_state_path(&ws)).unwrap(), first);
+    std::fs::remove_dir_all(ws).unwrap();
+}
+
+#[test]
+fn latest_roster_merge_precedes_pruning_and_explicit_deletion_removes_watch() {
+    let ws = workspace();
+    let latest = json!({"active_team_key": "a", "session_name": "team-a", "agents": {
+        "w": {"agent_id": "w", "provider": "codex", "status": "paused"}
+    }, "coordinator": {"abnormal_exit_watch": {"w": {"last_notified_key": "keep"}}}});
+    save_runtime_state(&ws, &latest).unwrap();
+    let mut stale = load_runtime_state(&ws).unwrap();
+    stale["agents"] = json!({});
+    save_runtime_state(&ws, &stale).unwrap();
+    let merged = load_runtime_state(&ws).unwrap();
+    assert!(merged["agents"].get("w").is_some());
+    assert_eq!(
+        merged["coordinator"]["abnormal_exit_watch"]["w"]["last_notified_key"],
+        "keep"
+    );
+    crate::state::persist::save_runtime_state_with_deleted_agents(&ws, &stale, &["w"]).unwrap();
+    let removed = load_runtime_state(&ws).unwrap();
+    assert!(removed["agents"].get("w").is_none());
+    assert_eq!(removed["coordinator"]["abnormal_exit_watch"], json!({}));
+    std::fs::remove_dir_all(ws).unwrap();
+}
+
+#[test]
+fn unknown_team_retains_history_until_observation_but_never_authorizes_reuse() {
+    let mut state = observed();
+    state["active_team_key"] = Value::Null;
+    let before = state.clone();
+    assert!(observation_identity(&state, "w").is_none());
+    compact_after_merge(&mut state, None, &[]);
+    assert_eq!(state, before);
+    assert!(!matches_observation(
+        &state,
+        "w",
+        &state["coordinator"]["abnormal_exit_watch"]["w"]
+    ));
+    begin_observation(&mut state, "w");
+    assert!(state["coordinator"]["abnormal_exit_watch"]
+        .get("w")
+        .is_none());
+}
+
+#[test]
+fn malformed_team_catalog_does_not_authorize_root_pruning() {
+    let mut state =
+        json!({"agents": {}, "teams": [], "coordinator": {"abnormal_exit_watch": {"w": {}}}});
+    let before = state.clone();
+    compact_after_merge(&mut state, None, &[]);
+    assert_eq!(state, before);
+    assert!(!needs_compaction(&state));
+}
+
+#[test]
+fn lock_held_latest_membership_protects_rows_without_roster_stub_fields() {
+    let latest = json!({"agents": {"unknown-row": {}}, "teams": {
+        "new-sibling": {"agents": {"sibling": {}}}
+    }});
+    let mut incoming = json!({"agents": {}, "coordinator": {"abnormal_exit_watch": {
+        "unknown-row": {}, "sibling": {}, "gone": {}
+    }}});
+    compact_after_merge(&mut incoming, Some(&latest), &[]);
+    assert_eq!(
+        incoming["coordinator"]["abnormal_exit_watch"],
+        json!({"unknown-row": {}, "sibling": {}})
+    );
+    compact_after_merge(&mut incoming, Some(&latest), &["unknown-row"]);
+    assert_eq!(
+        incoming["coordinator"]["abnormal_exit_watch"],
+        json!({"sibling": {}})
+    );
+}

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

@@ -0,0 +1,144 @@
+//! Scope and lifecycle boundaries for the abnormal-exit observation cache.
+use std::collections::BTreeSet;
+
+use serde_json::{json, Value};
+
+fn members(state: &Value) -> Option<BTreeSet<String>> {
+    Some(state.get("agents")?.as_object()?.keys().cloned().collect())
+}
+
+// A missing roster is unknown. Only a complete, lock-merged roster authorizes
+// discarding absent members; liveness, pause status and record age do not.
+fn scopes(state: &Value) -> Vec<(Option<String>, Option<BTreeSet<String>>)> {
+    let mut root = members(state);
+    if state.get("teams").is_some_and(|teams| !teams.is_object()) {
+        root = None;
+    }
+    let mut scopes = Vec::new();
+    if let Some(teams) = state.get("teams").and_then(Value::as_object) {
+        for (team, entry) in teams {
+            let roster = members(entry);
+            root = match (root, &roster) {
+                (Some(mut union), Some(keys)) => {
+                    union.extend(keys.iter().cloned());
+                    Some(union)
+                }
+                _ => None,
+            };
+            scopes.push((Some(team.clone()), roster));
+        }
+    }
+    scopes.push((None, root));
+    scopes
+}
+
+pub(crate) fn needs_compaction(state: &Value) -> bool {
+    scopes(state).into_iter().any(|(team, roster)| {
+        let entry = team.as_ref().map_or(state, |key| &state["teams"][key]);
+        roster.is_some_and(|keys| {
+            entry
+                .pointer("/coordinator/abnormal_exit_watch")
+                .and_then(Value::as_object)
+                .is_some_and(|watch| watch.keys().any(|key| !keys.contains(key)))
+        })
+    })
+}
+
+/// Call only after the persistence lock's latest-roster merge.
+pub(crate) fn compact_after_merge(state: &mut Value, latest: Option<&Value>, deleted: &[&str]) {
+    let latest_scopes = latest.map(scopes).unwrap_or_default();
+    for (team, mut roster) in scopes(state) {
+        // The normal merge may omit a roster row with no allowlisted stub
+        // fields, or a whole sibling absent from a stale input. Membership in
+        // lock-held latest still forbids pruning its observation. Only explicit
+        // deletion authority can subtract it from this retention union.
+        if let Some((_, latest_roster)) = latest_scopes.iter().find(|(key, _)| key == &team) {
+            roster = match (roster, latest_roster) {
+                (Some(mut keys), Some(latest_keys)) => {
+                    keys.extend(
+                        latest_keys
+                            .iter()
+                            .filter(|key| !deleted.contains(&key.as_str()))
+                            .cloned(),
+                    );
+                    Some(keys)
+                }
+                _ => None,
+            };
+        }
+        let Some(keys) = roster else { continue };
+        let entry = match team {
+            Some(team) => &mut state["teams"][&team],
+            None => &mut *state,
+        };
+        if let Some(watch) = entry
+            .pointer_mut("/coordinator/abnormal_exit_watch")
+            .and_then(Value::as_object_mut)
+        {
+            watch.retain(|key, _| keys.contains(key));
+        }
+    }
+}
+
+/// New observations carry their team and cohort, never just a bare agent id.
+pub(crate) fn observation_identity(state: &Value, agent_id: &str) -> Option<Value> {
+    let agent = state.get("agents")?.get(agent_id)?;
+    let provider = crate::provider::wire::parse_provider(agent.get("provider")?.as_str()?)?;
+    let path = ["rollout_path", "transcript_path", "session_log_path"]
+        .into_iter()
+        .find_map(|key| agent.get(key).and_then(Value::as_str))
+        .filter(|path| !path.is_empty())?;
+    let spawn_epoch = agent.get("spawn_epoch").and_then(Value::as_u64);
+    let spawned_at = agent
+        .get("spawned_at")
+        .and_then(Value::as_str)
+        .filter(|value| !value.is_empty());
+    // Preserve the watcher's existing legacy cohort: missing spawn fields
+    // remain explicit nulls, never a fabricated generation. A later known
+    // cohort changes this identity and establishes a new baseline.
+    let team = state
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .filter(|team| !team.is_empty())
+        .map(str::to_string)
+        .or_else(|| {
+            let team = super::projection::team_state_key(state);
+            (team != super::projection::CURRENT_TEAM_ALIAS).then_some(team)
+        })?;
+    Some(json!({
+        "team_key": team,
+        "agent_id": agent_id,
+        "provider": crate::provider::wire::provider_wire(provider),
+        "path": path,
+        "spawn_epoch": spawn_epoch,
+        "spawned_at": spawned_at,
+    }))
+}
+
+pub(crate) fn matches_observation(state: &Value, agent_id: &str, row: &Value) -> bool {
+    observation_identity(state, agent_id)
+        .is_some_and(|identity| row.get("watch_identity") == Some(&identity))
+}
+
+/// Legacy/foreign-cohort facts cannot be reused as current observation evidence.
+/// This is invoked only when actually observing the member, not for paused or
+/// otherwise ineligible members. The next scan establishes the ordinary baseline.
+pub(crate) fn begin_observation(state: &mut Value, agent_id: &str) {
+    let identity = observation_identity(state, agent_id);
+    if let Some(watch) = state
+        .pointer_mut("/coordinator/abnormal_exit_watch")
+        .and_then(Value::as_object_mut)
+    {
+        if watch.get(agent_id).is_some_and(|row| {
+            identity
+                .as_ref()
+                .is_none_or(|identity| row.get("watch_identity") != Some(identity))
+        }) {
+            watch.remove(agent_id);
+        }
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod tests;

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

@@ -15,6 +15,7 @@
 //! 绝不 in-place truncate,绝不让审计/重试失败拖垮可见的原 state。
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
+pub(crate) mod abnormal_watch;
 pub mod identity;
 // Stage 0 of identity-boundary unified plan (architect direction 2026-06-23):
 // shared identity primitives. Pure additive — Stage 1+ consume these.

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

@@ -492,7 +492,8 @@ fn persist_runtime_state_with_merge_options_and_expected(
     // Exact-seed cleanup must observe lock-held disk, not a pre-lock cache or
     // byte-equality hit. A matching in-memory document would otherwise no-op
     // and leave the seed, or skip copying a concurrent owner.
-    let skip_pre_lock_fast_path = exact_owner_seed_to_clear.is_some()
+    let skip_pre_lock_fast_path = super::abnormal_watch::needs_compaction(&migrated)
+        || exact_owner_seed_to_clear.is_some()
         || expected_owner_receiver.is_some()
         || exact_owner_receiver_to_clear.is_some()
         || exact_owner_receiver_to_restore.is_some();
@@ -542,7 +543,7 @@ fn persist_runtime_state_with_merge_options_and_expected(
             ));
         }
     }
-    if let Some(latest) = latest {
+    if let Some(latest) = latest.as_ref() {
         let deleted = deleted_agent_ids
             .iter()
             .copied()
@@ -572,7 +573,7 @@ fn persist_runtime_state_with_merge_options_and_expected(
             .collect::<BTreeSet<_>>();
         apply_persist_merge_contract(
             &mut migrated,
-            &latest,
+            latest,
             &deleted,
             skip_capture_backfill_team_key,
             &skip_capture_backfill,
@@ -583,6 +584,7 @@ fn persist_runtime_state_with_merge_options_and_expected(
             exact_owner_receiver_to_restore,
         )?;
     }
+    super::abnormal_watch::compact_after_merge(&mut migrated, latest.as_ref(), deleted_agent_ids);
     // Stage 3 save-output strip second pass (defence-in-depth): after the
     // `preserve_latest_roster_entries` lock-held merge, a future addition
     // to the preserve path could re-introduce root owner fields from the

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

@@ -486,7 +486,13 @@ pub fn project_top_level_view(state: &Value, team_key: &str) -> Value {
         .is_some_and(|o| o.contains_key("coordinator"))
         && !p.contains_key("coordinator")
     {
-        p.insert("coordinator".to_string(), state["coordinator"].clone());
+        let mut coordinator = state["coordinator"].clone();
+        // Workspace legacy watch facts have no proven owner in this team.
+        // Preserve other coordinator fields, but never broadcast this cache.
+        if let Some(coordinator) = coordinator.as_object_mut() {
+            coordinator.remove("abnormal_exit_watch");
+        }
+        p.insert("coordinator".to_string(), coordinator);
     }
     Value::Object(p)
 }

package/crates/team-agent/src/tmux_backend/tests.rs

@@ -355,6 +355,34 @@ fn backend_with(default: MockResp, queued: Vec<MockResp>) -> (TmuxBackend, Recor
     (TmuxBackend::with_runner(Box::new(runner)), recorded)
 }
 
+#[test]
+fn provider_exit_receipt_accepts_only_shell_exit_status() {
+    for (text, expected) in [
+        ("", None),
+        ("running", None),
+        ("[team-agent] pi exited with 0", None),
+        ("256", None),
+        ("0\n", Some(0)),
+        ("17\n", Some(17)),
+        ("143\n", Some(143)),
+    ] {
+        let (backend, recorded) = backend_with(MockResp::Out(ok(text)), Vec::new());
+        assert_eq!(
+            backend.provider_exit_status(&PaneId::new("%47")).unwrap(),
+            expected
+        );
+        let calls = recorded.lock().unwrap();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0][4], "%47");
+        assert_eq!(calls[0][5], "#{@team-agent-provider-exit-status}");
+    }
+    let (backend, _) = backend_with(MockResp::Out(fail(1, "pane unavailable")), Vec::new());
+    assert_eq!(
+        backend.provider_exit_status(&PaneId::new("%47")).unwrap(),
+        None
+    );
+}
+
 fn backend_with_stdin(
     default: MockResp,
     queued: Vec<MockResp>,

package/crates/team-agent/src/tmux_backend.rs

@@ -2656,24 +2656,22 @@ fn append_caller_context_assignments(parts: &mut Vec<String>, provider: Option<&
     ));
 }
 
-/// 0.4.x (CR R6): single-source marker prefix. The exit marker emitted by
-/// `leader_shell_wrapper_command` and the substring detected by
-/// `leader_provider_health` MUST share this prefix exactly. Format:
+/// Public exit-marker text emitted by `leader_shell_wrapper_command`. Format:
 /// `"[team-agent] {provider_label} exited with {rc}"`.
 pub const LEADER_PROVIDER_EXIT_MARKER_PREFIX: &str = "[team-agent]";
 pub const LEADER_PROVIDER_EXIT_MARKER_SUFFIX: &str = "exited with";
+const PROVIDER_EXIT_STATUS_OPTION: &str = "@team-agent-provider-exit-status";
 
 /// 0.4.x (CR R6): build the leader exit marker text for `provider_label`.
-/// Used by both the shell wrapper (printf source) and the health check
-/// (capture substring) so they cannot drift.
+/// Used by the shell wrapper for human-readable output.
 /// ---
 /// purpose: 单一来源地拼出 leader pane 的 provider 退出标记文本
 /// params:
 ///   provider_label: 人类可读的 provider 名,原样嵌入标记
 /// returns: 前缀 + provider 名 + 后缀 拼成的标记(不含退出码,退出码由 shell 的 printf 补)
 /// boundary:
-///   - 写标记的 shell wrapper 与读标记的健康检查必须都用这一个函数,禁止各写一份字面量
-///   - 这是内容信号:pane 里出现同样文本(如 cat 日志)就会误触发,判定强度到此为止
+///   - shell wrapper 统一使用此显示标记,进程状态另由监督 shell 收据证明
+///   - 仅供显示;历史正文可包含相同文本,不得据此判定进程退出
 /// ---
 pub fn leader_provider_exit_marker(provider_label: &str) -> String {
     format!(
@@ -2905,6 +2903,11 @@ pub fn leader_shell_wrapper_command(
         parts.push(key.clone());
         parts.push("&&".to_string());
     }
+    // Clear any prior receipt before invoking the provider. Terminal content,
+    // including replayed sessions, must never be treated as an exit receipt.
+    parts.push(format!(
+        "{{ tmux -S \"${{TMUX%%,*}}\" set-option -p -t \"$TMUX_PANE\" {PROVIDER_EXIT_STATUS_OPTION} running >/dev/null 2>&1 || :; }} &&"
+    ));
     // 3. env exports + provider (NO `exec` so the provider is a child).
     // 0.4.x ordering fix: skip keys present in env_unset so KEY=val does not
     // re-introduce a just-unset variable from the inherited env map.
@@ -2918,6 +2921,9 @@ pub fn leader_shell_wrapper_command(
     parts.push(";".to_string());
     // 4. exit marker + inert shell tail
     parts.push("rc=$?;".to_string());
+    parts.push(format!(
+        "tmux -S \"${{TMUX%%,*}}\" set-option -p -t \"$TMUX_PANE\" {PROVIDER_EXIT_STATUS_OPTION} \"$rc\" >/dev/null 2>&1;"
+    ));
     parts.push("printf".to_string());
     // CR R6: marker text comes from single-source `leader_provider_exit_marker`.
     parts.push(shell_quote(&format!(
@@ -2930,8 +2936,8 @@ pub fn leader_shell_wrapper_command(
 }
 
 fn inert_pane_tail_command() -> String {
-    // `sh` is deliberate: provider-exit health checks use the shell basename
-    // to reach the exit-marker branch. `sh -c` does not read commands from
+    // `sh` is deliberate: exited-wrapper input classifiers recognize shell
+    // basenames. `sh -c` does not read commands from
     // stdin; disabling echo also prevents input from appearing accepted.
     let script = r#"trap '' INT QUIT; stty -echo 2>/dev/null; printf "%s\n" "[team-agent] Provider exited; this pane no longer accepts input. Restart from another pane with the appropriate team-agent start command."; while :; do sleep 3600 & wait "$!"; done"#;
     format!("exec /bin/sh -c {}", shell_quote(script))
@@ -3743,6 +3749,22 @@ impl Transport for TmuxBackend {
         Ok(Some(output.stdout.trim().to_string()))
     }
 
+    fn provider_exit_status(&self, pane: &PaneId) -> Result<Option<u8>, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "display-message".to_string(),
+            "-p".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            format!("#{{{PROVIDER_EXIT_STATUS_OPTION}}}"),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if !output.success {
+            return Ok(None);
+        }
+        Ok(output.stdout.trim().parse::<u8>().ok())
+    }
+
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
         let argv = self.tmux_argv(&[
             "tmux".to_string(),

package/crates/team-agent/src/transport.rs

@@ -981,6 +981,12 @@ pub trait Transport: Send + Sync {
     /// pane 存活三态(`PaneLiveness`,bug-085 穷尽 match;unknown ≠ dead ≠ live)。
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError>;
 
+    /// Exit status recorded by the provider's supervising wrapper, never inferred
+    /// from terminal text. None means running or no authoritative receipt.
+    fn provider_exit_status(&self, _pane: &PaneId) -> Result<Option<u8>, TransportError> {
+        Ok(None)
+    }
+
     /// Cheap direct pane existence check when a backend can prove it. `Ok(None)`
     /// preserves the existing Unknown boundary.
     fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.78",
+  "version": "0.5.80",
   "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.78",
-    "@team-agent/cli-darwin-x64": "0.5.78",
-    "@team-agent/cli-linux-x64": "0.5.78"
+    "@team-agent/cli-darwin-arm64": "0.5.80",
+    "@team-agent/cli-darwin-x64": "0.5.80",
+    "@team-agent/cli-linux-x64": "0.5.80"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",