@team-agent/installer 0.5.42 → 0.5.44

package/crates/team-agent/src/cli/tests/lane_c.rs

@@ -1,71 +1,71 @@
 use super::*;
 
-    // =========================================================================
-    // WAVE-2 LANE C — diagnose/status byte-parity DIVERGENCES + target-scan wiring.
-    // The status/diagnose handlers are IMPLEMENTED (status) or STUBBED (approvals/inbox/doctor/
-    // comms_selftest/orphan_gate/cleanup_orphans/fix_schema) — these REDs lock the EXACT golden JSON
-    // shapes (keys/values/insertion-order) each one DIVERGES from. Golden bytes captured via
-    // PYTHONPATH=.../src python3 /tmp/lanec_probe*.py on a fresh workspace.
-    // =========================================================================
+// =========================================================================
+// WAVE-2 LANE C — diagnose/status byte-parity DIVERGENCES + target-scan wiring.
+// The status/diagnose handlers are IMPLEMENTED (status) or STUBBED (approvals/inbox/doctor/
+// comms_selftest/orphan_gate/cleanup_orphans/fix_schema) — these REDs lock the EXACT golden JSON
+// shapes (keys/values/insertion-order) each one DIVERGES from. Golden bytes captured via
+// PYTHONPATH=.../src python3 /tmp/lanec_probe*.py on a fresh workspace.
+// =========================================================================
 
-    /// Seed `.team/runtime/state.json` with `state` so `status_port::status` reads a real fixture.
-    fn seed_status_state(state: serde_json::Value) -> std::path::PathBuf {
-        let ws = tmp_workspace();
-        std::fs::write(
-            ws.join(".team").join("runtime").join("state.json"),
-            serde_json::to_vec_pretty(&state).unwrap(),
-        )
-        .unwrap();
-        ws
-    }
+/// Seed `.team/runtime/state.json` with `state` so `status_port::status` reads a real fixture.
+fn seed_status_state(state: serde_json::Value) -> std::path::PathBuf {
+    let ws = tmp_workspace();
+    std::fs::write(
+        ws.join(".team").join("runtime").join("state.json"),
+        serde_json::to_vec_pretty(&state).unwrap(),
+    )
+    .unwrap();
+    ws
+}
 
-    // ── status #1: `team` = state["leader"]["id"] (default "leader"), NOT state["team"] ──────────────
-    // GOLDEN queries.py:66 `state.get("leader", {}).get("id", "leader")`. RUST mod.rs:94 reads
-    // `state.get("team")`. Seed BOTH distinct -> golden binds leader.id, Rust binds the team key. RED.
-    #[test]
-    fn status_team_is_leader_id_not_team_key() {
-        let ws = seed_status_state(json!({"team": "TEAMKEY", "leader": {"id": "LEADERID"}}));
-        let v = status_port::status(&ws, /*compact=*/ false, /*detail=*/ true).expect("status");
-        assert_eq!(
-            v["team"],
-            json!("LEADERID"),
-            "golden status.team = state['leader']['id'] (queries.py:66), NOT state['team']; got {:?}",
-            v["team"]
-        );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+// ── status #1: `team` = state["leader"]["id"] (default "leader"), NOT state["team"] ──────────────
+// GOLDEN queries.py:66 `state.get("leader", {}).get("id", "leader")`. RUST mod.rs:94 reads
+// `state.get("team")`. Seed BOTH distinct -> golden binds leader.id, Rust binds the team key. RED.
+#[test]
+fn status_team_is_leader_id_not_team_key() {
+    let ws = seed_status_state(json!({"team": "TEAMKEY", "leader": {"id": "LEADERID"}}));
+    let v = status_port::status(&ws, /*compact=*/ false, /*detail=*/ true).expect("status");
+    assert_eq!(
+        v["team"],
+        json!("LEADERID"),
+        "golden status.team = state['leader']['id'] (queries.py:66), NOT state['team']; got {:?}",
+        v["team"]
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── status #2: messages = store.message_counts() ({} when empty), results = store.result_counts()
-    // ({total,uncollected,collected,invalid,by_status}) — NOT the Rust {"count": N} placeholders. ──────
-    // GOLDEN queries.py:73,75. RUST mod.rs:101,103 emit `{"count": N}`. RED.
-    #[test]
-    fn status_counts_are_store_count_maps_not_count_int() {
-        let ws = tmp_workspace(); // empty store
-        let v = status_port::status(&ws, false, true).expect("status");
-        assert_eq!(
-            v["messages"],
-            json!({}),
-            "golden empty store.message_counts() == {{}} (queries.py:73), NOT {{count:0}}; got {:?}",
-            v["messages"]
-        );
-        assert_eq!(
-            v["results"],
-            json!({"total": 0, "uncollected": 0, "collected": 0, "invalid": 0, "by_status": {}}),
-            "golden store.result_counts() full shape (queries.py:75), NOT {{count:0}}; got {:?}",
-            v["results"]
-        );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+// ── status #2: messages = store.message_counts() ({} when empty), results = store.result_counts()
+// ({total,uncollected,collected,invalid,by_status}) — NOT the Rust {"count": N} placeholders. ──────
+// GOLDEN queries.py:73,75. RUST mod.rs:101,103 emit `{"count": N}`. RED.
+#[test]
+fn status_counts_are_store_count_maps_not_count_int() {
+    let ws = tmp_workspace(); // empty store
+    let v = status_port::status(&ws, false, true).expect("status");
+    assert_eq!(
+        v["messages"],
+        json!({}),
+        "golden empty store.message_counts() == {{}} (queries.py:73), NOT {{count:0}}; got {:?}",
+        v["messages"]
+    );
+    assert_eq!(
+        v["results"],
+        json!({"total": 0, "uncollected": 0, "collected": 0, "invalid": 0, "by_status": {}}),
+        "golden store.result_counts() full shape (queries.py:75), NOT {{count:0}}; got {:?}",
+        v["results"]
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── status #3: coordinator = coordinator_health(ws) FULL shape in golden order ──────────────────
-    // 0.5.18 adds binary identity diagnostics to expose stale coordinator rotation reasons.
-    #[test]
-    fn status_coordinator_is_full_health_identity_shape() {
-        let ws = tmp_workspace();
-        let v = status_port::status(&ws, false, true).expect("status");
-        let coord = v["coordinator"].as_object().expect("coordinator dict");
-        let order: Vec<&str> = coord.keys().map(String::as_str).collect();
-        assert_eq!(
+// ── status #3: coordinator = coordinator_health(ws) FULL shape in golden order ──────────────────
+// 0.5.18 adds binary identity diagnostics to expose stale coordinator rotation reasons.
+#[test]
+fn status_coordinator_is_full_health_identity_shape() {
+    let ws = tmp_workspace();
+    let v = status_port::status(&ws, false, true).expect("status");
+    let coord = v["coordinator"].as_object().expect("coordinator dict");
+    let order: Vec<&str> = coord.keys().map(String::as_str).collect();
+    assert_eq!(
             order,
             vec![
                 "ok",
@@ -89,197 +89,220 @@ use super::*;
             ],
             "golden coordinator_health insertion order with 0.5.41 fault-invisibility fields; got {order:?}"
         );
-        assert!(
+    assert!(
             coord.get("schema_version").is_none(),
             "golden coordinator has NO flat `schema_version` (it nests schema:{{message_store_schema_version}}); \
              Rust emits the flat key. got {coord:?}"
         );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── status #4: last_events = EventLog.tail(10) ([] when no events), NOT the literal placeholder ──
-    // GOLDEN queries.py:78 `EventLog(workspace).tail(10)`. RUST mod.rs:113 (non-compact) emits the
-    // hardcoded placeholder `[{"event":"status.full"}]`. On a fresh log golden == []. RED. ────────────
-    #[test]
-    fn status_last_events_is_event_tail_not_status_full_placeholder() {
-        let ws = tmp_workspace(); // no events.jsonl
-        let v = status_port::status(&ws, false, true).expect("status");
-        assert_ne!(
+// ── status #4: last_events = EventLog.tail(10) ([] when no events), NOT the literal placeholder ──
+// GOLDEN queries.py:78 `EventLog(workspace).tail(10)`. RUST mod.rs:113 (non-compact) emits the
+// hardcoded placeholder `[{"event":"status.full"}]`. On a fresh log golden == []. RED. ────────────
+#[test]
+fn status_last_events_is_event_tail_not_status_full_placeholder() {
+    let ws = tmp_workspace(); // no events.jsonl
+    let v = status_port::status(&ws, false, true).expect("status");
+    assert_ne!(
             v["last_events"],
             json!([{"event": "status.full"}]),
             "golden last_events = EventLog.tail(10), NOT the literal [{{event:status.full}}] placeholder"
         );
-        assert_eq!(
-            v["last_events"],
-            json!([]),
-            "golden last_events on a fresh event log is [] (tail of empty); got {:?}",
-            v["last_events"]
-        );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+    assert_eq!(
+        v["last_events"],
+        json!([]),
+        "golden last_events on a fresh event log is [] (tail of empty); got {:?}",
+        v["last_events"]
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── status #5: the full (non-compact) status dict has NO `detail` key ────────────────────────────
-    // GOLDEN queries.py:65-79 builds exactly 13 keys; there is no `detail`. RUST mod.rs:115-119 injects
-    // `detail:true` whenever `!compact || detail`. The full --detail call MUST NOT carry detail. RED. ──
-    #[test]
-    fn status_noncompact_has_no_detail_key() {
-        let ws = tmp_workspace();
-        let v = status_port::status(&ws, /*compact=*/ false, /*detail=*/ true).expect("status");
-        assert!(
+// ── status #5: the full (non-compact) status dict has NO `detail` key ────────────────────────────
+// GOLDEN queries.py:65-79 builds exactly 13 keys; there is no `detail`. RUST mod.rs:115-119 injects
+// `detail:true` whenever `!compact || detail`. The full --detail call MUST NOT carry detail. RED. ──
+#[test]
+fn status_noncompact_has_no_detail_key() {
+    let ws = tmp_workspace();
+    let v = status_port::status(&ws, /*compact=*/ false, /*detail=*/ true).expect("status");
+    assert!(
             v.as_object().unwrap().get("detail").is_none(),
             "golden status dict has NO `detail` key (queries.py:65-79); Rust injects detail:true. got {v:?}"
         );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── status #6: each agent entry is enriched with an `interacted` marker (C3, queries.py:53-64) ────
-    // GOLDEN: valid ISO first_send_at passes through; any other shape (invalid str / missing) -> the
-    // literal "never" (_interacted_marker, queries.py:15-30). RUST mod.rs:81-84 passes agents through
-    // RAW with no enrichment -> no `interacted` key. RED. ────────────────────────────────────────────
-    #[test]
-    fn status_agents_enriched_with_interacted_marker() {
-        let ws = seed_status_state(json!({
-            "leader": {"id": "leader"},
-            "agents": {
-                "alpha": {"provider": "codex", "first_send_at": "2026-05-27T10:00:00+00:00"},
-                "beta": {"provider": "claude", "first_send_at": "not-a-date"},
-                "gamma": {"provider": "claude"},
-            }
-        }));
-        let v = status_port::status(&ws, false, true).expect("status");
-        let agents = &v["agents"];
-        assert_eq!(
-            agents["alpha"]["interacted"],
-            json!("2026-05-27T10:00:00+00:00"),
-            "valid ISO first_send_at must pass through as the interacted marker (queries.py:24-29)"
-        );
-        assert_eq!(
-            agents["beta"]["interacted"],
-            json!("never"),
-            "an unparseable first_send_at must render as the literal 'never' (queries.py:27-28)"
-        );
-        assert_eq!(
-            agents["gamma"]["interacted"],
-            json!("never"),
-            "a missing first_send_at must render as 'never' (queries.py:30)"
-        );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+// ── status #6: each agent entry is enriched with an `interacted` marker (C3, queries.py:53-64) ────
+// GOLDEN: valid ISO first_send_at passes through; any other shape (invalid str / missing) -> the
+// literal "never" (_interacted_marker, queries.py:15-30). RUST mod.rs:81-84 passes agents through
+// RAW with no enrichment -> no `interacted` key. RED. ────────────────────────────────────────────
+#[test]
+fn status_agents_enriched_with_interacted_marker() {
+    let ws = seed_status_state(json!({
+        "leader": {"id": "leader"},
+        "agents": {
+            "alpha": {"provider": "codex", "first_send_at": "2026-05-27T10:00:00+00:00"},
+            "beta": {"provider": "claude", "first_send_at": "not-a-date"},
+            "gamma": {"provider": "claude"},
+        }
+    }));
+    let v = status_port::status(&ws, false, true).expect("status");
+    let agents = &v["agents"];
+    assert_eq!(
+        agents["alpha"]["interacted"],
+        json!("2026-05-27T10:00:00+00:00"),
+        "valid ISO first_send_at must pass through as the interacted marker (queries.py:24-29)"
+    );
+    assert_eq!(
+        agents["beta"]["interacted"],
+        json!("never"),
+        "an unparseable first_send_at must render as the literal 'never' (queries.py:27-28)"
+    );
+    assert_eq!(
+        agents["gamma"]["interacted"],
+        json!("never"),
+        "a missing first_send_at must render as 'never' (queries.py:30)"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── status #7 (TARGET-SCAN WIRING, in-process): tmux_session_present uses a LIVE tmux probe ───────
-    // GOLDEN queries.py:52 `_tmux_session_exists(session_name)` (real `tmux has-session`). RUST mod.rs:96
-    // shortcuts to `session_name.is_some()`. Seed a present-but-nonexistent session -> golden False,
-    // Rust True. This is the status-level pane-discovery wiring the dangling list_targets feeds. RED. ──
-    #[test]
-    fn status_tmux_session_present_uses_live_tmux_probe_not_is_some() {
-        let absent = format!("ta-lanec-absent-{}", std::process::id());
-        let ws = seed_status_state(json!({"leader": {"id": "leader"}, "session_name": absent}));
-        let v = status_port::status(&ws, false, true).expect("status");
-        assert_eq!(
+// ── status #7 (TARGET-SCAN WIRING, in-process): tmux_session_present uses a LIVE tmux probe ───────
+// GOLDEN queries.py:52 `_tmux_session_exists(session_name)` (real `tmux has-session`). RUST mod.rs:96
+// shortcuts to `session_name.is_some()`. Seed a present-but-nonexistent session -> golden False,
+// Rust True. This is the status-level pane-discovery wiring the dangling list_targets feeds. RED. ──
+#[test]
+fn status_tmux_session_present_uses_live_tmux_probe_not_is_some() {
+    let absent = format!("ta-lanec-absent-{}", std::process::id());
+    let ws = seed_status_state(json!({"leader": {"id": "leader"}, "session_name": absent}));
+    let v = status_port::status(&ws, false, true).expect("status");
+    assert_eq!(
             v["tmux_session_present"],
             json!(false),
             "golden tmux_session_present = _tmux_session_exists(name) (a live probe; queries.py:52); a \
              present-but-nonexistent session name must be False, not is_some()==true. got {:?}",
             v["tmux_session_present"]
         );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── approvals: golden 5-key {ok,waiting,waiting_count,approvals,scan} (status/approvals.py:30-36) ──
-    // RUST mod.rs:131-133 stub {ok,agent,approvals}. RED. ───────────────────────────────────────────
-    #[test]
-    fn approvals_golden_shape_has_waiting_count_and_scan_not_agent() {
-        let ws = tmp_workspace();
-        let v = status_port::approvals(&ws, None, true).expect("approvals");
-        let obj = v.as_object().expect("approvals dict");
-        let order: Vec<&str> = obj.keys().map(String::as_str).collect();
-        assert_eq!(
+// ── approvals: golden 5-key {ok,waiting,waiting_count,approvals,scan} (status/approvals.py:30-36) ──
+// RUST mod.rs:131-133 stub {ok,agent,approvals}. RED. ───────────────────────────────────────────
+#[test]
+fn approvals_golden_shape_has_waiting_count_and_scan_not_agent() {
+    let ws = tmp_workspace();
+    let v = status_port::approvals(&ws, None, true).expect("approvals");
+    let obj = v.as_object().expect("approvals dict");
+    let order: Vec<&str> = obj.keys().map(String::as_str).collect();
+    assert_eq!(
             order,
             vec!["ok", "waiting", "waiting_count", "approvals", "scan"],
             "golden approvals 5-key order (approvals.py:30-36); Rust stub emits {{ok,agent,approvals}}. got {order:?}"
         );
-        assert!(!obj.contains_key("agent"), "golden approvals has NO `agent` key");
-        assert_eq!(
+    assert!(
+        !obj.contains_key("agent"),
+        "golden approvals has NO `agent` key"
+    );
+    assert_eq!(
             v["scan"],
             json!({"mode": "tail", "lines": 120, "raw_output": false}),
             "golden scan == {{mode:tail,lines:120,raw_output:false}} (APPROVAL_SCAN_LINES=120); got {:?}",
             v["scan"]
         );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── inbox: golden {ok,agent_id,messages,since} (status/inbox.py:35-38) — key is `agent_id`, carries
-    // `since` (not `agent`/`limit`). RUST mod.rs:136-144 stub {ok,agent,limit,messages}. RED. ──────────
-    #[test]
-    fn inbox_golden_shape_is_agent_id_and_since_not_agent_limit() {
-        let ws = tmp_workspace();
-        let v = status_port::inbox(&ws, "alpha", 20, None, true, None).expect("inbox");
-        let obj = v.as_object().expect("inbox dict");
-        let order: Vec<&str> = obj.keys().map(String::as_str).collect();
-        assert_eq!(
+// ── inbox: golden {ok,agent_id,messages,since} (status/inbox.py:35-38) — key is `agent_id`, carries
+// `since` (not `agent`/`limit`). RUST mod.rs:136-144 stub {ok,agent,limit,messages}. RED. ──────────
+#[test]
+fn inbox_golden_shape_is_agent_id_and_since_not_agent_limit() {
+    let ws = tmp_workspace();
+    let v = status_port::inbox(&ws, "alpha", 20, None, true, None).expect("inbox");
+    let obj = v.as_object().expect("inbox dict");
+    let order: Vec<&str> = obj.keys().map(String::as_str).collect();
+    assert_eq!(
             order,
             vec!["ok", "agent_id", "messages", "since"],
             "golden inbox 4-key order {{ok,agent_id,messages,since}} (inbox.py:38); Rust stub uses agent/limit. got {order:?}"
         );
-        assert_eq!(v["agent_id"], json!("alpha"), "golden key is `agent_id` (not `agent`)");
-        assert!(obj.contains_key("since"), "golden inbox carries `since` (echoed, null here)");
-        assert!(!obj.contains_key("agent"), "golden inbox has NO bare `agent` key");
-        assert!(!obj.contains_key("limit"), "golden inbox has NO `limit` key in the result dict");
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+    assert_eq!(
+        v["agent_id"],
+        json!("alpha"),
+        "golden key is `agent_id` (not `agent`)"
+    );
+    assert!(
+        obj.contains_key("since"),
+        "golden inbox carries `since` (echoed, null here)"
+    );
+    assert!(
+        !obj.contains_key("agent"),
+        "golden inbox has NO bare `agent` key"
+    );
+    assert!(
+        !obj.contains_key("limit"),
+        "golden inbox has NO `limit` key in the result dict"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── comms_selftest: golden {ok,status,run_id,scope,boundary,checks} (diagnose/comms.py:40-47) ─────
-    // RUST mod.rs:525-527 stub {ok,team,gate,provider_sdk_calls:int}. RED. Locks COMMS_BOUNDARY_TEXT +
-    // the deterministic check sub-shapes (run_id is a random uuid; not value-locked). ────────────────
-    #[test]
-    fn comms_selftest_golden_boundary_scope_and_check_shapes() {
-        let boundary = "validates live pane binding consistency and zero-token comms contracts. \
+// ── comms_selftest: golden {ok,status,run_id,scope,boundary,checks} (diagnose/comms.py:40-47) ─────
+// RUST mod.rs:525-527 stub {ok,team,gate,provider_sdk_calls:int}. RED. Locks COMMS_BOUNDARY_TEXT +
+// the deterministic check sub-shapes (run_id is a random uuid; not value-locked). ────────────────
+#[test]
+fn comms_selftest_golden_boundary_scope_and_check_shapes() {
+    let boundary = "validates live pane binding consistency and zero-token comms contracts. \
                         Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
-        let ws = tmp_workspace();
-        let v = diagnose_port::comms_selftest(&ws, None, None).expect("comms_selftest");
-        let obj = v.as_object().expect("comms dict");
-        assert_eq!(v["boundary"], json!(boundary), "golden COMMS_BOUNDARY_TEXT prefix (comms.py:11-14)");
-        assert_eq!(v["scope"], json!("binding_consistency"), "golden scope");
-        assert_eq!(
-            v["status"],
-            json!("fail"),
-            "empty workspace has no runtime receiver binding, so comms gate must not pass"
-        );
-        assert!(obj.contains_key("run_id"), "golden carries a run_id (uuid hex[:12])");
-        assert!(!obj.contains_key("team"), "golden has NO `team` key");
-        assert!(!obj.contains_key("gate"), "golden has NO `gate` key");
-        assert_eq!(v["checks"]["contract_suite"]["status"], json!("pass"));
-        assert_eq!(v["checks"]["contract_suite"]["failed"], json!([]));
-        let suite_names: Vec<&str> = v["checks"]["contract_suite"]["checks"]
-            .as_array()
-            .expect("contract suite checks")
-            .iter()
-            .filter_map(|check| check.get("name").and_then(Value::as_str))
-            .collect();
-        assert!(
-            suite_names.contains(&"message_store_schema")
-                && suite_names.contains(&"message_token_shape")
-                && suite_names.contains(&"result_notification_render")
-                && suite_names.contains(&"leader_projection_owner_team"),
-            "contract suite must be executable, not deferred: {suite_names:?}"
-        );
-        assert_eq!(
-            v["checks"]["provider_sdk_calls"]["calls"],
-            json!({"anthropic": 0, "openai": 0, "httpx": 0}),
-            "golden provider_sdk_calls.calls (comms.py:142-151); Rust stub is a bare int 0"
-        );
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+    let ws = tmp_workspace();
+    let v = diagnose_port::comms_selftest(&ws, None, None).expect("comms_selftest");
+    let obj = v.as_object().expect("comms dict");
+    assert_eq!(
+        v["boundary"],
+        json!(boundary),
+        "golden COMMS_BOUNDARY_TEXT prefix (comms.py:11-14)"
+    );
+    assert_eq!(v["scope"], json!("binding_consistency"), "golden scope");
+    assert_eq!(
+        v["status"],
+        json!("fail"),
+        "empty workspace has no runtime receiver binding, so comms gate must not pass"
+    );
+    assert!(
+        obj.contains_key("run_id"),
+        "golden carries a run_id (uuid hex[:12])"
+    );
+    assert!(!obj.contains_key("team"), "golden has NO `team` key");
+    assert!(!obj.contains_key("gate"), "golden has NO `gate` key");
+    assert_eq!(v["checks"]["contract_suite"]["status"], json!("pass"));
+    assert_eq!(v["checks"]["contract_suite"]["failed"], json!([]));
+    let suite_names: Vec<&str> = v["checks"]["contract_suite"]["checks"]
+        .as_array()
+        .expect("contract suite checks")
+        .iter()
+        .filter_map(|check| check.get("name").and_then(Value::as_str))
+        .collect();
+    assert!(
+        suite_names.contains(&"message_store_schema")
+            && suite_names.contains(&"message_token_shape")
+            && suite_names.contains(&"result_notification_render")
+            && suite_names.contains(&"leader_projection_owner_team"),
+        "contract suite must be executable, not deferred: {suite_names:?}"
+    );
+    assert_eq!(
+        v["checks"]["provider_sdk_calls"]["calls"],
+        json!({"anthropic": 0, "openai": 0, "httpx": 0}),
+        "golden provider_sdk_calls.calls (comms.py:142-151); Rust stub is a bare int 0"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── orphan_gate(fix=true,confirm=false): golden REFUSED envelope (orphan_cleanup.py:304-311) ──────
-    // {ok:false,gate:"orphans",status:"refused",reason:"fix_requires_confirm",action:...}. RUST mod.rs:
-    // 530-531 stub {ok:true,fix,confirm,orphans:[]}. Fully deterministic (no subprocess). RED. ─────────
-    #[test]
-    fn orphan_gate_fix_without_confirm_is_refused_envelope() {
-        let ws = tmp_workspace();
-        let v = diagnose_port::orphan_gate(&ws, /*fix=*/ true, /*confirm=*/ false)
-            .expect("orphan_gate");
-        assert_eq!(
+// ── orphan_gate(fix=true,confirm=false): golden REFUSED envelope (orphan_cleanup.py:304-311) ──────
+// {ok:false,gate:"orphans",status:"refused",reason:"fix_requires_confirm",action:...}. RUST mod.rs:
+// 530-531 stub {ok:true,fix,confirm,orphans:[]}. Fully deterministic (no subprocess). RED. ─────────
+#[test]
+fn orphan_gate_fix_without_confirm_is_refused_envelope() {
+    let ws = tmp_workspace();
+    let v =
+        diagnose_port::orphan_gate(&ws, /*fix=*/ true, /*confirm=*/ false).expect("orphan_gate");
+    assert_eq!(
             v,
             json!({
                 "ok": false,
@@ -290,74 +313,134 @@ use super::*;
             }),
             "golden orphan_gate fix-without-confirm refused envelope (orphan_cleanup.py:304-311); got {v:?}"
         );
-        let order: Vec<&str> = v.as_object().unwrap().keys().map(String::as_str).collect();
-        assert_eq!(order, vec!["ok", "gate", "status", "reason", "action"], "golden refused key order");
-    }
+    let order: Vec<&str> = v.as_object().unwrap().keys().map(String::as_str).collect();
+    assert_eq!(
+        order,
+        vec!["ok", "gate", "status", "reason", "action"],
+        "golden refused key order"
+    );
+}
 
-    // ── cleanup_orphans(confirm=false): golden DRY-RUN envelope (orphan_cleanup.py cleanup_…) ─────────
-    // {ok,scanned,orphans,dry_run:true,scanned_at,action_required}. RUST mod.rs:534-535 stub
-    // {ok,confirm,cleaned}. scanned/scanned_at are machine/clock-derived; lock the deterministic ones. RED.
-    #[test]
-    #[ignore = "real-machine: cleanup_orphans scans machine-wide ta-* tmux/process residue"]
-    #[serial_test::file_serial(tmux)]
-    fn cleanup_orphans_dryrun_golden_envelope() {
-        let ws = tmp_workspace();
-        let v = diagnose_port::cleanup_orphans(&ws, /*confirm=*/ false).expect("cleanup_orphans");
-        let obj = v.as_object().expect("cleanup dict");
-        assert_eq!(v["dry_run"], json!(true), "no --confirm => dry_run:true (cleanup_orphan_coordinators)");
-        assert_eq!(v["orphans"], json!([]), "golden lists orphans (empty when none)");
-        assert_eq!(
-            v["action_required"],
-            json!("re-run with --confirm to send SIGTERM"),
-            "golden dry-run action_required text"
-        );
-        assert!(obj.contains_key("scanned_at"), "golden carries scanned_at timestamp");
-        assert!(obj.contains_key("scanned"), "golden carries scanned count");
-        assert!(!obj.contains_key("confirm"), "golden has NO `confirm` key");
-        assert!(!obj.contains_key("cleaned"), "golden has NO `cleaned` key (uses `orphans`)");
-    }
+// ── cleanup_orphans(confirm=false): golden DRY-RUN envelope (orphan_cleanup.py cleanup_…) ─────────
+// {ok,scanned,orphans,dry_run:true,scanned_at,action_required}. RUST mod.rs:534-535 stub
+// {ok,confirm,cleaned}. scanned/scanned_at are machine/clock-derived; lock the deterministic ones. RED.
+#[test]
+#[ignore = "real-machine: cleanup_orphans scans machine-wide ta-* tmux/process residue"]
+#[serial_test::file_serial(tmux)]
+fn cleanup_orphans_dryrun_golden_envelope() {
+    let ws = tmp_workspace();
+    let v = diagnose_port::cleanup_orphans(&ws, /*confirm=*/ false).expect("cleanup_orphans");
+    let obj = v.as_object().expect("cleanup dict");
+    assert_eq!(
+        v["dry_run"],
+        json!(true),
+        "no --confirm => dry_run:true (cleanup_orphan_coordinators)"
+    );
+    assert_eq!(
+        v["orphans"],
+        json!([]),
+        "golden lists orphans (empty when none)"
+    );
+    assert_eq!(
+        v["action_required"],
+        json!("re-run with --confirm to send SIGTERM"),
+        "golden dry-run action_required text"
+    );
+    assert!(
+        obj.contains_key("scanned_at"),
+        "golden carries scanned_at timestamp"
+    );
+    assert!(obj.contains_key("scanned"), "golden carries scanned count");
+    assert!(!obj.contains_key("confirm"), "golden has NO `confirm` key");
+    assert!(
+        !obj.contains_key("cleaned"),
+        "golden has NO `cleaned` key (uses `orphans`)"
+    );
+}
 
-    // ── fix_schema: golden fix_schema_layout diagnosis envelope (schema_migration.py:258) ─────────────
-    // {ok,status,db_path,schema_version,user_version,layout_diffs,recommended_action,would_backup_path,
-    // fixed,rebuilds}. RUST mod.rs:538-540 stub {ok,fixed:false}. db_path/would_backup_path are
-    // path/clock-derived; lock the deterministic fields. SCHEMA_VERSION==3. RED. ─────────────────────
-    #[test]
-    fn fix_schema_golden_layout_diagnosis_envelope() {
-        let ws = tmp_workspace();
-        let v = diagnose_port::fix_schema(&ws).expect("fix_schema");
-        let obj = v.as_object().expect("fix_schema dict");
-        assert_eq!(v["status"], json!("missing"), "missing db: status missing");
-        assert_eq!(v["schema_version"], json!(3), "golden schema_version == SCHEMA_VERSION (3)");
-        assert_eq!(v["user_version"], json!(0), "missing db user_version == 0");
-        assert_eq!(v["layout_diffs"], json!([]), "missing db => empty layout_diffs list");
-        assert_eq!(v["recommended_action"], json!("none"), "no drift => recommended_action 'none'");
-        assert_eq!(v["fixed"], json!(false), "missing db is diagnostic-only and does not create a db");
-        assert_eq!(v["rebuilds"], json!([]), "no rebuilds on a fresh db");
-        assert!(obj.contains_key("db_path"), "golden carries db_path");
-        assert!(obj.contains_key("would_backup_path"), "golden carries would_backup_path");
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+// ── fix_schema: golden fix_schema_layout diagnosis envelope (schema_migration.py:258) ─────────────
+// {ok,status,db_path,schema_version,user_version,layout_diffs,recommended_action,would_backup_path,
+// fixed,rebuilds}. RUST mod.rs:538-540 stub {ok,fixed:false}. db_path/would_backup_path are
+// path/clock-derived; lock the deterministic fields. SCHEMA_VERSION==3. RED. ─────────────────────
+#[test]
+fn fix_schema_golden_layout_diagnosis_envelope() {
+    let ws = tmp_workspace();
+    let v = diagnose_port::fix_schema(&ws).expect("fix_schema");
+    let obj = v.as_object().expect("fix_schema dict");
+    assert_eq!(v["status"], json!("missing"), "missing db: status missing");
+    assert_eq!(
+        v["schema_version"],
+        json!(3),
+        "golden schema_version == SCHEMA_VERSION (3)"
+    );
+    assert_eq!(v["user_version"], json!(0), "missing db user_version == 0");
+    assert_eq!(
+        v["layout_diffs"],
+        json!([]),
+        "missing db => empty layout_diffs list"
+    );
+    assert_eq!(
+        v["recommended_action"],
+        json!("none"),
+        "no drift => recommended_action 'none'"
+    );
+    assert_eq!(
+        v["fixed"],
+        json!(false),
+        "missing db is diagnostic-only and does not create a db"
+    );
+    assert_eq!(v["rebuilds"], json!([]), "no rebuilds on a fresh db");
+    assert!(obj.contains_key("db_path"), "golden carries db_path");
+    assert!(
+        obj.contains_key("would_backup_path"),
+        "golden carries would_backup_path"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
 
-    // ── doctor: golden checks dict (diagnose/health.py:179-241) — tmux/workspace/workspace_is_git_repo/
-    // providers/mcp/coordinator/ok. RUST mod.rs:520-522 stub {ok,spec,blockers}. Lock the golden
-    // top-level keys (values are machine-derived) + absence of the stub's spec/blockers. RED. ─────────
-    #[test]
-    fn doctor_golden_checks_shape_not_spec_blockers_stub() {
-        let ws = tmp_workspace();
-        let v = diagnose_port::doctor(&ws, None).expect("doctor");
-        let obj = v.as_object().expect("doctor dict");
-        let tmux = v["tmux"].as_object().expect("golden doctor.tmux is a dict {installed,path}");
-        assert!(tmux.contains_key("installed") && tmux.contains_key("path"), "tmux check shape");
-        assert!(v["workspace"].is_string(), "golden doctor.workspace is a string path");
-        assert!(v["workspace_is_git_repo"].is_boolean(), "golden doctor.workspace_is_git_repo bool");
-        assert!(v["providers"].is_object(), "golden doctor.providers is a dict");
-        assert_eq!(
-            v["mcp"]["local_module"],
-            json!(true),
-            "golden doctor.mcp.local_module == true (health.py:197-200)"
-        );
-        assert!(v["coordinator"].is_object(), "golden doctor.coordinator is the coordinator_health dict");
-        assert!(!obj.contains_key("spec"), "golden doctor has NO `spec` key (Rust stub adds it)");
-        assert!(!obj.contains_key("blockers"), "golden doctor has NO `blockers` key (Rust stub adds it)");
-        let _ = std::fs::remove_dir_all(&ws);
-    }
+// ── doctor: golden checks dict (diagnose/health.py:179-241) — tmux/workspace/workspace_is_git_repo/
+// providers/mcp/coordinator/ok. RUST mod.rs:520-522 stub {ok,spec,blockers}. Lock the golden
+// top-level keys (values are machine-derived) + absence of the stub's spec/blockers. RED. ─────────
+#[test]
+fn doctor_golden_checks_shape_not_spec_blockers_stub() {
+    let ws = tmp_workspace();
+    let v = diagnose_port::doctor(&ws, None).expect("doctor");
+    let obj = v.as_object().expect("doctor dict");
+    let tmux = v["tmux"]
+        .as_object()
+        .expect("golden doctor.tmux is a dict {installed,path}");
+    assert!(
+        tmux.contains_key("installed") && tmux.contains_key("path"),
+        "tmux check shape"
+    );
+    assert!(
+        v["workspace"].is_string(),
+        "golden doctor.workspace is a string path"
+    );
+    assert!(
+        v["workspace_is_git_repo"].is_boolean(),
+        "golden doctor.workspace_is_git_repo bool"
+    );
+    assert!(
+        v["providers"].is_object(),
+        "golden doctor.providers is a dict"
+    );
+    assert_eq!(
+        v["mcp"]["local_module"],
+        json!(true),
+        "golden doctor.mcp.local_module == true (health.py:197-200)"
+    );
+    assert!(
+        v["coordinator"].is_object(),
+        "golden doctor.coordinator is the coordinator_health dict"
+    );
+    assert!(
+        !obj.contains_key("spec"),
+        "golden doctor has NO `spec` key (Rust stub adds it)"
+    );
+    assert!(
+        !obj.contains_key("blockers"),
+        "golden doctor has NO `blockers` key (Rust stub adds it)"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}