@team-agent/installer 0.2.11 → 0.3.0

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

@@ -0,0 +1,183 @@
+use super::*;
+
+    // =====================================================================
+    // 1. 锁名 / 闭枚举 / serde 字节对齐(纯数据,不依赖 unimplemented body)
+    // =====================================================================
+
+    // LEADER_OWNERSHIP_LOCK = "send"(__init__.py:393):attach/claim/takeover/autobind 共享同一临界区。
+    #[test]
+    fn ownership_lock_is_send() {
+        assert_eq!(LEADER_OWNERSHIP_LOCK, "send");
+    }
+
+    // LeaseReason 闭枚举的 serde 字节必须与 _LEASE_REASON_ENUM ∪ {caller_pane_missing} 一致。
+    // golden(probe_leader.py):enum 8 值(snake)+ binding 的 caller_pane_missing。
+    #[test]
+    fn lease_reason_serializes_to_exact_python_strings() {
+        let cases = [
+            (LeaseReason::VacantAcquired, "\"vacant_acquired\""),
+            (LeaseReason::PreviousOwnerPaneDead, "\"previous_owner_pane_dead\""),
+            (LeaseReason::PreviousOwnerAliveRefused, "\"previous_owner_alive_refused\""),
+            (LeaseReason::OwnerEpochAdvanced, "\"owner_epoch_advanced\""),
+            (LeaseReason::ForceConfirmRequired, "\"force_confirm_required\""),
+            (LeaseReason::CallerNotLeaderShaped, "\"caller_not_leader_shaped\""),
+            (LeaseReason::CallerCwdMismatch, "\"caller_cwd_mismatch\""),
+            (LeaseReason::NotInTmuxPane, "\"not_in_tmux_pane\""),
+            (LeaseReason::CallerPaneMissing, "\"caller_pane_missing\""),
+        ];
+        for (r, want) in cases {
+            assert_eq!(serde_json::to_string(&r).unwrap(), want, "{r:?}");
+        }
+    }
+
+    // _LEASE_REBIND_REQUIRED_REASONS = {not_in_tmux_pane, caller_not_leader_shaped, caller_cwd_mismatch}
+    // (__init__.py:384-386)→ 决定 refusal 事件名 rebind_required vs claim_refused。
+    // is_rebind_required 是 unimplemented!() → 调用即 panic = RED。
+    #[test]
+    fn lease_reason_rebind_required_membership_matches_python() {
+        // 三个 rebind-required(golden probe_leader.py rebind_required 集)。
+        assert!(LeaseReason::NotInTmuxPane.is_rebind_required());
+        assert!(LeaseReason::CallerNotLeaderShaped.is_rebind_required());
+        assert!(LeaseReason::CallerCwdMismatch.is_rebind_required());
+        // 其余一律 claim_refused(非 rebind-required)。
+        assert!(!LeaseReason::VacantAcquired.is_rebind_required());
+        assert!(!LeaseReason::PreviousOwnerPaneDead.is_rebind_required());
+        assert!(!LeaseReason::PreviousOwnerAliveRefused.is_rebind_required());
+        assert!(!LeaseReason::OwnerEpochAdvanced.is_rebind_required());
+        assert!(!LeaseReason::ForceConfirmRequired.is_rebind_required());
+        assert!(!LeaseReason::CallerPaneMissing.is_rebind_required());
+    }
+
+    // LeaseStatus serde(probe_leader3.py):already_bound / claimed / refused / dry_run。
+    #[test]
+    fn lease_status_serializes_to_exact_python_strings() {
+        assert_eq!(serde_json::to_string(&LeaseStatus::AlreadyBound).unwrap(), "\"already_bound\"");
+        assert_eq!(serde_json::to_string(&LeaseStatus::Claimed).unwrap(), "\"claimed\"");
+        assert_eq!(serde_json::to_string(&LeaseStatus::Refused).unwrap(), "\"refused\"");
+        assert_eq!(serde_json::to_string(&LeaseStatus::DryRun).unwrap(), "\"dry_run\"");
+    }
+
+    // Discovery serde(probe_leader3.py):attach_readopt/claim_leader/env_pane/explicit_pane/current_pane。
+    #[test]
+    fn discovery_serializes_to_exact_python_strings() {
+        assert_eq!(serde_json::to_string(&Discovery::AttachReadopt).unwrap(), "\"attach_readopt\"");
+        assert_eq!(serde_json::to_string(&Discovery::ClaimLeader).unwrap(), "\"claim_leader\"");
+        assert_eq!(serde_json::to_string(&Discovery::EnvPane).unwrap(), "\"env_pane\"");
+        assert_eq!(serde_json::to_string(&Discovery::ExplicitPane).unwrap(), "\"explicit_pane\"");
+        assert_eq!(serde_json::to_string(&Discovery::CurrentPane).unwrap(), "\"current_pane\"");
+    }
+
+    // ClaimedVia 是 kebab-case(__init__.py:545/693/876 等写 "attach-leader"/"claim-leader")。
+    #[test]
+    fn claimed_via_serializes_kebab_case() {
+        assert_eq!(serde_json::to_string(&ClaimedVia::ClaimLeader).unwrap(), "\"claim-leader\"");
+        assert_eq!(serde_json::to_string(&ClaimedVia::AttachLeader).unwrap(), "\"attach-leader\"");
+    }
+
+    // LeaseSource serde:launch/quick_start/restart/manual(__init__.py source 取值)。
+    #[test]
+    fn lease_source_serializes_snake_case() {
+        assert_eq!(serde_json::to_string(&LeaseSource::Launch).unwrap(), "\"launch\"");
+        assert_eq!(serde_json::to_string(&LeaseSource::QuickStart).unwrap(), "\"quick_start\"");
+        assert_eq!(serde_json::to_string(&LeaseSource::Restart).unwrap(), "\"restart\"");
+        assert_eq!(serde_json::to_string(&LeaseSource::Manual).unwrap(), "\"manual\"");
+    }
+
+    // ReceiverMode/Status:direct_tmux / attached(__init__.py:283-284)。
+    #[test]
+    fn receiver_mode_and_status_serialize_to_python_strings() {
+        assert_eq!(serde_json::to_string(&ReceiverMode::DirectTmux).unwrap(), "\"direct_tmux\"");
+        assert_eq!(serde_json::to_string(&ReceiverStatus::Attached).unwrap(), "\"attached\"");
+    }
+
+    // LeaderStartMode:exec_provider/new_tmux_session/attach_existing(leader_start_plan)。
+    #[test]
+    fn leader_start_mode_serializes_to_python_strings() {
+        assert_eq!(serde_json::to_string(&LeaderStartMode::ExecProvider).unwrap(), "\"exec_provider\"");
+        assert_eq!(serde_json::to_string(&LeaderStartMode::NewTmuxSession).unwrap(), "\"new_tmux_session\"");
+        assert_eq!(serde_json::to_string(&LeaderStartMode::AttachExisting).unwrap(), "\"attach_existing\"");
+    }
+
+    // NodeRole:worker/leader(build_idle_nodes role 字段)。
+    #[test]
+    fn node_role_serializes_to_python_strings() {
+        assert_eq!(serde_json::to_string(&NodeRole::Worker).unwrap(), "\"worker\"");
+        assert_eq!(serde_json::to_string(&NodeRole::Leader).unwrap(), "\"leader\"");
+    }
+
+    // RereadReason:wake.py 五值(probe_leader.py)。
+    #[test]
+    fn reread_reason_serializes_to_python_strings() {
+        assert_eq!(serde_json::to_string(&RereadReason::NoFile).unwrap(), "\"no_file\"");
+        assert_eq!(serde_json::to_string(&RereadReason::NeverClassified).unwrap(), "\"never_classified\"");
+        assert_eq!(serde_json::to_string(&RereadReason::FileChanged).unwrap(), "\"file_changed\"");
+        assert_eq!(
+            serde_json::to_string(&RereadReason::QuiescentAlreadyClassified).unwrap(),
+            "\"quiescent_already_classified\""
+        );
+        assert_eq!(serde_json::to_string(&RereadReason::Unchanged).unwrap(), "\"unchanged\"");
+    }
+
+    // =====================================================================
+    // 2. LeaderSessionUuidSource — 漂移 NOTE(card §168-179)
+    // =====================================================================
+
+    // leader plan 侧 _leader_identity_context(__init__.py:206)只产 "override"/"derived";
+    // identity lane(state.py:332)用 "explicit-override"/"env"/"derived"。
+    // 此 enum 的 serde 字节当对齐 LEADER 侧:Override→"override"。Env→"env" 也在闭集。
+    #[test]
+    fn leader_session_uuid_source_serializes_leader_plan_strings() {
+        assert_eq!(serde_json::to_string(&LeaderSessionUuidSource::Derived).unwrap(), "\"derived\"");
+        // NOTE(drift):leader plan 写裸 "override"(非 identity lane 的 "explicit-override")。
+        assert_eq!(serde_json::to_string(&LeaderSessionUuidSource::Override).unwrap(), "\"override\"");
+        assert_eq!(serde_json::to_string(&LeaderSessionUuidSource::Env).unwrap(), "\"env\"");
+    }
+
+    // 漂移可观测:identity lane 的 caller dict 用 "explicit-override",二者不可互换。
+    // 这是 leader 集成时必须 reconcile 的 NOTE —— 锁死 leader-plan 侧字节,防被误统一成
+    // identity 串。serde override≠"explicit-override"。
+    #[test]
+    fn leader_plan_override_is_not_identity_explicit_override_string() {
+        let leader_plan = serde_json::to_string(&LeaderSessionUuidSource::Override).unwrap();
+        assert_eq!(leader_plan, "\"override\"");
+        assert_ne!(leader_plan, "\"explicit-override\"", "drift NOTE: leader plan 用 'override',不可写成 identity 的 'explicit-override'");
+    }
+
+    // =====================================================================
+    // 3. LeaderEvent::name() — §40 字节级一致(unimplemented → RED)
+    // =====================================================================
+
+    // 全部 leader 审计事件名(probe_leader2.py FOUND 验证;ping 来自 idle_predicate 跨 lane,亦 golden)。
+    // 注:ReceiverClaimLeaderNotification 在 v0.2.11 任何 source 都查无 "leader_receiver.claim_leader_notification"
+    // 字面 → 见 deferred,此处不钉该串(只钉可验证的 23 个)。
+    #[test]
+    fn leader_event_names_match_python_byte_for_byte() {
+        let cases = [
+            (LeaderEvent::ReceiverAttached, "leader_receiver.attached"),
+            (LeaderEvent::ReceiverRebindApplied, "leader_receiver.rebind_applied"),
+            (LeaderEvent::ReceiverClaimApplied, "leader_receiver.claim_applied"),
+            (LeaderEvent::ReceiverClaimRefused, "leader_receiver.claim_refused"),
+            (LeaderEvent::ReceiverRebindRequired, "leader_receiver.rebind_required"),
+            (LeaderEvent::ReceiverAttachFailed, "leader_receiver.attach_failed"),
+            (LeaderEvent::ReceiverStateDivergenceRepaired, "leader_receiver.state_divergence_repaired"),
+            (LeaderEvent::ReceiverFirstTimeEnvSeeded, "leader_receiver.first_time_env_seeded"),
+            (LeaderEvent::ReceiverAutobindSkipped, "leader_receiver.autobind_skipped"),
+            (LeaderEvent::ReceiverRequeuedExhaustedWatchers, "leader_receiver.requeued_exhausted_watchers"),
+            (LeaderEvent::ReceiverAmbiguousCandidates, "leader_receiver.ambiguous_candidates"),
+            (LeaderEvent::ReceiverClaimRequeue, "leader_receiver.claim_requeue"),
+            (LeaderEvent::OwnerAdoptedOnRestart, "owner.adopted_on_restart"),
+            (LeaderEvent::OwnerBoundFromCallerPane, "owner.bound_from_caller_pane"),
+            (LeaderEvent::OwnerBindRefused, "owner.bind_refused"),
+            (LeaderEvent::OwnerEpochAdvanced, "owner_epoch_advanced"),
+            (LeaderEvent::LeaderSessionUuidOverride, "leader_session_uuid.override"),
+            (LeaderEvent::LeaderStart, "leader.start"),
+            (LeaderEvent::ResultWatcherRequeued, "result_watcher.requeued"),
+            (LeaderEvent::IdleTakeoverClassify, "idle_takeover.classify"),
+            (LeaderEvent::IdleTakeoverPing, "idle_takeover.ping"),
+            (LeaderEvent::IdleTakeoverReminder, "idle_takeover.reminder"),
+            (LeaderEvent::IdleTakeoverPushFailed, "idle_takeover.push_failed"),
+        ];
+        for (ev, want) in cases {
+            assert_eq!(ev.name(), want, "{ev:?}");
+        }
+    }

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

@@ -0,0 +1,234 @@
+use super::*;
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn d1_claim_team_owner_includes_os_user() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("d1_owner_keys");
+        let mut state = serde_json::json!({"session_name": "team-agent-x"});
+        let r = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
+            &PaneId::new("%5"), false, &crate::event_log::EventLog::new(&ws), &seeded_liveness(&["%5"])).unwrap();
+        assert!(r.ok && r.status == LeaseStatus::Claimed, "precondition: vacant acquire");
+        let owner = state["team_owner"].as_object().expect("team_owner object");
+        assert!(owner.contains_key("os_user"),
+            "golden claim-path team_owner carries os_user even when empty; keys={:?}", owner.keys().collect::<Vec<_>>());
+        let keys: Vec<&str> = owner.keys().map(String::as_str).collect();
+        assert_eq!(keys, vec!["pane_id","provider","machine_fingerprint","leader_session_uuid","owner_epoch","claimed_at","claimed_via","os_user"],
+            "golden new_owner includes os_user");
+    }
+
+    // D2 [BLOCK] — claim-path leader_receiver is golden's 14 keys in golden order; NO
+    // fingerprint/requested_provider/warning. Golden _receiver_from_claim_target (__init__.py:861-877).
+    // Rust LeaderReceiver serializes all 17 (no skip_serializing_if) -> 3 always-null extras leak. RED.
+    // (The POPULATED tmux values session_name/window_*/pane_* come from the caller-target scan — a
+    // deferred real-tmux seam, see d2_receiver_populated_from_caller_target_seam; the KEY-SET + ORDER
+    // locked here are unchanged by that scan.)
+    #[test]
+    #[serial_test::serial(env)]
+    fn d2_claim_leader_receiver_is_fourteen_golden_keys_in_order_no_extras() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("d2_recv_keys");
+        let mut state = serde_json::json!({"session_name": "team-agent-x"});
+        let r = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
+            &PaneId::new("%5"), false, &crate::event_log::EventLog::new(&ws), &seeded_liveness(&["%5"])).unwrap();
+        assert!(r.ok && r.status == LeaseStatus::Claimed, "precondition: vacant acquire");
+        let recv = state["leader_receiver"].as_object().expect("leader_receiver object");
+        for extra in ["fingerprint", "requested_provider", "warning"] {
+            assert!(!recv.contains_key(extra),
+                "golden leader_receiver has NO '{extra}' key (Rust must add skip_serializing_if); keys={:?}", recv.keys().collect::<Vec<_>>());
+        }
+        let keys: Vec<&str> = recv.keys().map(String::as_str).collect();
+        assert_eq!(keys, vec![
+            "mode","status","provider","pane_id","session_name","window_index","window_name",
+            "pane_index","pane_tty","pane_current_command","leader_session_uuid","owner_epoch",
+            "attached_at","discovery",
+        ], "golden _receiver_from_claim_target 14-key set + ORDER (__init__.py:861-877)");
+    }
+
+    // D2 seam — the caller-target SCAN that fills session_name/window_index/window_name/pane_index/
+    // pane_tty/pane_current_command from core_list_targets (golden _receiver_from_claim_target reads
+    // target[...]). Rust make_receiver leaves them None (no scan). Real-tmux: needs core_list_targets.
+    #[test]
+    #[ignore = "real-tmux seam: leader_receiver session_name/window_*/pane_* are populated from the \
+                caller target via core_list_targets (golden _receiver_from_claim_target); Rust has no \
+                scan (values null). Porter wires the target scan; this asserts the populated values."]
+    fn d2_receiver_populated_from_caller_target_seam() {
+        // Golden contract: new_receiver.session_name == caller_target.session_name, etc. Needs a live
+        // tmux target list (core_list_targets) — out of in-process scope.
+    }
+
+    // D3 [BLOCK] — bound_pane is RECEIVER-first (golden :624 receiver.pane_id OR owner.pane_id). PROBE-B
+    // (receiver=%9, owner=%1, caller=%9): golden ok=True already_bound. Rust derives OWNER-first
+    // (owner %1 != caller %9) -> owner live + !confirm -> refused force_confirm_required. RED.
+    #[test]
+    #[serial_test::serial(env)]
+    fn d3_bound_pane_receiver_first_reclaim_from_receiver_pane_is_already_bound() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("d3_receiver_first");
+        let mut state = serde_json::json!({
+            "session_name": "team-agent-x",
+            "team_owner": {"pane_id":"%1","provider":"codex","machine_fingerprint":"fp","leader_session_uuid":"U","owner_epoch":3,"claimed_at":"t","claimed_via":"claim-leader"},
+            "leader_receiver": {"pane_id":"%9","owner_epoch":3,"leader_session_uuid":"U"},
+        });
+        let r = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
+            &PaneId::new("%9"), false, &crate::event_log::EventLog::new(&ws), &seeded_liveness(&["%9","%1"])).unwrap();
+        assert!(r.ok, "a re-claim from the bound RECEIVER pane (%9) is idempotent ok=true; got {r:?}");
+        assert_eq!(r.status, LeaseStatus::AlreadyBound,
+            "golden :624 receiver-first: bound_pane=receiver(%9)==caller(%9) -> already_bound, NOT force_confirm");
+    }
+
+    // D4 [WARN] — precheck_epoch uses Python truthiness: owner_epoch=0 is FALSY -> falls through to
+    // receiver_epoch=5 (golden _lease_epoch :400 int(owner.epoch or recv.epoch or 0)). Rust
+    // current_owner_epoch Some(0) stops the chain -> 0. Surfaces in the force_confirm refusal. RED.
+    #[test]
+    #[serial_test::serial(env)]
+    fn d4_precheck_epoch_zero_is_falsy_falls_through_to_receiver() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("d4_epoch_falsy");
+        let mut state = serde_json::json!({
+            "session_name": "team-agent-x",
+            "team_owner": {"pane_id":"%1","provider":"codex","machine_fingerprint":"fp","leader_session_uuid":"U","owner_epoch":0,"claimed_at":"t","claimed_via":"claim-leader"},
+            "leader_receiver": {"pane_id":"%1","owner_epoch":5,"leader_session_uuid":"U"},
+        });
+        let r = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
+            &PaneId::new("%2"), false, &crate::event_log::EventLog::new(&ws), &seeded_liveness(&["%1","%2"])).unwrap();
+        assert_eq!(r.status, LeaseStatus::Refused, "precondition: live owner %1 + no confirm -> force_confirm");
+        assert_eq!(r.owner_epoch, Some(OwnerEpoch(5)),
+            "golden _lease_epoch: owner_epoch=0 is falsy -> receiver_epoch=5; Rust stops at Some(0)");
+    }
+
+    // D5 [BLOCK] — success path emits leader_receiver.rebind_applied + owner_epoch_advanced (golden
+    // :712-729), NOT the incident-arm leader_receiver.claim_applied (:791). RED.
+    #[test]
+    #[serial_test::serial(env)]
+    fn d5_success_emits_rebind_applied_and_owner_epoch_advanced_not_claim_applied() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("d5_events");
+        let mut state = serde_json::json!({"session_name": "team-agent-x"});
+        let _ = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
+            &PaneId::new("%5"), false, &crate::event_log::EventLog::new(&ws), &seeded_liveness(&["%5"])).unwrap();
+        let names = event_names(&ws);
+        assert!(names.iter().any(|n| n == "leader_receiver.rebind_applied"),
+            "golden success emits leader_receiver.rebind_applied (:712); got {names:?}");
+        assert!(names.iter().any(|n| n == "owner_epoch_advanced"),
+            "golden success emits owner_epoch_advanced (:721); got {names:?}");
+        assert!(!names.iter().any(|n| n == "leader_receiver.claim_applied"),
+            "claim_applied is the INCIDENT-arm event, NEVER on the no-incident path; got {names:?}");
+    }
+
+    // D6 [WARN] — EVERY lease refusal writes a leader_receiver audit event (golden _emit_lease_refusal).
+    // not_in_tmux_pane ∈ _LEASE_REBIND_REQUIRED_REASONS -> "leader_receiver.rebind_required" (:481).
+    // Rust refused() takes no event_log -> writes nothing. RED.
+    #[test]
+    #[serial_test::serial(env)]
+    fn d6_refusal_emits_leader_receiver_audit_event() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("d6_refusal_event");
+        let mut state = serde_json::json!({});
+        let r = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
+            &PaneId::new(""), false, &crate::event_log::EventLog::new(&ws), &seeded_liveness(&[])).unwrap();
+        assert_eq!(r.reason, Some(LeaseReason::NotInTmuxPane), "precondition: empty caller -> not_in_tmux_pane");
+        let names = event_names(&ws);
+        assert!(names.iter().any(|n| n == "leader_receiver.rebind_required"),
+            "golden writes a leader_receiver.rebind_required audit on the not_in_tmux_pane refusal; Rust writes none. got {names:?}");
+    }
+
+    // D8 [WARN] — provider PRESERVED from the prior receiver on re-claim (golden
+    // _receiver_from_claim_target provider=previous.provider or 'codex'; new_owner=new_recv.provider or
+    // owner.provider or 'codex'). A dead-owner recover of a CLAUDE leader keeps provider='claude'. Rust
+    // make_receiver/make_owner hardcode Provider::Codex. RED.
+    #[test]
+    #[serial_test::serial(env)]
+    fn d8_provider_preserved_from_prior_receiver_on_reclaim() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("d8_provider");
+        let mut state = serde_json::json!({
+            "session_name": "team-agent-x",
+            "team_owner": {"pane_id":"%1","provider":"claude","machine_fingerprint":"fp","leader_session_uuid":"U","owner_epoch":3,"claimed_at":"t","claimed_via":"claim-leader"},
+            "leader_receiver": {"pane_id":"%1","provider":"claude","owner_epoch":3,"leader_session_uuid":"U"},
+        });
+        let r = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
+            &PaneId::new("%5"), false, &crate::event_log::EventLog::new(&ws), &seeded_liveness(&["%5"])).unwrap();
+        assert!(r.ok && r.status == LeaseStatus::Claimed, "precondition: dead-owner %1 recover");
+        assert_eq!(state.pointer("/team_owner/provider").and_then(|v| v.as_str()), Some("claude"),
+            "golden preserves the prior provider (claude) on re-claim; Rust hardcodes codex");
+        assert_eq!(state.pointer("/leader_receiver/provider").and_then(|v| v.as_str()), Some("claude"),
+            "the new receiver also preserves the prior provider (golden previous.provider)");
+    }
+
+    // TOCTOU CAS [BLOCK, flagged] — golden :654-671 re-reads owner_epoch INSIDE the lock and refuses
+    // owner_epoch_advanced on a concurrent bump (no double-bind). Rust has NO locked re-read; the race
+    // silently double-binds (LeaseReason::OwnerEpochAdvanced is unreachable). Simulated: on-disk
+    // state.json (the locked-re-read source) carries epoch 5 while the passed precheck state is epoch 3.
+    // RED: today Rust ignores disk and claims. Porter: re-read select_runtime_state under the lock and
+    // refuse owner_epoch_advanced when locked_epoch != precheck_epoch.
+    #[test]
+    #[serial_test::serial(env)]
+    fn toctou_locked_reread_refuses_owner_epoch_advanced_on_concurrent_bump() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("toctou_cas");
+        // disk (the locked-re-read source): a concurrent claimer bumped owner_epoch to 5.
+        crate::state::persist::save_runtime_state(&ws, &serde_json::json!({
+            "session_name": "team-agent-x",
+            "team_owner": {"pane_id":"%1","provider":"codex","machine_fingerprint":"fp","leader_session_uuid":"U","owner_epoch":5,"claimed_at":"t","claimed_via":"claim-leader"},
+        })).unwrap();
+        // precheck state passed to the claim: epoch 3, vacant (no owner pane) -> no force_confirm gate.
+        let mut state = serde_json::json!({"session_name":"team-agent-x","leader_receiver":{"owner_epoch":3}});
+        let r = claim_lease_no_incident(&ws, &mut state, None, &TeamKey::new("current"),
+            &PaneId::new("%5"), false, &crate::event_log::EventLog::new(&ws), &seeded_liveness(&["%5"])).unwrap();
+        assert_eq!(r.status, LeaseStatus::Refused,
+            "golden TOCTOU CAS: locked epoch 5 != precheck 3 -> refused; Rust skips the re-read and claims. got {r:?}");
+        assert_eq!(r.reason, Some(LeaseReason::OwnerEpochAdvanced),
+            "the refusal reason is owner_epoch_advanced (:666)");
+    }
+
+    // attach_leader_to_state [BLOCK, flagged] — golden non-first-time path writes leader_receiver ONLY:
+    // NO team_owner write, NO epoch advance (after the strict-uuid gate). Rust stub writes BOTH and
+    // advances epoch (precheck+1), ignoring source/require_current. RED (locked before the autobind/launch
+    // wiring lands, so it does not silently overwrite the owner + bump epoch on every attach).
+    #[test]
+    #[serial_test::serial(env)]
+    fn attach_leader_to_state_nonfirst_does_not_overwrite_owner_or_advance_epoch() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
+        let ws = p2_temp_ws("attach_nonfirst");
+        let mut state = serde_json::json!({
+            "session_name": "team-agent-x",
+            "team_owner": {"pane_id":"%1","provider":"codex","machine_fingerprint":"fp","leader_session_uuid":"U","owner_epoch":3,"claimed_at":"t","claimed_via":"claim-leader"},
+        });
+        let event_log = crate::event_log::EventLog::new(&ws);
+        let _ = attach_leader_to_state(&ws, &mut state, Some(&PaneId::new("%2")),
+            crate::provider::Provider::Codex, &event_log, LeaseSource::Manual, false);
+        assert_eq!(state.pointer("/team_owner/pane_id").and_then(|v| v.as_str()), Some("%1"),
+            "non-first-time attach must NOT overwrite team_owner.pane_id (golden writes leader_receiver only); Rust rebinds it to %2");
+        assert_eq!(state.pointer("/team_owner/owner_epoch").and_then(|v| v.as_u64()), Some(3),
+            "non-first-time attach must NOT advance owner_epoch (golden keeps 3); Rust bumps to 4");
+    }
+
+    // C3 [WARN] — leader_identity.current_pane_id honors TEAM_AGENT_LEADER_PANE_ID priority (golden
+    // :366 = env(TEAM_AGENT_LEADER_PANE_ID) or env(TMUX_PANE) or None). Rust owner_bind.rs:32 reads
+    // TMUX_PANE only. RED: with TEAM_AGENT_LEADER_PANE_ID set + TMUX_PANE unset, current_pane_id must be
+    // the LEADER_PANE_ID. (Sibling gap, noted: last_seen_at = receiver.attached_at OR receiver.last_seen_at;
+    // Rust reads attached_at only.)
+    #[test]
+    #[serial_test::serial(env)]
+    fn c3_leader_identity_current_pane_honors_leader_pane_id_env() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[
+            ("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None),
+            ("TEAM_AGENT_LEADER_PANE_ID", Some("%foo")),
+            ("TMUX_PANE", None),
+        ]);
+        let ws = p2_temp_ws("c3_pane_env");
+        let v = leader_identity(&ws, None).unwrap();
+        assert_eq!(v["current_pane_id"], serde_json::json!("%foo"),
+            "golden :366 current_pane_id = TEAM_AGENT_LEADER_PANE_ID or TMUX_PANE or None; Rust reads TMUX_PANE only");
+    }

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

@@ -0,0 +1,206 @@
+use super::*;
+
+    // =====================================================================
+    // 12. leader_identity_context — override / state uuid / derive 三源(unimplemented → RED)
+    // =====================================================================
+
+    // 无 override env、无 state record → derive(machine, ws_abspath, user, team)。
+    // 现 unimplemented → 调用即 RED;锁住返回 LeaderIdentity 且 source==Derived。
+    #[test]
+    #[serial_test::serial(env)]
+    fn leader_identity_context_derives_when_no_override_no_state() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_lic_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        // 空 state(无 team_owner/leader_receiver uuid)。
+        let state = serde_json::json!({});
+        let id = leader_identity_context(&ws, None, Some(&state)).unwrap();
+        // 无 override → source 为 Derived(leader plan 侧;__init__.py:206)。
+        assert_eq!(id.leader_session_uuid_source, LeaderSessionUuidSource::Derived);
+        // uuid 是 32 hex(derive 形)。
+        assert_eq!(id.leader_session_uuid.as_str().len(), 32);
+    }
+
+    // leader_identity:CLI 直出 dict(__init__.py:355-369)。unimplemented → RED。
+    // 强化:uuid_prefix 必须 == leader_identity_context 派生 uuid 的前 12 hex(绑到真值,
+    // 而非任意 12 字符);整个 dict 的 machine_fingerprint/os_user/team_id/source 必须与 context 一致。
+    #[test]
+    #[serial_test::serial(env)]
+    fn leader_identity_dict_ties_prefix_and_fields_to_derived_context() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_lid_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        // 空 state → context 走 derive(无 override/无 state uuid)。
+        let ctx = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
+        let expected_prefix = &ctx.leader_session_uuid.as_str()[..12];
+        let v = leader_identity(&ws, None).unwrap();
+        assert_eq!(v["ok"], serde_json::json!(true));
+        // uuid_prefix 绑到派生真值的前 12 hex(错的 12 字符串会被抓)。
+        assert_eq!(v["uuid_prefix"].as_str().unwrap(), expected_prefix);
+        // 其余身份字段与 context 字节一致。
+        assert_eq!(v["machine_fingerprint"].as_str().unwrap(), ctx.machine_fingerprint);
+        assert_eq!(v["os_user"].as_str().unwrap(), ctx.os_user);
+        assert_eq!(v["team_id"].as_str().unwrap(), ctx.team_id.as_str());
+        // source == 派生侧 "derived"(无 override → 不是 "override"/"env")。
+        assert_eq!(v["source"], serde_json::json!("derived"));
+        assert_eq!(ctx.leader_session_uuid_source, LeaderSessionUuidSource::Derived);
+        // CLI 直出形态:current_pane_id / last_seen_at 在无 env/无 receiver 时为 null。
+        assert_eq!(v["last_seen_at"], serde_json::Value::Null);
+    }
+
+    // =====================================================================
+    // 13. leader_start_plan(unimplemented → RED):钉 mode 选择 + leader_env 导出键。
+    // =====================================================================
+
+    // leader_start_plan(__init__.py:82-145)。强化:钉具体 mode + plan 内容,而非 provider 回声。
+    // 确定性环境:在 TMUX 内 → exec_provider;不在 TMUX(且 tmux 可用)→ new_tmux_session,
+    // session_name==leader_session_name(Fake,ws),leader_env 携带 5 个 TEAM_AGENT_* 导出键。
+    // 注:`detached` 在 leader_start_plan 返回值里恒为 false(__init__.py:174 "detached": False);
+    //     非 tty 的 `-d` 插入发生在 start_leader 调用者层(:74-78),不在本 plan 边界 → 不在此断言 detached。
+    // unimplemented → RED。
+    #[test]
+    #[serial_test::serial(env)]
+    fn leader_start_plan_pins_mode_and_leader_env() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_lsp_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let plan = leader_start_plan(Provider::Fake, &[], &ws, false, false, None).unwrap();
+        assert_eq!(plan.provider, Provider::Fake);
+        if std::env::var_os("TMUX").is_some() {
+            // 已在 tmux 内 → exec in-place。
+            assert_eq!(plan.mode, LeaderStartMode::ExecProvider);
+        } else {
+            // 不在 tmux → 新建 tmux session(测试环境假定 tmux 可用;否则 Err(Start))。
+            assert_eq!(plan.mode, LeaderStartMode::NewTmuxSession);
+            // session_name 由派生公式确定。
+            assert_eq!(plan.session_name.as_ref(), Some(&leader_session_name(Provider::Fake, &ws)));
+            // plan 边界 detached 恒 false(`-d` 插入在 start_leader 层,非此处)。
+            assert!(!plan.detached, "leader_start_plan 返回值 detached 恒 false");
+            // leader_env 携带 5 个 TEAM_AGENT_* 导出键(_leader_provider_env)。
+            for key in [
+                "TEAM_AGENT_LEADER_PROVIDER",
+                "TEAM_AGENT_LEADER_SESSION_UUID",
+                "TEAM_AGENT_MACHINE_FINGERPRINT",
+                "TEAM_AGENT_WORKSPACE",
+                "TEAM_AGENT_TEAM_ID",
+            ] {
+                assert!(plan.leader_env.contains_key(key), "leader_env 缺导出键 {key}");
+            }
+            assert_eq!(
+                plan.leader_env.get("TEAM_AGENT_LEADER_PROVIDER").map(String::as_str),
+                Some("fake")
+            );
+        }
+    }
+
+    // ═══════════════ P2 FIX-LOOP RED (复绿即对抗 cross-model findings) ═══════════════
+    // Lock CORRECT Python v0.2.11 leader-identity behavior the contracts missed.
+    // Golden re-probed via /tmp/probe_p2_leader.py vs team-agent-public @ 439bef8
+    // (leader/__init__.py:_leader_identity_context / _identity_* / _detect_dual_state_divergence).
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn p2_leader_state_uuid_source_is_derived_not_env() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[
+            ("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None),
+            ("TEAM_AGENT_LEADER_SESSION_UUID", None),
+        ]);
+        let ws = p2_temp_ws("src");
+        let state = serde_json::json!({"team_owner": {"leader_session_uuid": "STATEUUID123"}});
+        let id = leader_identity_context(&ws, None, Some(&state)).unwrap();
+        assert_eq!(id.leader_session_uuid_source, LeaderSessionUuidSource::Derived);
+        assert_eq!(id.leader_session_uuid.as_str(), "STATEUUID123");
+    }
+
+    // P1 — operator override env var is TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE (the
+    // _OVERRIDE suffix), per leader/__init__.py:197 — NOT the injected child-env var.
+    #[test]
+    #[serial_test::serial(env)]
+    fn p2_leader_override_reads_override_suffixed_env_var() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[
+            ("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", Some("OVERRIDE_X")),
+            ("TEAM_AGENT_LEADER_SESSION_UUID", None),
+        ]);
+        let ws = p2_temp_ws("ovr");
+        let id = leader_identity_context(&ws, None, None).unwrap();
+        assert_eq!(id.leader_session_uuid_source, LeaderSessionUuidSource::Override);
+        assert_eq!(id.leader_session_uuid.as_str(), "OVERRIDE_X");
+    }
+
+    // P1 — derived inputs read state: machine_fingerprint = state team_owner record first
+    // (_identity_machine_fingerprint); team_id = team_state_key(state) from session_name
+    // (default 'current', not a hardcoded 'default').
+    #[test]
+    #[serial_test::serial(env)]
+    fn p2_leader_derived_inputs_read_state_record() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[("TEAM_AGENT_MACHINE_FINGERPRINT", None)]);
+        let ws = p2_temp_ws("der");
+        let state = serde_json::json!({
+            "team_owner": {"machine_fingerprint": "RECORDED-FP-FROM-STATE"},
+            "session_name": "team-agent-myteam"
+        });
+        let id = leader_identity_context(&ws, None, Some(&state)).unwrap();
+        assert_eq!(id.machine_fingerprint, "RECORDED-FP-FROM-STATE", "state record fp beats env/hostname");
+        assert_eq!(id.team_id.as_str(), "team-agent-myteam", "team_id from state.session_name");
+    }
+
+    // P1 — os_user fallback chain = USER or USERNAME or '' (_identity_os_user), NOT
+    // USER or LOGNAME or 'unknown'. (USERNAME is the 2nd choice; empty-string fallback.)
+    #[test]
+    #[serial_test::serial(env)]
+    fn p2_leader_os_user_honors_username_then_empty() {
+        let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+        let _e = EnvGuard::apply(&[
+            ("USER", None),
+            ("LOGNAME", None),
+            ("USERNAME", Some("winuser")),
+        ]);
+        let ws = p2_temp_ws("usr");
+        let id = leader_identity_context(&ws, None, None).unwrap();
+        assert_eq!(id.os_user, "winuser", "USERNAME is the second choice (not LOGNAME)");
+    }
+
+    // P1 — detect_dual_state_divergence must catch an owner leader_session_uuid split even
+    // when panes + epoch are identical (leader/__init__.py:574).
+    #[test]
+    #[serial_test::serial(env)]
+    fn p2_leader_detect_divergence_catches_owner_uuid_split() {
+        let ws = p2_temp_ws("div");
+        let snap_dir = crate::model::paths::runtime_dir(&ws).join("teams").join("sess1");
+        std::fs::create_dir_all(&snap_dir).unwrap();
+        let snap = serde_json::json!({
+            "session_name":"sess1",
+            "team_owner":{"pane_id":"%1","leader_session_uuid":"UUID_B","owner_epoch":5},
+            "leader_receiver":{"pane_id":"%1"}
+        });
+        std::fs::write(snap_dir.join("state.json"), serde_json::to_string(&snap).unwrap()).unwrap();
+        let state = serde_json::json!({
+            "session_name":"sess1",
+            "team_owner":{"pane_id":"%1","leader_session_uuid":"UUID_A","owner_epoch":5},
+            "leader_receiver":{"pane_id":"%1"}
+        });
+        let div = detect_dual_state_divergence(&ws, &state).unwrap();
+        assert!(div.is_some(), "owner uuid split (A vs B) with matching panes/epoch must be detected");
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // 14. WAVE-2 Lane B CONTRACT PASS — CLI-handler-facing byte-parity for the
+    //     three verbs (claim-leader / takeover / identity) + their core lease
+    //     machinery (_claim_lease_no_incident outcomes / _lease_refused shapes).
+    //
+    //     GOLDEN (re-probed @ team-agent-public, leader/__init__.py +
+    //     runtime.py:721/791). Each test labels RED|LOCK honestly:
+    //       RED  = drives an unimplemented!() body (claim_lease_no_incident /
+    //              attach_leader_to_state) → panics today = correct RED-first.
+    //       LOCK = drives an already-implemented stub/path → green today; pins
+    //              the golden so a future port cannot regress it.
+    //     Deferred to later adversarial rounds (Lane-A style): the ambiguous-
+    //     incident claim arm (no_caller_pane / caller_not_candidate / dry_run /
+    //     lost_race) which needs a seeded event-log incident + the broadcast
+    //     requeue cross-lane; the strict-uuid attach refusal string (needs a
+    //     live pane resolver). Those are #[ignore]/NOTE seams below.
+    // ═══════════════════════════════════════════════════════════════════════
+
+    // ── 14a. _claim_lease_no_incident OUTCOMES (golden __init__.py:598) ──────
+    //
+    // claim_lease_no_incident is unimplemented!() → every test here PANICS today