@team-agent/installer 0.5.78 → 0.5.81

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.78"
+version = "0.5.81"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.78"
+version = "0.5.81"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -248,6 +248,37 @@ mod tests {
             None
         );
     }
+
+    #[cfg(unix)]
+    #[test]
+    fn search_survives_unrelated_spaced_model_ids() {
+        let catalog = include_str!("../lifecycle/tests/fixtures/pi_list_models_spaced_ids.stdout.txt");
+        let path = fixture(&format!("printf '%s' '{catalog}'"));
+        let result = cmd_models_with(
+            &ModelsArgs {
+                provider: "pi".into(),
+                search: Some("gpt-5.6-luna".into()),
+                json: true,
+            },
+            &path,
+            Duration::from_secs(10),
+            MAX_CATALOG_BYTES,
+        )
+        .unwrap();
+        cleanup_fixture(&path);
+        assert_eq!(result.exit, ExitCode::Ok);
+        let CmdOutput::Human(text) = result.output else {
+            panic!("expected JSON projection")
+        };
+        let value: Value = serde_json::from_str(&text).unwrap();
+        assert_eq!(value["ok"], true);
+        assert_eq!(value["auth"], "ok");
+        let models = value["models"].as_array().unwrap();
+        assert_eq!(models.len(), 2);
+        assert_eq!(models[0]["role_model"], "openai-codex/gpt-5.6-luna");
+        assert_eq!(models[1]["role_model"], "team-agent/gpt-5.6-luna");
+    }
+
     #[cfg(unix)]
     fn fixture(body: &str) -> std::path::PathBuf {
         use std::os::unix::fs::PermissionsExt;

package/crates/team-agent/src/cli/status_port/brief.rs

@@ -294,24 +294,39 @@ fn display_optional(value: &Value) -> String {
 }
 
 fn registered_nodes(state: &Value, selected: Option<&str>) -> Vec<RegisteredNode> {
-    let agents = state
-        .get("agents")
-        .and_then(Value::as_object)
-        .or_else(|| {
-            let key = state.get("active_team_key").and_then(Value::as_str)?;
-            state
-                .get("teams")
-                .and_then(|teams| teams.get(key))
-                .and_then(|team| team.get("agents"))
-                .and_then(Value::as_object)
-        });
+    // A projected state can still carry stale top-level agents. Once the
+    // selector identified a canonical team entry, that entry is authoritative;
+    // an empty/missing nested roster must not fall back to the stale projection.
+    let canonical_team = state
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .and_then(|key| state.get("teams").and_then(|teams| teams.get(key)));
+    let (agents, lifecycle, defaults) = match canonical_team {
+        Some(team) => (
+            team.get("agents").and_then(Value::as_object),
+            team.get("agent_lifecycle").and_then(Value::as_object),
+            team,
+        ),
+        None => (
+            state.get("agents").and_then(Value::as_object),
+            state.get("agent_lifecycle").and_then(Value::as_object),
+            state,
+        ),
+    };
     let Some(agents) = agents else {
         return Vec::new();
     };
     agents
         .iter()
         .filter(|(name, _)| selected.is_none_or(|selected| selected == name.as_str()))
-        .map(|(name, value)| registered_node(name, value, state))
+        .filter(|(name, _)| {
+            !lifecycle
+                .and_then(|entries| entries.get(*name))
+                .and_then(|entry| entry.get("state"))
+                .and_then(Value::as_str)
+                .is_some_and(|state| state == "retired")
+        })
+        .map(|(name, value)| registered_node(name, value, defaults))
         .collect()
 }
 
@@ -803,7 +818,7 @@ fn parse_probe(bytes: &[u8], requested_endpoint: &str) -> Result<ProbeResult, ()
         .and_then(Value::as_array)
         .ok_or(())?
         .iter()
-        .filter_map(parse_probe_node)
+        .filter_map(|node| parse_probe_node(node, report_socket))
         .collect();
     Ok(ProbeResult { nodes })
 }
@@ -818,9 +833,12 @@ fn probe_has_error(value: &Value) -> bool {
     }
 }
 
-fn parse_probe_node(value: &Value) -> Option<ProbeNode> {
+fn parse_probe_node(value: &Value, report_socket: &str) -> Option<ProbeNode> {
     Some(ProbeNode {
-        socket: non_empty(value, "socket")?,
+        // The accepted producer binds the socket once at the report envelope
+        // and omits the redundant per-node field. An explicit node socket is
+        // still preserved for strict mismatch rejection below.
+        socket: non_empty(value, "socket").unwrap_or_else(|| report_socket.to_string()),
         session: non_empty(value, "session")?,
         window: non_empty(value, "window_name")?,
         pane: non_empty(value, "pane_id")?,
@@ -926,7 +944,13 @@ fn match_result<'a>(
 fn matches_registered(node: &RegisteredNode, observed: &ProbeNode) -> bool {
     node.endpoint.as_deref() == Some(observed.socket.as_str())
         && node.session.as_deref() == Some(observed.session.as_str())
-        && node.window.as_deref() == Some(observed.window.as_str())
+        // Older registrations may not persist a window. The endpoint,
+        // session, and pane tuple remains the narrow compatibility key; a
+        // present window is still an exact constraint.
+        && node
+            .window
+            .as_deref()
+            .is_none_or(|window| window == observed.window)
         && node.pane.as_deref() == Some(observed.pane.as_str())
 }
 

package/crates/team-agent/src/cli/status_port/runtime.rs

@@ -58,7 +58,9 @@ pub(crate) fn compute_runtime_freshness(
             for (agent_id, entry) in watch {
                 let exited =
                     entry.get("worker_provider_exited").and_then(Value::as_bool) == Some(true);
-                if exited {
+                if exited
+                    && crate::state::abnormal_watch::matches_observation(state, agent_id, entry)
+                {
                     provider_exited_agents.insert(agent_id.clone());
                 }
             }

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

@@ -28,7 +28,12 @@ fn health_fixture() -> crate::coordinator::HealthReport {
 
 #[test]
 fn runtime_freshness_provider_exit_requires_typed_positive_fact() {
-    let state = serde_json::json!({
+    let mut state = serde_json::json!({
+        "active_team_key": "status-team",
+        "agents": {
+            "pane_only": {"provider": "codex", "rollout_path": "/fixture/pane", "spawn_epoch": 1},
+            "typed_exit": {"provider": "codex", "rollout_path": "/fixture/typed", "spawn_epoch": 1}
+        },
         "coordinator": {
             "abnormal_exit_watch": {
                 "pane_only": {
@@ -43,6 +48,10 @@ fn runtime_freshness_provider_exit_requires_typed_positive_fact() {
         }
     });
 
+    for id in ["pane_only", "typed_exit"] {
+        state["coordinator"]["abnormal_exit_watch"][id]["watch_identity"] =
+            crate::state::abnormal_watch::observation_identity(&state, id).unwrap();
+    }
     let freshness = compute_runtime_freshness(
         Path::new("/nonexistent/status-port-typed-provider-exit-test"),
         &state,
@@ -52,3 +61,30 @@ fn runtime_freshness_provider_exit_requires_typed_positive_fact() {
     assert!(!freshness.provider_exited_agents.contains("pane_only"));
     assert!(freshness.provider_exited_agents.contains("typed_exit"));
 }
+
+#[test]
+fn runtime_freshness_rejects_foreign_legacy_and_unknown_watch_identity() {
+    let mut state = json!({
+        "active_team_key": "a",
+        "agents": {"w": {"provider": "codex", "rollout_path": "/fixture/w", "spawn_epoch": 1}},
+        "coordinator": {"abnormal_exit_watch": {"w": {"worker_provider_exited": true}}}
+    });
+    let path = Path::new("/nonexistent/status-watch-188");
+    assert!(compute_runtime_freshness(path, &state, &health_fixture())
+        .provider_exited_agents
+        .is_empty());
+    let identity = crate::state::abnormal_watch::observation_identity(&state, "w").unwrap();
+    state["coordinator"]["abnormal_exit_watch"]["w"]["watch_identity"] = identity;
+    for (pointer, value) in [
+        ("/active_team_key", json!("b")),
+        ("/agents/w/provider", json!("claude")),
+        ("/agents/w/spawn_epoch", json!(2)),
+        ("/agents/w/rollout_path", json!(null)),
+    ] {
+        let mut changed = state.clone();
+        *changed.pointer_mut(pointer).unwrap() = value;
+        assert!(compute_runtime_freshness(path, &changed, &health_fixture())
+            .provider_exited_agents
+            .is_empty());
+    }
+}

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

@@ -685,6 +685,205 @@ fn cmd_status_multi_endpoint_uses_total_budget() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[cfg(unix)]
+#[test]
+#[serial(status_brief)]
+fn cmd_status_uses_canonical_roster_and_filters_same_team_retired_tombstones() {
+    let ws = brief_workspace("canonical-roster");
+    let mut stale = serde_json::Map::new();
+    for index in 0..220 {
+        stale.insert(
+            format!("stale-{index}"),
+            production_agent(&format!("stale-{index}"), &format!("%{index}")),
+        );
+    }
+    let mut stopped = production_agent("stopped", "%9");
+    stopped["status"] = json!("stopped");
+    let state = json!({
+        "session_name": "team-demo",
+        "tmux_endpoint": "/tmp/ta-status-brief.sock",
+        "tmux_socket": "/tmp/ta-status-brief.sock",
+        "active_team_key": "demo",
+        "agents": stale,
+        "teams": {
+            "demo": {
+                "status": "alive",
+                "session_name": "team-demo",
+                "tmux_endpoint": "/tmp/ta-status-brief.sock",
+                "agents": {
+                    "live": production_agent("live", "%7"),
+                    "retired": production_agent("retired", "%8"),
+                    "stopped": stopped
+                },
+                "agent_lifecycle": {
+                    "retired": {"state": "retired"}
+                }
+            },
+            "sibling": {
+                "status": "alive",
+                "agent_lifecycle": {"live": {"state": "retired"}}
+            }
+        }
+    });
+    write_state(&ws, &state);
+    let bin = write_nodeprobe(
+        &ws.join("probe"),
+        "printf '%s\\n' '{\"schema_version\":1,\"socket\":\"/tmp/ta-status-brief.sock\",\"nodes\":[]}'\n",
+    );
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&ws, true, None, Some("demo"))).expect("status"))
+    });
+    let mut names = nodes
+        .iter()
+        .filter_map(|node| node["name"].as_str())
+        .collect::<Vec<_>>();
+    names.sort_unstable();
+    assert_eq!(names, vec!["live", "stopped"]);
+    assert_eq!(
+        nodes
+            .iter()
+            .find(|node| node["name"] == "stopped")
+            .and_then(|node| node["runtime_status"].as_str()),
+        Some("stopped")
+    );
+    let err = cmd_status(&status_args(&ws, true, Some("retired"), Some("demo"))).unwrap_err();
+    assert!(err.to_string().contains("unknown agent id: retired"), "{err}");
+
+    let empty = brief_workspace("canonical-empty");
+    write_state(
+        &empty,
+        &json!({
+            "active_team_key": "demo",
+            "agents": {"stale": production_agent("stale", "%1")},
+            "teams": {
+                "demo": {
+                    "status": "alive",
+                    "agents": {},
+                    "agent_lifecycle": {}
+                }
+            }
+        }),
+    );
+    assert!(json_nodes(cmd_status(&status_args(&empty, true, None, None)).expect("status")).is_empty());
+    let _ = std::fs::remove_dir_all(&ws);
+    let _ = std::fs::remove_dir_all(&empty);
+}
+
+#[cfg(unix)]
+#[test]
+#[serial(status_brief)]
+fn cmd_status_allows_only_missing_window_compatibility_match() {
+    let ws = brief_workspace("missing-window");
+    let mut agent = production_agent("worker", "%7");
+    agent.as_object_mut().unwrap().remove("window");
+    agent.as_object_mut().unwrap().remove("layout_window");
+    agent
+        .get_mut("display")
+        .and_then(Value::as_object_mut)
+        .unwrap()
+        .remove("window");
+    write_state(
+        &ws,
+        &production_state(json!({"worker": agent})),
+    );
+    let report = producer_report(
+        "/tmp/ta-status-brief.sock",
+        "observed-window",
+        "%7",
+        "pi_activity_channel",
+    );
+    let bin = write_nodeprobe(&ws.join("probe"), &format!("cat <<'EOF'\n{report}\nEOF\n"));
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&ws, true, None, None)).expect("status"))
+    });
+    assert_eq!(nodes[0]["runtime_status"], "running");
+    assert_eq!(nodes[0]["activity"], "idle");
+    assert_eq!(
+        nodes[0]["tmux_command"],
+        "tmux -S '/tmp/ta-status-brief.sock' attach -t 'team-demo:observed-window.%7'"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+
+    let conflict = brief_workspace("present-window-conflict");
+    write_state(
+        &conflict,
+        &production_state(json!({"worker": production_agent("worker", "%7")})),
+    );
+    let report = producer_report(
+        "/tmp/ta-status-brief.sock",
+        "different-window",
+        "%7",
+        "pi_activity_channel",
+    );
+    let bin = write_nodeprobe(&conflict.join("probe"), &format!("cat <<'EOF'\n{report}\nEOF\n"));
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&conflict, true, None, None)).expect("status"))
+    });
+    assert_eq!(nodes[0]["runtime_status"], "unknown");
+    assert!(nodes[0]["tmux_command"].is_null());
+    let _ = std::fs::remove_dir_all(&conflict);
+}
+
+#[cfg(unix)]
+#[test]
+#[serial(status_brief)]
+fn cmd_status_accepts_envelope_bound_node_socket_but_rejects_explicit_mismatch() {
+    let ws = brief_workspace("envelope-node-socket");
+    write_state(
+        &ws,
+        &production_state(json!({"worker": production_agent("worker", "%7")})),
+    );
+    let mut report: Value =
+        serde_json::from_str(&producer_report(
+            "/tmp/ta-status-brief.sock",
+            "worker",
+            "%7",
+            "pi_activity_channel",
+        ))
+        .unwrap();
+    report["nodes"][0].as_object_mut().unwrap().remove("socket");
+    let report = serde_json::to_string(&report).unwrap();
+    let bin = write_nodeprobe(&ws.join("probe"), &format!("cat <<'EOF'\n{report}\nEOF\n"));
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&ws, true, None, None)).expect("status"))
+    });
+    assert_eq!(nodes[0]["runtime_status"], "running");
+    assert_eq!(nodes[0]["activity"], "idle");
+    assert_eq!(nodes[0]["health"], "normal");
+    assert_eq!(nodes[0]["session_name"], "pi-session");
+    assert_eq!(
+        nodes[0]["tmux_command"],
+        "tmux -S '/tmp/ta-status-brief.sock' attach -t 'team-demo:worker.%7'"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+
+    let mismatch = brief_workspace("explicit-node-socket-mismatch");
+    write_state(
+        &mismatch,
+        &production_state(json!({"worker": production_agent("worker", "%7")})),
+    );
+    let mut report: Value =
+        serde_json::from_str(&producer_report(
+            "/tmp/ta-status-brief.sock",
+            "worker",
+            "%7",
+            "pi_activity_channel",
+        ))
+        .unwrap();
+    report["nodes"][0]["socket"] = json!("/tmp/other.sock");
+    let report = serde_json::to_string(&report).unwrap();
+    let bin = write_nodeprobe(
+        &mismatch.join("probe"),
+        &format!("cat <<'EOF'\n{report}\nEOF\n"),
+    );
+    let nodes = status_port::with_test_nodeprobe(bin, || {
+        json_nodes(cmd_status(&status_args(&mismatch, true, None, None)).expect("status"))
+    });
+    assert_eq!(nodes[0]["runtime_status"], "unknown");
+    assert!(nodes[0]["tmux_command"].is_null());
+    let _ = std::fs::remove_dir_all(&mismatch);
+}
+
 #[cfg(unix)]
 fn pid_alive(pid: u32) -> bool {
     unsafe { libc::kill(pid as i32, 0) == 0 }

package/crates/team-agent/src/coordinator/steps/abnormal.rs

@@ -73,6 +73,8 @@ pub(crate) fn detect_abnormal_exits(
     let team = crate::state::projection::team_state_key(&snapshot);
     let session_name = snapshot.get("session_name").and_then(Value::as_str);
     for agent in abnormal_watch_agents(&snapshot) {
+        // Reject untrusted history without skipping a fresh provider/path observation.
+        crate::state::abnormal_watch::begin_observation(state, &agent.agent_id);
         // Pane/process liveness is independent of transcript content. A
         // frozen rollout is common after pane death, so probe before the
         // metadata dedupe gate; only the expensive tail scan stays deduped.
@@ -109,7 +111,7 @@ pub(crate) fn detect_abnormal_exits(
         // re-read below.
         if let (Some(mtime), Some(stored)) = (
             mtime_ns,
-            abnormal_watch_stored_metadata(&snapshot, &agent.agent_id),
+            abnormal_watch_stored_metadata(state, &agent.agent_id),
         ) {
             if stored == (size, mtime) {
                 refresh_abnormal_watch_liveness(state, &agent.agent_id, &liveness);
@@ -149,7 +151,7 @@ pub(crate) fn detect_abnormal_exits(
             .map(|fact| abnormal_error_observation_key(&agent, fact));
         let error_observation_cohort = fact.as_ref().map(|_| abnormal_error_cohort_key(&agent));
         let error_recency = abnormal_error_recency(
-            &snapshot,
+            state,
             &agent,
             error_observation_key.as_deref(),
             error_observation_cohort.as_deref(),
@@ -954,6 +956,9 @@ fn abnormal_watch_payload(
 }
 
 fn upsert_abnormal_watch(state: &mut Value, agent_id: &str, mut payload: Value) {
+    if let Some(identity) = crate::state::abnormal_watch::observation_identity(state, agent_id) {
+        payload["watch_identity"] = identity;
+    }
     let preserved = [
         "last_notified_key",
         "last_notified_at",
@@ -1413,6 +1418,121 @@ mod tests {
             crate::provider::get_adapter(provider)
         }
     }
+    #[test]
+    fn resource188_foreign_metadata_and_dedupe_cannot_skip_new_baseline() {
+        let dir = temp_abnormal_dir("188-foreign-watch");
+        let rollout = dir.join("rollout-w1.jsonl");
+        let error = "{\"method\":\"turn/completed\",\"params\":{\"turn\":{\"id\":\"old\",\"status\":\"failed\"}}}\n";
+        std::fs::write(&rollout, error).unwrap();
+        seed_abnormal_state(&dir, &rollout, "alive", 1);
+        let mut state = crate::state::persist::load_runtime_state(&dir).unwrap();
+        let metadata = std::fs::metadata(&rollout).unwrap();
+        let mut foreign = crate::state::abnormal_watch::observation_identity(&state, "w1").unwrap();
+        foreign["team_key"] = serde_json::json!("another-team");
+        state["coordinator"] = serde_json::json!({"abnormal_exit_watch": {"w1": {
+            "watch_identity": foreign,
+            "size": metadata.len(), "mtime_ns": metadata_mtime_ns(&metadata),
+            "last_notified_key": "foreign", "last_check_key": "foreign",
+            "last_error_observation_key": "foreign", "last_error_observation_cohort": "foreign"
+        }}});
+        let log = EventLog::new(&dir);
+        let transport = crate::transport::test_support::OfflineTransport::new();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        let baseline = state["coordinator"]["abnormal_exit_watch"]["w1"].clone();
+        assert_eq!(baseline["error_recency"], "stale");
+        assert!(baseline.get("last_notified_key").is_none());
+        assert!(crate::state::abnormal_watch::matches_observation(
+            &state, "w1", &baseline
+        ));
+        let events = log.tail(0).unwrap();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        assert_eq!(
+            log.tail(0).unwrap(),
+            events,
+            "unchanged baseline must not re-alarm"
+        );
+        assert!(find_event(&events, "worker.abnormal_exit").is_none());
+    }
+
+    #[test]
+    fn resource188_legacy_missing_cohort_still_observes_fresh_errors_and_dedupes() {
+        let dir = temp_abnormal_dir("188-legacy-cohort");
+        let rollout = dir.join("rollout-w1.jsonl");
+        let error = "{\"method\":\"turn/completed\",\"params\":{\"turn\":{\"id\":\"old\",\"status\":\"failed\"}}}\n";
+        std::fs::write(&rollout, error).unwrap();
+        seed_abnormal_state(&dir, &rollout, "alive", 1);
+        let mut state = crate::state::persist::load_runtime_state(&dir).unwrap();
+        state["agents"]["w1"]
+            .as_object_mut()
+            .unwrap()
+            .remove("spawn_epoch");
+        let log = EventLog::new(&dir);
+        let transport = crate::transport::test_support::OfflineTransport::new();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        assert_eq!(
+            state["coordinator"]["abnormal_exit_watch"]["w1"]["error_recency"],
+            "stale"
+        );
+        assert!(find_event(&log.tail(0).unwrap(), "worker.abnormal_exit").is_none());
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(&rollout)
+            .unwrap()
+            .write_all(error.replace("old", "new-error").as_bytes())
+            .unwrap();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        let events = log.tail(0).unwrap();
+        assert_eq!(
+            find_event(&events, "worker.abnormal_exit").unwrap()["error_recency"],
+            "fresh"
+        );
+        let notified =
+            state["coordinator"]["abnormal_exit_watch"]["w1"]["last_notified_key"].clone();
+        assert!(notified.is_string());
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        assert_eq!(log.tail(0).unwrap(), events);
+        assert_eq!(
+            state["coordinator"]["abnormal_exit_watch"]["w1"]["last_notified_key"],
+            notified
+        );
+        state["agents"]["w1"]["spawn_epoch"] = serde_json::json!(2);
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        let watch = &state["coordinator"]["abnormal_exit_watch"]["w1"];
+        assert_eq!(
+            watch["error_recency"], "stale",
+            "a known generation must rebaseline unchanged bytes"
+        );
+        assert!(watch.get("last_notified_key").is_none());
+        assert_eq!(
+            log.tail(0)
+                .unwrap()
+                .iter()
+                .filter(|event| event["event"] == "worker.abnormal_exit")
+                .count(),
+            1
+        );
+    }
+
+    #[test]
+    fn resource188_unknown_team_still_records_fresh_liveness_without_reusing_cache() {
+        let dir = temp_abnormal_dir("188-unknown-team");
+        let rollout = dir.join("rollout-w1.jsonl");
+        std::fs::write(&rollout, "").unwrap();
+        seed_abnormal_state(&dir, &rollout, "dead", 1);
+        let mut state = crate::state::persist::load_runtime_state(&dir).unwrap();
+        state.as_object_mut().unwrap().remove("active_team_key");
+        let log = EventLog::new(&dir);
+        let transport = crate::transport::test_support::OfflineTransport::new();
+        detect_abnormal_exits(&dir, &transport, &mut state, &log, &[]).unwrap();
+        assert_eq!(
+            state["coordinator"]["abnormal_exit_watch"]["w1"]["last_liveness"],
+            "dead"
+        );
+        assert!(state["coordinator"]["abnormal_exit_watch"]["w1"]
+            .get("watch_identity")
+            .is_none());
+    }
+
     #[test]
     fn abnormal_stale_error_baselines_then_fresh_alive_error_notifies() {
         let dir = temp_abnormal_dir("alive-fresh");

package/crates/team-agent/src/coordinator/tests/mod.rs

@@ -282,6 +282,7 @@ fn read_event_log_dir(dir: &std::path::Path) -> Vec<serde_json::Value> {
 }
 
 mod a0_lostupdate;
+mod s3_bounded;
 mod abnormal;
 mod api_error_recovery;
 mod basics;