@team-agent/installer 0.2.10 → 0.3.0

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

@@ -0,0 +1,271 @@
+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() {
+        assert_eq!(LeaderEvent::IdleTakeoverReminder.name(), "idle_takeover.reminder");
+        assert_eq!(LeaderEvent::IdleTakeoverPushFailed.name(), "idle_takeover.push_failed");
+        assert_eq!(LeaderEvent::IdleTakeoverPing.name(), "idle_takeover.ping");
+    }
+
+    // =====================================================================
+    // 11. struct 构造 / 序列化形态 + key 插入序证据(纯数据,不依赖 body)
+    // =====================================================================
+
+    // LeaderReceiver:所有可选字段 Option(bug-085 半状态合法);序列化保字段名。
+    #[test]
+    fn leader_receiver_struct_serializes_with_python_field_names() {
+        let recv = LeaderReceiver {
+            mode: ReceiverMode::DirectTmux,
+            status: ReceiverStatus::Attached,
+            provider: Provider::ClaudeCode,
+            pane_id: PaneId::new("%648"),
+            session_name: Some(SessionName::new("S")),
+            window_index: Some("1".into()),
+            window_name: Some(WindowName::new("W")),
+            pane_index: Some("2".into()),
+            pane_tty: Some("/dev/ttys001".into()),
+            pane_current_command: Some("claude".into()),
+            fingerprint: Some("fp".into()),
+            leader_session_uuid: Some(uuid("fp", "/ws", "u", "default")),
+            owner_epoch: Some(OwnerEpoch(3)),
+            attached_at: Some("2026-06-02T00:00:00+00:00".into()),
+            discovery: Some(Discovery::ClaimLeader),
+            requested_provider: None,
+            warning: None,
+        };
+        let v = serde_json::to_value(&recv).unwrap();
+        assert_eq!(v["mode"], serde_json::json!("direct_tmux"));
+        assert_eq!(v["status"], serde_json::json!("attached"));
+        assert_eq!(v["provider"], serde_json::json!("claude_code"));
+        assert_eq!(v["pane_id"], serde_json::json!("%648"));
+        assert_eq!(v["owner_epoch"], serde_json::json!(3));
+        assert_eq!(v["discovery"], serde_json::json!("claim_leader"));
+        // bug-085:None 字段序列化为 null(半状态合法,不崩)。
+        assert_eq!(v["requested_provider"], serde_json::Value::Null);
+        assert_eq!(v["warning"], serde_json::Value::Null);
+    }
+
+    // TeamOwner:claimed_via kebab + owner_epoch int;os_user Option(Family A 才写)。
+    #[test]
+    fn team_owner_struct_serializes_with_python_shape() {
+        let owner = TeamOwner {
+            pane_id: PaneId::new("%9"),
+            provider: Provider::Codex,
+            machine_fingerprint: "fp".into(),
+            leader_session_uuid: Some(uuid("fp", "/ws", "u", "default")),
+            owner_epoch: OwnerEpoch(1),
+            claimed_at: "2026-06-02T00:00:00+00:00".into(),
+            claimed_via: ClaimedVia::ClaimLeader,
+            os_user: Some("alice".into()),
+        };
+        let v = serde_json::to_value(&owner).unwrap();
+        assert_eq!(v["claimed_via"], serde_json::json!("claim-leader"));
+        assert_eq!(v["owner_epoch"], serde_json::json!(1));
+        assert_eq!(v["provider"], serde_json::json!("codex"));
+        assert_eq!(v["os_user"], serde_json::json!("alice"));
+    }
+
+    // LeaderIdentity:source 用 leader-plan 枚举值(Override→"override");team_id 透明串。
+    #[test]
+    fn leader_identity_struct_serializes_with_leader_plan_source() {
+        let id = LeaderIdentity {
+            leader_session_uuid: uuid("fp", "/ws", "u", "default"),
+            leader_session_uuid_source: LeaderSessionUuidSource::Override,
+            machine_fingerprint: "fp".into(),
+            workspace_abspath: std::path::PathBuf::from("/ws"),
+            os_user: "u".into(),
+            team_id: TeamKey::new("default"),
+        };
+        let v = serde_json::to_value(&id).unwrap();
+        assert_eq!(v["leader_session_uuid_source"], serde_json::json!("override"));
+        assert_eq!(v["team_id"], serde_json::json!("default"));
+    }
+
+    // IdleNode:bug-085 rollout_path Option;state 是 TurnState(穷尽,Unknown 非 idle)。
+    #[test]
+    fn idle_node_unknown_state_is_not_idle() {
+        let n = IdleNode {
+            node_id: "w1".into(),
+            role: NodeRole::Worker,
+            state: TurnState::Unknown,
+            turn_id: None,
+            annotations: vec![],
+            provider: Some(Provider::Codex),
+            auth_mode: None,
+            rollout_path: None, // bug-085:None 合法 → 该 node Unknown。
+        };
+        assert!(!n.state.is_idle_for_takeover(), "Unknown 不当 idle");
+        assert!(n.rollout_path.is_none());
+    }

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

@@ -0,0 +1,225 @@
+use super::*;
+
+    // =====================================================================
+    // 7. 五条 lease 路径签名 + 返回 LeaseResult 形态(unimplemented → RED)
+    // =====================================================================
+
+    // attach_leader:手动 CLI attach(__init__.py:19-58 → attach_leader_to_state:276 →
+    // _resolve_leader_pane)。在无 live tmux 的测试环境,指定一个不存在的 pane %1 →
+    // _resolve_leader_pane raise RuntimeError("tmux pane not found: %1")(_legacy_pane_discovery.py:153),
+    // 映射到 LeaderError::Validation。golden(probe_attach.py 已验:真跑即 raise)。
+    // 强化:钉具体的 Err 形态 + 错误串含 pane id;并断言失败时绝不留下半绑定 state(无 team_owner)。
+    // unimplemented → RED(unimplemented panic ≠ 期望的 Validation,且后续 is_err 断言不会被求值)。
+    #[test]
+    fn attach_leader_errors_when_pane_not_resolvable() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_attach_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let r = attach_leader(&ws, Some(&PaneId::new("%1")), Provider::Codex);
+        // 不可解析 pane → Err(Validation),错误串提及 pane not found。
+        match r {
+            Err(LeaderError::Validation(msg)) => {
+                assert!(msg.contains("%1"), "Validation 错误须含目标 pane id,got {msg}");
+                assert!(msg.contains("not found"), "须是 pane-not-found 形态,got {msg}");
+            }
+            Err(other) => panic!("期望 Validation(pane not found),got {other:?}"),
+            Ok(v) => panic!("无 live tmux pane 时不该成功 attach,got {v:?}"),
+        }
+        // 失败不留半绑定:state.json 无 team_owner。
+        let st = crate::state::persist::load_runtime_state(&ws).unwrap();
+        assert!(st.get("team_owner").is_none(), "resolve 失败不得落 team_owner");
+    }
+
+    // attach_leader 成功 post-state(需 live tmux pane + cross-lane _resolve_leader_pane):
+    // vacant acquire → status=Claimed、reason=vacant_acquired、owner_epoch 0→1、owner/receiver 绑同 pane、
+    // 且 workspace state.json 真被持久化。golden(_claim_lease_no_incident:81/102/139-143)。
+    // real-machine-gated(无 live tmux 无法驱动 pane resolver)。
+    #[test]
+    #[ignore = "needs a live tmux pane + cross-lane _resolve_leader_pane (step 9/11)"]
+    fn attach_leader_binds_pane_advances_epoch_and_persists() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_attach_ok_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let pane = PaneId::new("%1");
+        let r = attach_leader(&ws, Some(&pane), Provider::Codex).unwrap();
+        assert!(r.ok);
+        assert_eq!(r.status, LeaseStatus::Claimed);
+        let owner = r.owner.as_ref().expect("attach 成功必带 owner");
+        assert_eq!(owner.pane_id, pane);
+        assert_eq!(owner.owner_epoch, OwnerEpoch(1), "vacant acquire 后 epoch=1");
+        assert_eq!(owner.provider, Provider::Codex);
+        let receiver = r.receiver.as_ref().expect("attach 成功必带 receiver");
+        assert_eq!(receiver.pane_id, pane);
+        assert_eq!(r.reason, Some(LeaseReason::VacantAcquired));
+        let persisted = crate::state::persist::load_runtime_state(&ws).unwrap();
+        assert_eq!(persisted["team_owner"]["pane_id"], serde_json::json!("%1"));
+        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]
+    fn claim_leader_returns_lease_result() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_claim_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let r = claim_leader(&ws, None, false).unwrap();
+        // 无 caller pane(测试进程无 TMUX_PANE)→ refused not_in_tmux_pane(__init__.py:616-618)。
+        if std::env::var_os("TMUX_PANE").is_none() {
+            assert!(!r.ok);
+            assert_eq!(r.status, LeaseStatus::Refused);
+            assert_eq!(r.reason, Some(LeaseReason::NotInTmuxPane));
+            assert!(r.action.is_some());
+        }
+    }
+
+    // write_lease_dual_state:同一锁内双写(C17,__init__.py:588-596);unimplemented → RED。
+    // 强化:带 session_name 时必须落 BOTH —— workspace state.json + team/<session> snapshot,
+    // 两份 team_owner.pane_id / owner_epoch 必须一致(永不分叉)。空 body Ok(()) 会被这里抓。
+    #[test]
+    fn write_lease_dual_state_persists_both_locations_without_divergence() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_dual_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let state = serde_json::json!({
+            "session_name": "team-sess",
+            "team_owner": {"pane_id": "%1", "owner_epoch": 2, "leader_session_uuid": "uuuu"},
+            "leader_receiver": {"pane_id": "%1", "owner_epoch": 2},
+        });
+        write_lease_dual_state(&ws, &state).unwrap();
+        // (1) workspace state.json(<ws>/.team/runtime/state.json)被写,team_owner.pane_id==%1。
+        let ws_path = crate::state::persist::runtime_state_path(&ws);
+        let ws_state: serde_json::Value =
+            serde_json::from_str(&std::fs::read_to_string(&ws_path).expect("workspace state.json 必须存在")).unwrap();
+        assert_eq!(ws_state["team_owner"]["pane_id"], serde_json::json!("%1"));
+        assert_eq!(ws_state["team_owner"]["owner_epoch"], serde_json::json!(2));
+        // (2) team-level snapshot(<ws>/.team/runtime/teams/<session>/state.json)被写。
+        let snap_path = crate::model::paths::runtime_dir(&ws)
+            .join("teams")
+            .join("team-sess")
+            .join("state.json");
+        let snap_state: serde_json::Value =
+            serde_json::from_str(&std::fs::read_to_string(&snap_path).expect("team snapshot state.json 必须存在")).unwrap();
+        // (3) 两份永不分叉:owner pane_id / owner_epoch 必须相等(C17 核心不变量)。
+        assert_eq!(
+            ws_state["team_owner"]["pane_id"], snap_state["team_owner"]["pane_id"],
+            "workspace 与 team snapshot 的 owner pane 不得分叉"
+        );
+        assert_eq!(
+            ws_state["team_owner"]["owner_epoch"], snap_state["team_owner"]["owner_epoch"],
+            "workspace 与 team snapshot 的 owner_epoch 不得分叉"
+        );
+    }
+
+    // detect_dual_state_divergence:无 session_name → None(__init__.py:560-561);unimplemented → RED。
+    #[test]
+    fn detect_dual_state_divergence_none_without_session_name() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_div_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let state = serde_json::json!({"team_owner": {"pane_id": "%1"}}); // 无 session_name。
+        let d = detect_dual_state_divergence(&ws, &state).unwrap();
+        assert!(d.is_none(), "无 session_name → 无 snapshot 可比 → None");
+    }
+
+    // C18 核心:workspace state.json 与 team snapshot 在 owner pane 上分叉 → Some(具体分叉字段)。
+    // golden(probe_leader_strengthen.py):workspace owner=%1 / snapshot owner=%9 →
+    // {workspace_owner_pane:%1, team_owner_pane:%9, workspace_receiver_pane:%1, team_receiver_pane:%9}。
+    // unimplemented → RED。
+    #[test]
+    fn detect_dual_state_divergence_reports_diverging_panes() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_divx_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let state = serde_json::json!({
+            "session_name": "team-sess",
+            "team_owner": {"pane_id": "%1", "leader_session_uuid": "uuuu", "owner_epoch": 2},
+            "leader_receiver": {"pane_id": "%1", "owner_epoch": 2},
+        });
+        // 写一份分叉 snapshot:owner/receiver pane 都是 %9(不同于 workspace 的 %1)。
+        let snap_dir = crate::model::paths::runtime_dir(&ws).join("teams").join("team-sess");
+        std::fs::create_dir_all(&snap_dir).unwrap();
+        let snap = serde_json::json!({
+            "session_name": "team-sess",
+            "team_owner": {"pane_id": "%9", "leader_session_uuid": "uuuu", "owner_epoch": 2},
+            "leader_receiver": {"pane_id": "%9", "owner_epoch": 2},
+        });
+        std::fs::write(snap_dir.join("state.json"), serde_json::to_string(&snap).unwrap()).unwrap();
+        let d = detect_dual_state_divergence(&ws, &state).unwrap().expect("分叉 → Some(details)");
+        assert_eq!(d["workspace_owner_pane"], serde_json::json!("%1"));
+        assert_eq!(d["team_owner_pane"], serde_json::json!("%9"));
+        assert_eq!(d["workspace_receiver_pane"], serde_json::json!("%1"));
+        assert_eq!(d["team_receiver_pane"], serde_json::json!("%9"));
+
+        // 匹配 snapshot(与 workspace 一致)→ None(无分叉)。
+        std::fs::write(snap_dir.join("state.json"), serde_json::to_string(&state).unwrap()).unwrap();
+        assert!(
+            detect_dual_state_divergence(&ws, &state).unwrap().is_none(),
+            "两份一致 → 无分叉 → None"
+        );
+    }
+
+// R8 D4 (c-lite offline byte-lock): the leader_receiver.requeued_exhausted_watchers payload-build,
+// extracted from the real-tmux attach flow into a pure helper, must produce golden shape.
+// golden leader/__init__.py:39-44: EXACTLY {watcher_ids, count, trigger:"attach_leader"}.
+#[test]
+fn r8_requeued_exhausted_watchers_event_payload_golden_shape() {
+    let notices = vec![crate::messaging::WatcherNotice {
+        watcher_id: "w1".to_string(),
+        result_id: Some("r1".to_string()),
+        ok: true,
+        status: Some("notify_failed".to_string()),
+        notified_message_id: None,
+        primary_watcher_id: None,
+        prior_state: Some("delivery_exhausted".to_string()),
+        error: None,
+    }];
+    let payload = crate::leader::lease::requeued_exhausted_watchers_event_payload(
+        &crate::transport::PaneId::new("%leader"),
+        &crate::model::ids::TeamKey::new("team-a"),
+        &notices,
+    );
+    let keys: std::collections::BTreeSet<&str> =
+        payload.as_object().unwrap().keys().map(String::as_str).collect();
+    let expected: std::collections::BTreeSet<&str> = ["watcher_ids", "count", "trigger"].into_iter().collect();
+    assert_eq!(keys, expected,
+        "D4: leader_receiver.requeued_exhausted_watchers payload must be golden {{watcher_ids, count, trigger}} \
+         (leader/__init__.py:39-44), not the Rust {{pane_id, team_id, watcher_ids, requeued}}; got {keys:?}");
+    assert_eq!(
+        payload.get("watcher_ids").and_then(|v| v.as_array()).map(|a| a.iter().filter_map(|x| x.as_str()).collect::<Vec<_>>()),
+        Some(vec!["w1"]), "watcher_ids must be the string list of requeued ids");
+    assert_eq!(payload.get("count").and_then(|v| v.as_u64()), Some(1), "count == number of requeued watchers");
+    assert_eq!(payload.get("trigger").and_then(|v| v.as_str()), Some("attach_leader"));
+}