@team-agent/installer 0.5.41 → 0.5.43

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

@@ -1,125 +1,141 @@
-    #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
-    use super::*;
-    use std::cell::Cell;
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+use super::*;
+use std::cell::Cell;
 
-    // ── helpers ────────────────────────────────────────────────────────────
-    /// derive 一个真 LeaderSessionUuid(骨架无公开裸构造器,仅 `derive`)。
-    fn uuid(fp: &str, ws: &str, user: &str, team: &str) -> LeaderSessionUuid {
-        LeaderSessionUuid::derive(fp, ws, user, team).unwrap()
-    }
+// ── helpers ────────────────────────────────────────────────────────────
+/// derive 一个真 LeaderSessionUuid(骨架无公开裸构造器,仅 `derive`)。
+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 }
+/// 注入式 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 },
-            })
-        }
+}
+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(());
+static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
 
-    /// RAII env override: restores prior values on drop (incl. panic unwind), so a
-    /// RED assertion-panic cannot leak a dirty env into other tests.
-    struct EnvGuard {
-        saved: Vec<(String, Option<String>)>,
-    }
-    impl EnvGuard {
-        fn apply(vars: &[(&str, Option<&str>)]) -> Self {
-            let saved = vars.iter().map(|(k, _)| ((*k).to_string(), std::env::var(k).ok())).collect();
-            for (k, v) in vars {
-                match v {
-                    Some(val) => std::env::set_var(k, val),
-                    None => std::env::remove_var(k),
-                }
+/// RAII env override: restores prior values on drop (incl. panic unwind), so a
+/// RED assertion-panic cannot leak a dirty env into other tests.
+struct EnvGuard {
+    saved: Vec<(String, Option<String>)>,
+}
+impl EnvGuard {
+    fn apply(vars: &[(&str, Option<&str>)]) -> Self {
+        let saved = vars
+            .iter()
+            .map(|(k, _)| ((*k).to_string(), std::env::var(k).ok()))
+            .collect();
+        for (k, v) in vars {
+            match v {
+                Some(val) => std::env::set_var(k, val),
+                None => std::env::remove_var(k),
             }
-            Self { saved }
         }
+        Self { saved }
     }
-    impl Drop for EnvGuard {
-        fn drop(&mut self) {
-            for (k, v) in &self.saved {
-                match v {
-                    Some(val) => std::env::set_var(k, val),
-                    None => std::env::remove_var(k),
-                }
+}
+impl Drop for EnvGuard {
+    fn drop(&mut self) {
+        for (k, v) in &self.saved {
+            match v {
+                Some(val) => std::env::set_var(k, val),
+                None => std::env::remove_var(k),
             }
         }
     }
+}
 
-    fn p2_temp_ws(tag: &str) -> PathBuf {
-        let ws = std::env::temp_dir().join(format!("ta_rs_p2leader_{}_{}", tag, std::process::id()));
-        std::fs::create_dir_all(&ws).unwrap();
-        ws
-    }
+fn p2_temp_ws(tag: &str) -> PathBuf {
+    let ws = std::env::temp_dir().join(format!("ta_rs_p2leader_{}_{}", tag, std::process::id()));
+    std::fs::create_dir_all(&ws).unwrap();
+    ws
+}
 
-    // P1 — state-supplied leader_session_uuid → source 'derived' (NOT 'env'); Python's
-    // source is binary override-vs-derived (leader/__init__.py:206).
-    struct SeededLiveness {
-        live_panes: std::collections::BTreeSet<String>,
-    }
-    impl crate::state::owner_gate::PaneLivenessProbe for SeededLiveness {
-        fn liveness(&self, pane_id: &str) -> crate::model::enums::PaneLiveness {
-            if self.live_panes.contains(pane_id) {
-                crate::model::enums::PaneLiveness::Live
-            } else {
-                crate::model::enums::PaneLiveness::Dead
-            }
+// P1 — state-supplied leader_session_uuid → source 'derived' (NOT 'env'); Python's
+// source is binary override-vs-derived (leader/__init__.py:206).
+struct SeededLiveness {
+    live_panes: std::collections::BTreeSet<String>,
+}
+impl crate::state::owner_gate::PaneLivenessProbe for SeededLiveness {
+    fn liveness(&self, pane_id: &str) -> crate::model::enums::PaneLiveness {
+        if self.live_panes.contains(pane_id) {
+            crate::model::enums::PaneLiveness::Live
+        } else {
+            crate::model::enums::PaneLiveness::Dead
         }
     }
+}
 
-    fn seeded_liveness(panes: &[&str]) -> SeededLiveness {
-        SeededLiveness { live_panes: panes.iter().map(|p| (*p).to_string()).collect() }
+fn seeded_liveness(panes: &[&str]) -> SeededLiveness {
+    SeededLiveness {
+        live_panes: panes.iter().map(|p| (*p).to_string()).collect(),
     }
+}
 
-    // RED — VACANT ACQUIRE: empty state + eligible caller → status=Claimed,
-    // reason=vacant_acquired, owner_epoch 0→1, owner+receiver bound to caller,
-    // claimed_via=claim-leader, BOTH state files written (dual-state).
-    // golden /tmp/probe_claimed.py: epoch 1, claimed_via "claim-leader",
-    // discovery "claim_leader", reason "vacant_acquired".
-    /// Event names from the workspace event log (events.jsonl), in write order.
-    fn event_names(ws: &std::path::Path) -> Vec<String> {
-        let path = crate::model::paths::logs_dir(ws).join("events.jsonl");
-        std::fs::read_to_string(&path)
-            .map(|t| {
-                t.lines()
-                    .filter_map(|l| serde_json::from_str::<serde_json::Value>(l).ok())
-                    .filter_map(|e| e.get("event").and_then(|v| v.as_str()).map(String::from))
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
+// RED — VACANT ACQUIRE: empty state + eligible caller → status=Claimed,
+// reason=vacant_acquired, owner_epoch 0→1, owner+receiver bound to caller,
+// claimed_via=claim-leader, BOTH state files written (dual-state).
+// golden /tmp/probe_claimed.py: epoch 1, claimed_via "claim-leader",
+// discovery "claim_leader", reason "vacant_acquired".
+/// Event names from the workspace event log (events.jsonl), in write order.
+fn event_names(ws: &std::path::Path) -> Vec<String> {
+    let path = crate::model::paths::logs_dir(ws).join("events.jsonl");
+    std::fs::read_to_string(&path)
+        .map(|t| {
+            t.lines()
+                .filter_map(|l| serde_json::from_str::<serde_json::Value>(l).ok())
+                .filter_map(|e| e.get("event").and_then(|v| v.as_str()).map(String::from))
+                .collect()
+        })
+        .unwrap_or_default()
+}
 
-    // D1 [BLOCK] — claim-path team_owner is EXACTLY golden's 7 keys (NO os_user). Golden new_owner
-    // (__init__.py:686-694) = pane_id,provider,machine_fingerprint,leader_session_uuid,owner_epoch,
-    // claimed_at,claimed_via; only Family-A leader_binding writes os_user, NEVER the claim path. Rust
-    // make_owner sets os_user:Some(..) + TeamOwner has no skip_serializing_if -> 8 keys. RED.
+// D1 [BLOCK] — claim-path team_owner is EXACTLY golden's 7 keys (NO os_user). Golden new_owner
+// (__init__.py:686-694) = pane_id,provider,machine_fingerprint,leader_session_uuid,owner_epoch,
+// claimed_at,claimed_via; only Family-A leader_binding writes os_user, NEVER the claim path. Rust
+// make_owner sets os_user:Some(..) + TeamOwner has no skip_serializing_if -> 8 keys. RED.
 
 mod basics;
-mod wake_start_owner;
-mod lease_api;
-mod idle;
+mod byte_findings;
 mod identity;
+mod idle;
+mod lease_api;
 mod lease_claim;
-mod byte_findings;
 mod rediscover;
+mod wake_start_owner;

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

@@ -8,7 +8,10 @@ fn r12_ws(tag: &str) -> std::path::PathBuf {
         "ta-r12-{}-{}-{}",
         tag,
         std::process::id(),
-        std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
     ));
     std::fs::create_dir_all(&ws).unwrap();
     ws
@@ -31,14 +34,23 @@ fn usable_target(pane: &str, cmd: &str) -> crate::transport::PaneInfo {
 }
 
 fn r12_events(ws: &std::path::Path) -> Vec<serde_json::Value> {
-    crate::event_log::EventLog::new(ws).tail(0).unwrap_or_default()
+    crate::event_log::EventLog::new(ws)
+        .tail(0)
+        .unwrap_or_default()
 }
 fn find_ev<'a>(evs: &'a [serde_json::Value], name: &str) -> Option<&'a serde_json::Value> {
-    evs.iter().rev().find(|e| e.get("event").and_then(|v| v.as_str()) == Some(name))
+    evs.iter()
+        .rev()
+        .find(|e| e.get("event").and_then(|v| v.as_str()) == Some(name))
 }
 fn r12_keys(e: &serde_json::Value) -> std::collections::BTreeSet<String> {
     e.as_object()
-        .map(|o| o.keys().filter(|k| *k != "ts" && *k != "event").cloned().collect())
+        .map(|o| {
+            o.keys()
+                .filter(|k| *k != "ts" && *k != "event")
+                .cloned()
+                .collect()
+        })
         .unwrap_or_default()
 }
 
@@ -46,12 +58,16 @@ fn r12_keys(e: &serde_json::Value) -> std::collections::BTreeSet<String> {
 // path D3: golden _rediscover_leader_receiver:133-145, owner present + >1 owner_candidates → broadcast).
 fn owner_matching_target(pane: &str, cmd: &str, uuid: &str) -> crate::transport::PaneInfo {
     let mut t = usable_target(pane, cmd);
-    t.leader_env
-        .insert("TEAM_AGENT_LEADER_SESSION_UUID".to_string(), uuid.to_string());
+    t.leader_env.insert(
+        "TEAM_AGENT_LEADER_SESSION_UUID".to_string(),
+        uuid.to_string(),
+    );
     t
 }
 fn count_ev(evs: &[serde_json::Value], name: &str) -> usize {
-    evs.iter().filter(|e| e.get("event").and_then(|v| v.as_str()) == Some(name)).count()
+    evs.iter()
+        .filter(|e| e.get("event").and_then(|v| v.as_str()) == Some(name))
+        .count()
 }
 
 // R12-0 + R12-3: NO owner_identity + 2 command-usable targets -> golden two-tier AMBIGUOUS (command-usable
@@ -61,10 +77,16 @@ fn count_ev(evs: &[serde_json::Value], name: &str) -> usize {
 fn r12_no_owner_two_usable_targets_is_ambiguous_not_missing() {
     let ws = r12_ws("noownerambig");
     let log = crate::event_log::EventLog::new(&ws);
-    let mut state = serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
+    let mut state =
+        serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
     let targets = vec![usable_target("%a", "codex"), usable_target("%b", "codex")];
     let out = crate::leader::rediscover_leader_receiver_from_targets_with_owner_identity(
-        &ws, &mut state, &targets, &log, &serde_json::json!({}), None,
+        &ws,
+        &mut state,
+        &targets,
+        &log,
+        &serde_json::json!({}),
+        None,
     )
     .unwrap();
     assert_eq!(
@@ -86,10 +108,16 @@ fn r12_no_owner_two_usable_targets_is_ambiguous_not_missing() {
 fn r12_no_owner_zero_usable_missing_is_lean_payload() {
     let ws = r12_ws("noownermiss");
     let log = crate::event_log::EventLog::new(&ws);
-    let mut state = serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
+    let mut state =
+        serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
     let targets: Vec<crate::transport::PaneInfo> = vec![];
     let out = crate::leader::rediscover_leader_receiver_from_targets_with_owner_identity(
-        &ws, &mut state, &targets, &log, &serde_json::json!({}), None,
+        &ws,
+        &mut state,
+        &targets,
+        &log,
+        &serde_json::json!({}),
+        None,
     )
     .unwrap();
     assert_eq!(out.get("status").and_then(|v| v.as_str()), Some("missing"));
@@ -108,7 +136,10 @@ fn r12_no_owner_zero_usable_missing_is_lean_payload() {
         "R12-1: no-owner D7 rebind_required (golden leader_panes.py:186) has rediscovery_status only, NO \
          recovery_action/owner_identity; got {rk:?}"
     );
-    assert_eq!(rebind.get("rediscovery_status").and_then(|v| v.as_str()), Some("missing"));
+    assert_eq!(
+        rebind.get("rediscovery_status").and_then(|v| v.as_str()),
+        Some("missing")
+    );
 }
 
 // R12-1/R12-2: owner_identity PRESENT + non-matching + 2 command-usable -> golden owner-MISSING (D4):
@@ -119,7 +150,8 @@ fn r12_no_owner_zero_usable_missing_is_lean_payload() {
 fn r12_owner_missing_candidate_count_is_command_usable_len_and_rebind_shape() {
     let ws = r12_ws("ownermiss");
     let log = crate::event_log::EventLog::new(&ws);
-    let mut state = serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
+    let mut state =
+        serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
     let owner = serde_json::json!({
         "pane_id": "%owner", "leader_session_uuid": "U-abcdef01",
         "machine_fingerprint": "F", "provider": "codex", "team_id": "team-a"
@@ -161,7 +193,8 @@ fn r12_owner_missing_candidate_count_is_command_usable_len_and_rebind_shape() {
 fn r12_5_ambiguous_candidates_event_is_full_golden_candidates_key() {
     let ws = r12_ws("ambigbroadcast");
     let log = crate::event_log::EventLog::new(&ws);
-    let mut state = serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
+    let mut state =
+        serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
     let owner = serde_json::json!({
         "pane_id": "%owner", "leader_session_uuid": "U-abcdef01",
         "machine_fingerprint": "F", "provider": "codex", "team_id": "team-a"
@@ -174,7 +207,10 @@ fn r12_5_ambiguous_candidates_event_is_full_golden_candidates_key() {
         &ws, &mut state, &targets, &log, &owner, None,
     )
     .unwrap();
-    assert_eq!(out.get("status").and_then(|v| v.as_str()), Some("ambiguous"));
+    assert_eq!(
+        out.get("status").and_then(|v| v.as_str()),
+        Some("ambiguous")
+    );
     let evs = r12_events(&ws);
     let bc = find_ev(&evs, "leader_receiver.ambiguous_candidates")
         .expect("OWNER-ambiguous must broadcast leader_receiver.ambiguous_candidates");
@@ -193,7 +229,10 @@ fn r12_5_ambiguous_candidates_event_is_full_golden_candidates_key() {
         Some(serde_json::json!(["%a", "%b"])),
         "R12-5: candidates == sorted pane_ids (golden candidate_ids = sorted); bc={bc:?}"
     );
-    assert_eq!(bc.get("reason").and_then(|v| v.as_str()), Some("force_confirm_required"));
+    assert_eq!(
+        bc.get("reason").and_then(|v| v.as_str()),
+        Some("force_confirm_required")
+    );
 }
 
 // R12-5 dedup: golden _broadcast_ambiguous_candidates:263 skips re-broadcast when a prior
@@ -204,7 +243,8 @@ fn r12_5_ambiguous_candidates_event_is_full_golden_candidates_key() {
 fn r12_5_ambiguous_candidates_dedups_on_repeat_incident() {
     let ws = r12_ws("ambigdedup");
     let log = crate::event_log::EventLog::new(&ws);
-    let mut state = serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
+    let mut state =
+        serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
     let owner = serde_json::json!({
         "pane_id": "%owner", "leader_session_uuid": "U-abcdef01",
         "machine_fingerprint": "F", "provider": "codex", "team_id": "team-a"
@@ -240,7 +280,8 @@ fn r12_5_ambiguous_candidates_dedups_on_repeat_incident() {
 fn r12_6_per_candidate_emits_separate_ambiguous_candidate_queued_events() {
     let ws = r12_ws("percand");
     let log = crate::event_log::EventLog::new(&ws);
-    let mut state = serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
+    let mut state =
+        serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
     let owner = serde_json::json!({
         "pane_id": "%owner", "leader_session_uuid": "U-abcdef01",
         "machine_fingerprint": "F", "provider": "codex", "team_id": "team-a"
@@ -263,8 +304,15 @@ fn r12_6_per_candidate_emits_separate_ambiguous_candidate_queued_events() {
     );
     let qpanes: std::collections::BTreeSet<String> = evs
         .iter()
-        .filter(|e| e.get("event").and_then(|v| v.as_str()) == Some("leader_receiver.ambiguous_candidate_queued"))
-        .filter_map(|e| e.get("pane_id").and_then(|v| v.as_str()).map(str::to_string))
+        .filter(|e| {
+            e.get("event").and_then(|v| v.as_str())
+                == Some("leader_receiver.ambiguous_candidate_queued")
+        })
+        .filter_map(|e| {
+            e.get("pane_id")
+                .and_then(|v| v.as_str())
+                .map(str::to_string)
+        })
         .collect();
     assert_eq!(
         qpanes,
@@ -296,7 +344,8 @@ fn r12_return_candidates(out: &serde_json::Value) -> &Vec<serde_json::Value> {
 fn r12_7_candidate_raw_uses_golden_pane_current_spelling() {
     let ws = r12_ws("rawkeys");
     let log = crate::event_log::EventLog::new(&ws);
-    let mut state = serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
+    let mut state =
+        serde_json::json!({"leader_receiver": {"pane_id": "%old", "provider": "codex"}});
     let owner = serde_json::json!({
         "pane_id": "%owner", "leader_session_uuid": "U-abcdef01",
         "machine_fingerprint": "F", "provider": "codex", "team_id": "team-a"
@@ -339,7 +388,10 @@ fn r12_7_event_provider_defaults_to_codex_when_absent() {
         &ws, &mut state, &targets, &log, &owner, None,
     )
     .unwrap();
-    assert_eq!(out.get("status").and_then(|v| v.as_str()), Some("ambiguous"));
+    assert_eq!(
+        out.get("status").and_then(|v| v.as_str()),
+        Some("ambiguous")
+    );
     let evs = r12_events(&ws);
     let amb = find_ev(&evs, "leader_receiver.rediscover_ambiguous").expect("rediscover_ambiguous");
     assert_eq!(