@team-agent/installer 0.5.61 → 0.5.62

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);
+    }
+}