@team-agent/installer 0.5.60 → 0.5.62

package/crates/team-agent/src/leader/tests/identity.rs

@@ -94,8 +94,13 @@ fn leader_start_plan_pins_mode_and_leader_env() {
     );
     assert!(!plan.is_external_leader);
     assert!(
-        plan.argv.iter().any(|arg| arg == "attach-session"),
-        "no-tmux managed launch attaches the user client to the leader window: {:?}",
+        plan.argv.len() >= 5
+            && plan.argv[0] == "tmux"
+            && plan.argv[1] == "-L"
+            && plan.argv[2].starts_with("ta-")
+            && plan.argv.iter().any(|arg| arg == "attach-session")
+            && plan.argv.iter().any(|arg| arg.ends_with(":fake")),
+        "no-tmux managed launch uses the workspace socket and attaches the user client to the leader window: {:?}",
         plan.argv
     );
     // plan 边界 detached 恒 false(`-d` 插入在 start_leader 层,非此处)。
@@ -130,7 +135,7 @@ fn leader_start_plan_external_leader_keeps_exec_provider_in_tmux() {
     std::fs::create_dir_all(&ws).unwrap();
 
     let provider_args = vec!["--".to_string(), "--model".to_string(), "opus".to_string()];
-    let plan = leader_start_plan(
+    let plan = crate::leader::start::leader_start_plan_after_ambient_authority_check(
         Provider::Fake,
         &provider_args,
         &ws,
@@ -202,7 +207,7 @@ fn managed_leader_uses_dedicated_leader_session_independent_of_state_session_nam
 
 #[test]
 #[serial_test::serial(env)]
-fn in_tmux_default_leader_runs_provider_in_current_pane() {
+fn in_tmux_default_leader_uses_managed_client_and_external_opt_out_keeps_exec_provider() {
     let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
     let ws = std::env::temp_dir().join(format!("ta_rs_lsp_switch_{}", std::process::id()));
     std::fs::create_dir_all(&ws).unwrap();
@@ -210,26 +215,65 @@ fn in_tmux_default_leader_runs_provider_in_current_pane() {
     let endpoint = format!("/private/tmp/tmux-501/{socket},88432,187");
     let _e = EnvGuard::apply(&[("TMUX", Some(&endpoint)), ("TMUX_PANE", Some("%7"))]);
 
-    let plan = leader_start_plan(Provider::Fake, &[], &ws, false, false, None, false).unwrap();
+    let managed = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        false,
+    )
+    .unwrap();
 
-    assert_eq!(plan.mode, LeaderStartMode::ExecProvider);
-    assert!(!plan.is_external_leader);
-    assert!(plan.session_name.is_none());
-    assert_eq!(plan.leader_window, None);
-    assert_eq!(plan.argv, vec!["fake".to_string()]);
+    assert_eq!(
+        managed.mode,
+        LeaderStartMode::ManagedTmuxClient,
+        "N41 managed default: an in-tmux caller on the workspace server must use the managed client path"
+    );
+    assert!(!managed.is_external_leader);
+    assert!(managed.session_name.is_some());
+    assert_eq!(
+        managed.leader_window.as_ref().map(WindowName::as_str),
+        Some("fake")
+    );
     assert!(
-        !plan
+        managed.argv.iter().any(|arg| arg == "switch-client")
+            && !managed.argv.iter().any(|arg| arg == "attach-session"),
+        "N41 managed default: same-server dispatch must switch the existing client, not nested-attach: {:?}",
+        managed.argv
+    );
+    assert_eq!(managed.provider_argv, vec!["fake".to_string()]);
+
+    let external = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        true,
+    )
+    .unwrap();
+
+    assert_eq!(external.mode, LeaderStartMode::ExecProvider);
+    assert!(external.is_external_leader);
+    assert_eq!(external.leader_window, None);
+    assert_eq!(external.argv, vec!["fake".to_string()]);
+    assert_eq!(external.provider_argv, vec!["fake".to_string()]);
+    assert!(
+        !external
             .argv
             .iter()
             .any(|arg| arg == "switch-client" || arg == "attach-session"),
-        "in-tmux default launch must not create or attach a background leader session: {:?}",
-        plan.argv
+        "N41 external opt-out: explicit external topology must remain a direct provider path: {:?}",
+        external.argv
     );
 }
 
 #[test]
 #[serial_test::serial(env)]
-fn in_tmux_default_leader_does_not_refuse_different_tmux_server() {
+fn in_tmux_external_opt_out_keeps_exec_provider_across_server_boundary() {
     let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
     let _e = EnvGuard::apply(&[
         ("TMUX", Some("/private/tmp/tmux-501/default,88432,187")),
@@ -238,12 +282,21 @@ fn in_tmux_default_leader_does_not_refuse_different_tmux_server() {
     let ws = std::env::temp_dir().join(format!("ta_rs_lsp_refuse_{}", std::process::id()));
     std::fs::create_dir_all(&ws).unwrap();
 
-    let plan = leader_start_plan(Provider::Fake, &[], &ws, false, false, None, false).unwrap();
+    let plan = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        true,
+    )
+    .unwrap();
 
     assert_eq!(plan.mode, LeaderStartMode::ExecProvider);
-    assert!(!plan.is_external_leader);
-    assert!(plan.session_name.is_none());
+    assert!(plan.is_external_leader);
     assert_eq!(plan.argv, vec!["fake".to_string()]);
+    assert_eq!(plan.provider_argv, vec!["fake".to_string()]);
 }
 
 #[test]
@@ -420,45 +473,4 @@ fn p2_leader_detect_divergence_catches_owner_uuid_split() {
 // refactor must also update these tests.
 // ═══════════════════════════════════════════════════════════════════════
 
-#[test]
-fn unit0_leader_session_prefix_constant_is_stable() {
-    // Pinned: the literal leader session prefix that gates "is this a
-    // leader session" decisions everywhere in the runtime.
-    assert_eq!(
-        crate::leader::start::LEADER_SESSION_PREFIX,
-        "team-agent-leader-"
-    );
-    // The layout module re-exports the same value (kept in sync via
-    // const re-export).
-    assert_eq!(
-        crate::layout::sessions::LEADER_SESSION_PREFIX,
-        crate::leader::start::LEADER_SESSION_PREFIX
-    );
-}
-
-#[test]
-fn unit0_leader_prefixed_name_must_never_be_taken_as_worker_session() {
-    // Pinned invariant fed into unit-1 typed identity: any session
-    // name starting with `LEADER_SESSION_PREFIX` is a leader launcher
-    // session, never a worker session. unit-1 will wrap this rule in
-    // typed constructors (`WorkerSession::new` rejects the prefix,
-    // `LeaderLauncherSession::new` requires it).
-    let leader = "team-agent-leader-claude-x-aaaaaaaaaaaa";
-    let worker = "team-real-worker";
-    let prefix = crate::leader::start::LEADER_SESSION_PREFIX;
-    assert!(leader.starts_with(prefix));
-    assert!(!worker.starts_with(prefix));
-    // Symmetry: the runtime today uses this exact check
-    // (cli/mod.rs:261 `starts_with(LEADER_SESSION_PREFIX)`) to spare
-    // leader sessions during shutdown.
-    let leader_name = crate::transport::SessionName::new(leader);
-    let worker_name = crate::transport::SessionName::new(worker);
-    assert!(
-        crate::layout::sessions::is_leader_session(&leader_name),
-        "is_leader_session must accept a leader-prefixed session",
-    );
-    assert!(
-        !crate::layout::sessions::is_leader_session(&worker_name),
-        "is_leader_session must reject a non-prefixed session",
-    );
-}
+include!("identity_session_names.rs");

package/crates/team-agent/src/leader/tests/identity_session_names.rs

@@ -0,0 +1,42 @@
+#[test]
+fn unit0_leader_session_prefix_constant_is_stable() {
+    // Pinned: the literal leader session prefix that gates "is this a
+    // leader session" decisions everywhere in the runtime.
+    assert_eq!(
+        crate::leader::start::LEADER_SESSION_PREFIX,
+        "team-agent-leader-"
+    );
+    // The layout module re-exports the same value (kept in sync via
+    // const re-export).
+    assert_eq!(
+        crate::layout::sessions::LEADER_SESSION_PREFIX,
+        crate::leader::start::LEADER_SESSION_PREFIX
+    );
+}
+
+#[test]
+fn unit0_leader_prefixed_name_must_never_be_taken_as_worker_session() {
+    // Pinned invariant fed into unit-1 typed identity: any session
+    // name starting with `LEADER_SESSION_PREFIX` is a leader launcher
+    // session, never a worker session. unit-1 will wrap this rule in
+    // typed constructors (`WorkerSession::new` rejects the prefix,
+    // `LeaderLauncherSession::new` requires it).
+    let leader = "team-agent-leader-claude-x-aaaaaaaaaaaa";
+    let worker = "team-real-worker";
+    let prefix = crate::leader::start::LEADER_SESSION_PREFIX;
+    assert!(leader.starts_with(prefix));
+    assert!(!worker.starts_with(prefix));
+    // Symmetry: the runtime today uses this exact check
+    // (cli/mod.rs:261 `starts_with(LEADER_SESSION_PREFIX)`) to spare
+    // leader sessions during shutdown.
+    let leader_name = crate::transport::SessionName::new(leader);
+    let worker_name = crate::transport::SessionName::new(worker);
+    assert!(
+        crate::layout::sessions::is_leader_session(&leader_name),
+        "is_leader_session must accept a leader-prefixed session",
+    );
+    assert!(
+        !crate::layout::sessions::is_leader_session(&worker_name),
+        "is_leader_session must reject a non-prefixed session",
+    );
+}

package/crates/team-agent/src/leader/tests/idle.rs

@@ -1,198 +1,5 @@
 use super::*;
 
-// =====================================================================
-// 8. idle-takeover 接线 — build_idle_nodes / leader_node(unimplemented → RED)
-//    命门:rollout_path=None → Unknown → never idle;leader path/provider 缺 → 省略;
-//    MUST-NOT-13:经 TurnStateClassifier mock,断言零 provider client 直连。
-// =====================================================================
-
-// build_idle_nodes:一个 worker 有 rollout_path(可读)→ classifier.classify 被调一次;
-// 经注入分类器(零 provider client)。stopped/paused 跳过。
-#[test]
-fn build_idle_nodes_uses_injected_classifier_no_provider_client() {
-    // 真实 session 文件,使 _read_session_tail 读到非空 → classifier 返回注入 state。
-    let dir = std::env::temp_dir().join(format!("ta_rs_idle_{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let log = dir.join("w1.jsonl");
-    std::fs::write(&log, b"{\"type\":\"turn_complete\"}\n").unwrap();
-    let state = serde_json::json!({
-        "agents": {
-            "w1": {"provider": "codex", "rollout_path": log.to_string_lossy(), "status": "running"},
-            "w_stopped": {"provider": "codex", "rollout_path": log.to_string_lossy(), "status": "stopped"},
-        }
-    });
-    let clf = CountingClassifier::new(TurnState::Idle);
-    let nodes = build_idle_nodes(&state, &clf).unwrap();
-    // stopped 被跳过(__init__ wiring:29)→ 仅 w1。
-    assert_eq!(nodes.len(), 1);
-    assert_eq!(nodes[0].node_id, "w1");
-    assert_eq!(nodes[0].role, NodeRole::Worker);
-    assert_eq!(nodes[0].state, TurnState::Idle);
-    // MUST-NOT-13:分类只经注入 classifier(此 mock 计数==1),零 provider client 直连。
-    assert_eq!(clf.calls.get(), 1, "每个 live node 恰调一次注入 classify");
-}
-
-// bug-085:rollout_path=None → 读到空串 → Unknown(不当 idle)。
-#[test]
-fn build_idle_nodes_none_rollout_path_yields_unknown_not_idle() {
-    let state = serde_json::json!({
-        "agents": {
-            "w1": {"provider": "codex", "status": "running"} // 无 rollout_path。
-        }
-    });
-    // 即使 mock 默认想返 Idle,空 session-log → classifier 返 Unknown(见 mock 逻辑)。
-    let clf = CountingClassifier::new(TurnState::Idle);
-    let nodes = build_idle_nodes(&state, &clf).unwrap();
-    assert_eq!(nodes.len(), 1);
-    assert_eq!(
-        nodes[0].state,
-        TurnState::Unknown,
-        "None rollout_path → Unknown,绝不 idle"
-    );
-    assert!(
-        !nodes[0].state.is_idle_for_takeover(),
-        "unknown ≠ idle:不得对 takeover 放行"
-    );
-}
-
-// _leader_node:leader path 或 provider 缺 → None(省略而非猜 idle)。
-#[test]
-fn leader_node_omitted_when_path_or_provider_missing() {
-    let clf = CountingClassifier::new(TurnState::Idle);
-    // 既无 leader.rollout_path 也无 receiver.rollout_path → None。
-    let state_no_path = serde_json::json!({
-        "leader": {"id": "leader", "provider": "codex"},
-        "leader_receiver": {"provider": "codex"}
-    });
-    assert!(
-        leader_node(&state_no_path, &clf).unwrap().is_none(),
-        "缺 path → 省略 leader 节点"
-    );
-    // 有 path 但无 provider → None。
-    let dir = std::env::temp_dir().join(format!("ta_rs_lnode_{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let log = dir.join("leader.jsonl");
-    std::fs::write(&log, b"{\"type\":\"turn_open\"}\n").unwrap();
-    let state_no_provider = serde_json::json!({
-        "leader": {"id": "leader", "rollout_path": log.to_string_lossy()}
-    });
-    assert!(
-        leader_node(&state_no_provider, &clf).unwrap().is_none(),
-        "缺 provider → 省略 leader 节点(不猜 idle)"
-    );
-}
-
-// _leader_node:path+provider 齐 → 经 classifier 产 role=leader 节点(C13)。
-#[test]
-fn leader_node_classified_via_injected_classifier() {
-    let dir = std::env::temp_dir().join(format!("ta_rs_lnode2_{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let log = dir.join("leader.jsonl");
-    std::fs::write(&log, b"{\"type\":\"turn_complete\"}\n").unwrap();
-    let state = serde_json::json!({
-        "leader": {"id": "leader", "provider": "codex", "rollout_path": log.to_string_lossy()}
-    });
-    let clf = CountingClassifier::new(TurnState::Working);
-    let node = leader_node(&state, &clf)
-        .unwrap()
-        .expect("path+provider 齐 → 有 leader 节点");
-    assert_eq!(node.role, NodeRole::Leader);
-    assert_eq!(node.node_id, "leader");
-    assert_eq!(node.state, TurnState::Working);
-    assert_eq!(
-        clf.calls.get(),
-        1,
-        "leader 分类经注入 classifier 一次,零 provider client"
-    );
-}
-
-// =====================================================================
-// 9. classify_provider_turn_state 门面(unimplemented → RED)
-//    unknown/abnormal 且有 event_sink → 写 idle_takeover.classify。
-// =====================================================================
-
-// 门面经注入 classifier 分类;空文本 → Unknown(本 mock),验证返回 TurnClassification。
-#[test]
-fn classify_provider_turn_state_returns_classification_via_injected_classifier() {
-    let clf = CountingClassifier::new(TurnState::Idle);
-    let c =
-        classify_provider_turn_state(Provider::Codex, "{\"type\":\"turn_complete\"}", &clf, None)
-            .unwrap();
-    assert_eq!(c.state, TurnState::Idle);
-    assert_eq!(clf.calls.get(), 1);
-    // 空文本 → Unknown(unknown ≠ idle 命门下游)。
-    let clf2 = CountingClassifier::new(TurnState::Idle);
-    let c2 = classify_provider_turn_state(Provider::Codex, "", &clf2, None).unwrap();
-    assert_eq!(c2.state, TurnState::Unknown);
-    assert!(!c2.state.is_idle_for_takeover());
-}
-
-// event_sink + unknown/abnormal → 写 idle_takeover.classify(事件名字节锁)。
-#[test]
-fn classify_event_name_is_idle_takeover_classify() {
-    assert_eq!(
-        LeaderEvent::IdleTakeoverClassify.name(),
-        "idle_takeover.classify"
-    );
-}
-
-// =====================================================================
-// 10. push_idle_reminder(unimplemented → RED):!should_ping → no-op。
-// =====================================================================
-
-#[test]
-fn push_idle_reminder_noop_when_should_not_ping() {
-    let ws = std::env::temp_dir().join(format!("ta_rs_push_{}", std::process::id()));
-    std::fs::create_dir_all(&ws).unwrap();
-    let event_log = crate::event_log::EventLog::new(&ws);
-    let state = serde_json::json!({"leader": {"id": "leader"}});
-    let result = TakeoverReminderResult {
-        should_ping: false,
-        message: None,
-        interrupted_nodes: vec![],
-        reason: Some("not_armed_no_worker_turn".into()),
-    };
-    // should_ping=false → no-op,返回 Ok(())。现 unimplemented → RED。
-    push_idle_reminder(&ws, &state, &event_log, &result).unwrap();
-    // 强化:no-op 必须真的什么都不做 —— 不写 idle_takeover.reminder 事件(EventLog 无该事件)。
-    let events = event_log.tail(50).unwrap();
-    assert!(
-        !events
-            .iter()
-            .any(|e| e["event"] == serde_json::json!("idle_takeover.reminder")),
-        "should_ping=false 时绝不写 reminder 事件"
-    );
-}
-
-// #236 nag_removal (N35) — push_idle_reminder is now a no-op shim.
-// [OLD] assertion: should_ping=true → writes idle_takeover.reminder event (with
-// interrupted/reason byte-locked golden payload).
-// [NEW] assertion: even when should_ping=true, push_idle_reminder writes NO event
-// and emits NO leader-bound message; ownership/handover happens only via explicit
-// `claim-leader` / `takeover` commands. The function signature is preserved so
-// existing callers (coordinator/tick.rs, lifecycle wiring) still resolve.
-#[test]
-fn push_idle_reminder_is_silent_no_op_under_n35_even_when_should_ping_true() {
-    let ws = std::env::temp_dir().join(format!("ta_rs_push2_{}", std::process::id()));
-    std::fs::create_dir_all(&ws).unwrap();
-    let event_log = crate::event_log::EventLog::new(&ws);
-    let state = serde_json::json!({"leader": {"id": "leader"}});
-    let result = TakeoverReminderResult {
-        should_ping: true,
-        message: Some("neutral reminder body".into()),
-        interrupted_nodes: vec!["w1".into()],
-        reason: Some("armed_all_idle".into()),
-    };
-    push_idle_reminder(&ws, &state, &event_log, &result).unwrap();
-    let events = event_log.tail(50).unwrap();
-    assert!(
-        !events
-            .iter()
-            .any(|e| e["event"] == serde_json::json!("idle_takeover.reminder")),
-        "#236 N35: push_idle_reminder must no longer emit the reminder nag event; got {events:?}"
-    );
-}
-
 // idle_takeover.reminder / push_failed 事件名字节锁。
 #[test]
 fn idle_takeover_event_names_byte_locked() {

package/crates/team-agent/src/leader/tests/lease_api.rs

@@ -67,51 +67,6 @@ fn attach_leader_binds_pane_advances_epoch_and_persists() {
     assert_eq!(persisted["team_owner"]["owner_epoch"], serde_json::json!(1));
 }
 
-// autobind:$TMUX_PANE 缺 → Ok(None)(__init__.py:885-887,锁前直接返回,不开锁)。
-// 强化:断言这是 lock-not-acquired 早退 —— 不写 state.json(无 receiver/owner 落盘),
-// 不发任何 leader_receiver.* 事件(锁前 return,连 EventLog 都不构造)。
-#[test]
-fn autobind_returns_none_when_tmux_pane_missing() {
-    if std::env::var_os("TMUX_PANE").is_some() {
-        return; // 在 tmux 内:走绑定路径,本用例只验缺失分支。
-    }
-    let ws = std::env::temp_dir().join(format!("ta_rs_auto_{}", std::process::id()));
-    std::fs::create_dir_all(&ws).unwrap();
-    let r = autobind_leader_receiver_from_env(&ws, Provider::Codex, LeaseSource::Restart).unwrap();
-    assert!(r.is_none(), "$TMUX_PANE 缺 → autobind 返回 Ok(None)");
-    // lock-not-acquired 早退:state.json 未被写(load 兜底成空 state,无 team_owner/receiver)。
-    let st = crate::state::persist::load_runtime_state(&ws).unwrap();
-    assert!(
-        st.get("leader_receiver").is_none(),
-        "skip 路径不应落 receiver"
-    );
-    assert!(st.get("team_owner").is_none(), "skip 路径不应落 owner");
-    // 早退发生在 EventLog 构造前 → 无任何事件文件。
-    let events = crate::event_log::EventLog::new(&ws).tail(50).unwrap();
-    assert!(events.is_empty(), "skip 路径绝不写审计事件");
-}
-
-// autobind 成功支:$TMUX_PANE 命中 → 锁内 attach_leader_to_state → Ok(Some(receiver))。
-// receiver.pane_id == 注入 pane,discovery==EnvPane($TMUX_PANE 直接命中)。
-// env 变更进程全局且与并行 test race,且依赖跨 lane 的 live pane resolver,故 real-machine-gated。
-#[test]
-#[ignore = "needs live $TMUX_PANE + cross-lane _resolve_leader_pane; env mutation races parallel tests"]
-fn autobind_binds_env_pane_on_success() {
-    let ws = std::env::temp_dir().join(format!("ta_rs_auto_ok_{}", std::process::id()));
-    std::fs::create_dir_all(&ws).unwrap();
-    // SAFETY: #[ignore]d,单独 `--ignored --test-threads=1` 跑,不与并行 test race。
-    unsafe { std::env::set_var("TMUX_PANE", "%42") };
-    let r = autobind_leader_receiver_from_env(&ws, Provider::Codex, LeaseSource::Restart).unwrap();
-    unsafe { std::env::remove_var("TMUX_PANE") };
-    let receiver = r.expect("$TMUX_PANE 命中 → Ok(Some(receiver))");
-    assert_eq!(receiver.pane_id, PaneId::new("%42"));
-    assert_eq!(
-        receiver.discovery,
-        Some(Discovery::EnvPane),
-        "$TMUX_PANE 命中 → discovery=env_pane"
-    );
-}
-
 // claim_leader:无 ambiguous incident → 走 claim_lease_no_incident 直接 acquire/CAS。
 // 现 unimplemented → RED;锁住返回 LeaseResult。
 #[test]

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

@@ -1,6 +1,5 @@
 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 use super::*;
-use std::cell::Cell;
 
 // ── helpers ────────────────────────────────────────────────────────────
 /// derive 一个真 LeaderSessionUuid(骨架无公开裸构造器,仅 `derive`)。
@@ -8,46 +7,6 @@ fn uuid(fp: &str, ws: &str, user: &str, team: &str) -> LeaderSessionUuid {
     LeaderSessionUuid::derive(fp, ws, user, team).unwrap()
 }
 
-/// 注入式 turn-state 分类器:MUST-NOT-13 命门 —— 统计 classify 调用次数,
-/// 据此断言 idle 面经此 trait 分类、绝不直连任何 provider client。
-struct CountingClassifier {
-    calls: Cell<usize>,
-    result: TurnState,
-}
-impl CountingClassifier {
-    fn new(result: TurnState) -> Self {
-        Self {
-            calls: Cell::new(0),
-            result,
-        }
-    }
-}
-impl TurnStateClassifier for CountingClassifier {
-    fn classify(
-        &self,
-        _provider: Provider,
-        session_log_text: &str,
-    ) -> Result<TurnClassification, LeaderError> {
-        self.calls.set(self.calls.get() + 1);
-        // 空 session-log 文本 → unknown(bug-085:None rollout_path 漏穿后读到空串)。
-        let state = if session_log_text.is_empty() {
-            TurnState::Unknown
-        } else {
-            self.result
-        };
-        Ok(TurnClassification {
-            state,
-            turn_id: None,
-            annotations: vec![],
-            reason: if state == TurnState::Unknown {
-                Some("empty_session_log".into())
-            } else {
-                None
-            },
-        })
-    }
-}
-
 static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
 
 /// RAII env override: restores prior values on drop (incl. panic unwind), so a
@@ -133,9 +92,13 @@ fn event_names(ws: &std::path::Path) -> Vec<String> {
 
 mod basics;
 mod byte_findings;
+mod claim_leader_mailbox_flush_contract;
+mod historical_inventory_upgrade_gate_red;
 mod identity;
 mod idle;
 mod lease_api;
 mod lease_claim;
 mod rediscover;
+mod team_in_team_state_scope_red;
+mod terminal_and_replay_vs_rerender_invariants_red;
 mod wake_start_owner;

package/crates/team-agent/src/leader/tests/rehomed_env.rs

@@ -0,0 +1,83 @@
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+const CALLER_IDENTITY_ENVS: &[&str] = &[
+    "TMUX",
+    "TMUX_PANE",
+    "TEAM_AGENT_LEADER_PANE_ID",
+    "TEAM_AGENT_LEADER_SESSION_UUID",
+    "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+    "TEAM_AGENT_LEADER_SESSION_NAME",
+    "TEAM_AGENT_LEADER_PROVIDER",
+    "TEAM_AGENT_MACHINE_FINGERPRINT",
+    "TEAM_AGENT_WORKSPACE",
+    "TEAM_AGENT_TEAM_ID",
+    "TEAM_AGENT_OWNER_TEAM_ID",
+    "TEAM_AGENT_ACTIVE_TEAM",
+    "TEAM_AGENT_ID",
+    "TEAM_AGENT_AGENT_ID",
+    "TEAM_AGENT_AUTH_MODE",
+    "TEAM_AGENT_LEADER_BYPASS",
+    "TEAM_AGENT_LEADER_BYPASS_SOURCE",
+    "TEAM_AGENT_LEADER_BYPASS_PROVIDER",
+    "TEAM_AGENT_LEADER_BYPASS_FLAG",
+    "TEAM_AGENT_MCP_AUTO_APPROVE",
+    "TEAM_AGENT_MCP_AUTO_APPROVE_SOURCE",
+];
+
+static COUNTER: AtomicU64 = AtomicU64::new(0);
+
+pub(super) struct RehomedTestEnv {
+    root: PathBuf,
+    previous: Vec<(&'static str, Option<String>)>,
+}
+
+impl RehomedTestEnv {
+    pub(super) fn enter(tag: &str) -> Self {
+        let root = std::env::temp_dir().join(format!(
+            "ta-leader-rehomed-{tag}-{}-{}",
+            std::process::id(),
+            COUNTER.fetch_add(1, Ordering::Relaxed)
+        ));
+        let _ = std::fs::remove_dir_all(&root);
+        let home = root.join("home");
+        std::fs::create_dir_all(&home).expect("create rehomed test HOME");
+
+        let mut previous = Vec::new();
+        for key in std::iter::once("HOME").chain(CALLER_IDENTITY_ENVS.iter().copied()) {
+            previous.push((key, std::env::var(key).ok()));
+        }
+        unsafe {
+            std::env::set_var("HOME", &home);
+            for key in CALLER_IDENTITY_ENVS {
+                std::env::remove_var(key);
+            }
+        }
+
+        Self { root, previous }
+    }
+
+    pub(super) fn workspace(&self, tag: &str) -> PathBuf {
+        let path = self.root.join(format!(
+            "workspace-{tag}-{}",
+            COUNTER.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&path).expect("create rehomed test workspace");
+        path
+    }
+}
+
+impl Drop for RehomedTestEnv {
+    fn drop(&mut self) {
+        for (key, value) in self.previous.drain(..).rev() {
+            unsafe {
+                if let Some(value) = value {
+                    std::env::set_var(key, value);
+                } else {
+                    std::env::remove_var(key);
+                }
+            }
+        }
+        let _ = std::fs::remove_dir_all(&self.root);
+    }
+}