@team-agent/installer 0.2.10 → 0.3.0

package/crates/team-agent/src/provider/tests/classify.rs

@@ -0,0 +1,240 @@
+fn claude_end_turn() -> String {
+    r#"{"type":"assistant","requestId":"r1","message":{"stop_reason":"end_turn"}}"#.to_string()
+}
+fn claude_open_turn() -> String {
+    r#"{"type":"assistant","requestId":"r1","message":{"stop_reason":"tool_use"}}"#.to_string()
+}
+
+#[test]
+fn classify_empty_text_is_unknown_never_idle() {
+    // probe empty_text: state=unknown turn_id=None reason=unreadable_or_empty
+    // source=session_file. BLOOD-LINE: unknown is NEVER idle (bug-071/077/085).
+    let c = classify(Provider::ClaudeCode, "", ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Unknown);
+    assert_eq!(c.reason, "unreadable_or_empty");
+    assert_eq!(c.turn_id, None);
+    assert_eq!(c.source, ClassifySource::SessionFile);
+    // The pin the audit demands: classify(unreadable) MUST NOT be treatable as idle.
+    assert!(
+        !c.state.is_idle_for_takeover(),
+        "unreadable/empty input must never be idle (C5)"
+    );
+}
+
+#[test]
+fn classify_whitespace_only_is_unknown() {
+    // probe whitespace_only → unknown / unreadable_or_empty.
+    let c = classify(Provider::Claude, "   \n  \t \n", ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Unknown);
+    assert_eq!(c.reason, "unreadable_or_empty");
+    assert!(!c.state.is_idle_for_takeover());
+}
+
+#[test]
+fn classify_garbage_jsonl_is_unknown_not_idle() {
+    // probe garbage_jsonl ("not json\n{broken"): parse yields diagnostics but
+    // had_records=false → reason=unreadable_or_empty (the !had_records branch
+    // wins over diagnostics; common.py:72-75). NEVER idle.
+    let c = classify(Provider::Claude, "not json\n{broken", ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Unknown);
+    assert_eq!(c.reason, "unreadable_or_empty");
+    assert!(!c.state.is_idle_for_takeover());
+}
+
+#[test]
+fn classify_unrecognized_format_is_unknown() {
+    // probe '{"foo":"bar"}': had_records=true, no lifecycle fact, NO diagnostics
+    // → reason=no_turn_lifecycle_fact (NOT unrecognized_format — golden-confirmed).
+    let c = classify(Provider::Claude, r#"{"foo":"bar"}"#, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Unknown);
+    assert_eq!(c.reason, "no_turn_lifecycle_fact");
+    assert!(!c.state.is_idle_for_takeover());
+}
+
+#[test]
+fn classify_claude_code_alias_normalizes_to_claude_reader() {
+    // 陷阱 #4: claude_code → claude reader (__init__.py:88). Both must classify an
+    // end_turn transcript identically to idle / end_turn — the alias never dies.
+    let txt = claude_end_turn();
+    let alias = classify(Provider::ClaudeCode, &txt, ProcessLiveness::Unverifiable, 0.0)
+        .expect("alias ok");
+    let canon = classify(Provider::Claude, &txt, ProcessLiveness::Unverifiable, 0.0)
+        .expect("canon ok");
+    assert_eq!(alias.state, TurnState::Idle);
+    assert_eq!(alias.reason, "end_turn");
+    assert_eq!(alias, canon, "claude_code must normalize to the claude reader");
+}
+
+#[test]
+fn classify_open_turn_with_no_process_is_unknown_not_working() {
+    // probe open_turn_process_none: open turn + Unverifiable (None process) →
+    // unknown / process_identity_unverified / source=process_guard, turn_id=r1.
+    // C4: missing identity is NEVER optimistically working.
+    let c = classify(Provider::Claude, &claude_open_turn(), ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Unknown);
+    assert_eq!(c.reason, "process_identity_unverified");
+    assert_eq!(c.source, ClassifySource::ProcessGuard);
+    assert_eq!(c.turn_id, Some(TurnId::new("r1")));
+    assert!(!c.state.is_idle_for_takeover());
+}
+
+#[test]
+fn classify_open_turn_alive_is_working() {
+    // probe open_turn_alive: open turn + Alive → working / open_turn / source=session_file.
+    let c = classify(Provider::Claude, &claude_open_turn(), ProcessLiveness::Alive, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Working);
+    assert_eq!(c.reason, "open_turn");
+    assert_eq!(c.source, ClassifySource::SessionFile);
+    assert_eq!(c.turn_id, Some(TurnId::new("r1")));
+}
+
+#[test]
+fn classify_open_turn_dead_is_abnormal_crashed_mid_turn() {
+    // probe open_turn_dead: open turn + Dead → abnormal / crashed_mid_turn /
+    // source=process_guard, annotations contains "crashed_mid_turn".
+    let c = classify(Provider::Claude, &claude_open_turn(), ProcessLiveness::Dead, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Abnormal);
+    assert_eq!(c.reason, "crashed_mid_turn");
+    assert_eq!(c.source, ClassifySource::ProcessGuard);
+    assert!(c.annotations.contains(&"crashed_mid_turn".to_string()));
+}
+
+#[test]
+fn classify_open_turn_unverifiable_process_is_unknown() {
+    // probe open_turn_unverifiable: open turn + Unverifiable →
+    // unknown / process_identity_unverified (NOT working). NEVER idle.
+    let c = classify(Provider::Claude, &claude_open_turn(), ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Unknown);
+    assert_eq!(c.reason, "process_identity_unverified");
+    assert!(!c.state.is_idle_for_takeover());
+}
+
+#[test]
+fn classify_last_lifecycle_fact_wins() {
+    // probe last_fact_wins_complete (tool_use 'a' then end_turn 'b') →
+    // idle / end_turn, turn_id = the LAST lifecycle fact's id ("b").
+    let two = format!(
+        "{}\n{}",
+        r#"{"type":"assistant","requestId":"a","message":{"stop_reason":"tool_use"}}"#,
+        r#"{"type":"assistant","requestId":"b","message":{"stop_reason":"end_turn"}}"#,
+    );
+    let c = classify(Provider::Claude, &two, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Idle);
+    assert_eq!(c.reason, "end_turn");
+    assert_eq!(c.turn_id, Some(TurnId::new("b")));
+}
+
+#[test]
+fn classify_c14_open_turn_beats_silence() {
+    // probe c14_open_after_complete_alive (end_turn 'a' then tool_use 'b', alive,
+    // file_silence=9999) → working / open_turn, turn_id="b". Silence is DISCARDED:
+    // only a dead process guard can demote an open turn (common.py:93-103, C14).
+    let c14 = format!(
+        "{}\n{}",
+        r#"{"type":"assistant","requestId":"a","message":{"stop_reason":"end_turn"}}"#,
+        r#"{"type":"assistant","requestId":"b","message":{"stop_reason":"tool_use"}}"#,
+    );
+    let c = classify(Provider::Claude, &c14, ProcessLiveness::Alive, 9999.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Working);
+    assert_eq!(c.reason, "open_turn");
+    assert_eq!(c.turn_id, Some(TurnId::new("b")));
+}
+
+#[test]
+fn classify_claude_interrupted_is_idle_interrupted_annotated() {
+    // probe claude_interrupted ("[Request interrupted by user]") →
+    // idle_interrupted / user_interrupt / annotations=["interrupted"], turn_id=u1.
+    let txt = r#"{"type":"user","uuid":"u1","message":{"content":[{"type":"text","text":"[Request interrupted by user]"}]}}"#;
+    let c = classify(Provider::Claude, txt, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::IdleInterrupted);
+    assert_eq!(c.reason, "user_interrupt");
+    assert_eq!(c.annotations, vec!["interrupted".to_string()]);
+    assert_eq!(c.turn_id, Some(TurnId::new("u1")));
+    // C12: idle_interrupted IS idle for take-over (annotated).
+    assert!(c.state.is_idle_for_takeover());
+}
+
+#[test]
+fn classify_claude_stop_sequence_is_idle() {
+    // probe claude_stop_sequence → idle / stop_sequence.
+    let txt = r#"{"type":"assistant","requestId":"r1","message":{"stop_reason":"stop_sequence"}}"#;
+    let c = classify(Provider::Claude, txt, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Idle);
+    assert_eq!(c.reason, "stop_sequence");
+}
+
+#[test]
+fn classify_codex_task_complete_is_idle() {
+    // probe codex_task_complete → idle / task_complete, turn_id from payload (ct1).
+    let txt = r#"{"type":"event_msg","payload":{"type":"task_complete","turn_id":"ct1"}}"#;
+    let c = classify(Provider::Codex, txt, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Idle);
+    assert_eq!(c.reason, "task_complete");
+    assert_eq!(c.turn_id, Some(TurnId::new("ct1")));
+}
+
+#[test]
+fn classify_codex_turn_aborted_interrupted_is_idle_interrupted() {
+    // probe codex_turn_aborted_interrupted → idle_interrupted / interrupted.
+    let interrupted = r#"{"type":"event_msg","payload":{"type":"turn_aborted","turn_id":"ct2","reason":"interrupted"}}"#;
+    let c = classify(Provider::Codex, interrupted, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::IdleInterrupted);
+    assert_eq!(c.reason, "interrupted");
+    // probe codex_turn_aborted_other (reason="error") → idle_interrupted with the
+    // RAW reason string passed through ("error"), turn_id=ct3.
+    let other = r#"{"type":"event_msg","payload":{"type":"turn_aborted","turn_id":"ct3","reason":"error"}}"#;
+    let c2 = classify(Provider::Codex, other, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c2.state, TurnState::IdleInterrupted);
+    assert_eq!(c2.reason, "error", "raw abort reason must pass through");
+    assert_eq!(c2.turn_id, Some(TurnId::new("ct3")));
+}
+
+#[test]
+fn classify_codex_appserver_failed_is_abnormal() {
+    // probe codex_appserver_failed (turn.status==failed) → abnormal / turn_failed /
+    // annotations=["turn_failed"], source=session_file, turn_id=ct4.
+    let txt = r#"{"jsonrpc":"2.0","method":"turn/completed","params":{"turn":{"id":"ct4","status":"failed"}}}"#;
+    let c = classify(Provider::Codex, txt, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::Abnormal);
+    assert_eq!(c.reason, "turn_failed");
+    assert_eq!(c.annotations, vec!["turn_failed".to_string()]);
+    assert_eq!(c.turn_id, Some(TurnId::new("ct4")));
+    assert!(!c.state.is_idle_for_takeover());
+}
+
+#[test]
+fn classify_codex_appserver_approval_is_blocked_on_human() {
+    // probe codex_appserver_approval (method endswith requestApproval) →
+    // blocked_on_human / approval_required / annotations=["awaiting_approval"], turn_id=ct5.
+    let txt = r#"{"jsonrpc":"2.0","method":"session/requestApproval","params":{"turnId":"ct5"}}"#;
+    let c = classify(Provider::Codex, txt, ProcessLiveness::Unverifiable, 0.0)
+        .expect("classify ok");
+    assert_eq!(c.state, TurnState::BlockedOnHuman);
+    assert_eq!(c.reason, "approval_required");
+    assert_eq!(c.annotations, vec!["awaiting_approval".to_string()]);
+    assert_eq!(c.turn_id, Some(TurnId::new("ct5")));
+    // blocked_on_human is NOT idle for take-over.
+    assert!(!c.state.is_idle_for_takeover());
+}
+
+// ---- (b) idle predicate / evaluate_takeover_reminder (NoPingReason cases) ----
+//
+// Golden via /tmp/probe_idle.py (idle_predicate.evaluate_takeover_reminder).
+// Nodes / monitor_state passed as serde_json::Value dicts (Python dict shape).
+

package/crates/team-agent/src/provider/tests/faults.rs

@@ -0,0 +1,120 @@
+fn line(v: serde_json::Value) -> String {
+    v.to_string()
+}
+
+// P0 — interrupt marker must match EXACTLY (provider_state/claude.py:75 `== _INTERRUPT_TEXT`),
+// not `.contains()`. A transcript that merely QUOTES the marker must stay Unknown
+// (ping-blocked); only the exact text is idle-eligible IdleInterrupted. §11 wrong-direction.
+#[test]
+fn p2_claude_interrupt_requires_exact_marker_text() {
+    let quote = classify(
+        Provider::ClaudeCode,
+        &line(serde_json::json!({"type":"user","uuid":"u1","message":{"content":[
+            {"type":"text","text":"prefix [Request interrupted by user] suffix"}]}})),
+        ProcessLiveness::Alive,
+        0.0,
+    )
+    .unwrap();
+    assert_eq!(quote.state, TurnState::Unknown, "merely quoting the marker must NOT be idle-eligible");
+    assert_eq!(quote.reason, "no_turn_lifecycle_fact");
+
+    let exact = classify(
+        Provider::ClaudeCode,
+        &line(serde_json::json!({"type":"user","uuid":"u1","message":{"content":[
+            {"type":"text","text":"[Request interrupted by user]"}]}})),
+        ProcessLiveness::Alive,
+        0.0,
+    )
+    .unwrap();
+    assert_eq!(exact.state, TurnState::IdleInterrupted);
+    assert_eq!(exact.turn_id.as_ref().map(TurnId::as_str), Some("u1"));
+}
+
+// P1 — claude api_error fault requires level=="error" (claude.py:54). Missing/other
+// level → NO fault (Python count 0).
+#[test]
+fn p2_claude_api_error_fault_requires_level_error() {
+    let no_level = vec![serde_json::json!({"type":"system","subtype":"api_error","sessionId":"s-1"})];
+    assert!(read_fault_facts(&no_level, Provider::ClaudeCode).is_empty(), "api_error w/o level=error is not a fault");
+    let warn = vec![serde_json::json!({"type":"system","subtype":"api_error","level":"warning","sessionId":"s-1"})];
+    assert!(read_fault_facts(&warn, Provider::ClaudeCode).is_empty(), "level=warning is not a fault");
+
+    let err = vec![serde_json::json!({"type":"system","subtype":"api_error","level":"error","sessionId":"s-1"})];
+    let facts = read_fault_facts(&err, Provider::ClaudeCode);
+    assert_eq!(facts.len(), 1);
+    assert_eq!(facts[0].signature.as_str(), "api_error");
+    assert_eq!(facts[0].turn_id.as_ref().map(TurnId::as_str), Some("s-1"));
+}
+
+// P1 — claude api_error turn_id fallback chain = sessionId -> parentUuid -> uuid
+// (claude.py:58), NOT sessionId -> requestId. Collapsing to None breaks C8 dedup.
+#[test]
+fn p2_claude_api_error_turn_id_fallback_parentuuid_then_uuid() {
+    let pu = vec![serde_json::json!({"type":"system","subtype":"api_error","level":"error","parentUuid":"pu-1"})];
+    let f = read_fault_facts(&pu, Provider::ClaudeCode);
+    assert_eq!(f.len(), 1);
+    assert_eq!(f[0].turn_id.as_ref().map(TurnId::as_str), Some("pu-1"), "parentUuid is in the chain (requestId is not)");
+
+    let uu = vec![serde_json::json!({"type":"system","subtype":"api_error","level":"error","uuid":"uu-1"})];
+    let f2 = read_fault_facts(&uu, Provider::ClaudeCode);
+    assert_eq!(f2.len(), 1);
+    assert_eq!(f2[0].turn_id.as_ref().map(TurnId::as_str), Some("uu-1"));
+}
+
+// P1 — codex requestApproval turn_id = params.turnId OR params.turn_id (codex.py:79).
+#[test]
+fn p2_codex_approval_turn_id_accepts_snake_case() {
+    let snake = vec![serde_json::json!({"jsonrpc":"2.0","method":"session/requestApproval","params":{"turn_id":"snake1"}})];
+    let f = read_fault_facts(&snake, Provider::Codex);
+    assert_eq!(f.len(), 1);
+    assert_eq!(f[0].turn_id.as_ref().map(TurnId::as_str), Some("snake1"), "snake-case turn_id must be honored");
+}
+
+// P1 — codex app-server turn/completed status completed/interrupted/inProgress map to
+// idle/idle_interrupted/working (codex.py:69-74), not Unknown.
+#[test]
+fn p2_codex_app_server_status_completed_interrupted_in_progress() {
+    let app = |status: &str| {
+        line(serde_json::json!({"jsonrpc":"2.0","method":"turn/completed","params":{"turn":{"id":"t1","status":status}}}))
+    };
+    let c = classify(Provider::Codex, &app("completed"), ProcessLiveness::Alive, 0.0).unwrap();
+    assert_eq!((c.state, c.reason.as_str()), (TurnState::Idle, "completed"));
+    assert_eq!(c.turn_id.as_ref().map(TurnId::as_str), Some("t1"));
+
+    let i = classify(Provider::Codex, &app("interrupted"), ProcessLiveness::Alive, 0.0).unwrap();
+    assert_eq!((i.state, i.reason.as_str()), (TurnState::IdleInterrupted, "interrupted"));
+
+    let p = classify(Provider::Codex, &app("inProgress"), ProcessLiveness::Alive, 0.0).unwrap();
+    assert_eq!((p.state, p.reason.as_str()), (TurnState::Working, "open_turn"));
+    assert_eq!(p.turn_id.as_ref().map(TurnId::as_str), Some("t1"));
+}
+
+// P1 — codex event_msg task_started → open turn → working(alive) (codex.py:30-31).
+#[test]
+fn p2_codex_event_msg_task_started_is_open_turn() {
+    let txt = line(serde_json::json!({"type":"event_msg","payload":{"type":"task_started","turn_id":"ts1"}}));
+    let r = classify(Provider::Codex, &txt, ProcessLiveness::Alive, 0.0).unwrap();
+    assert_eq!((r.state, r.reason.as_str()), (TurnState::Working, "open_turn"));
+    assert_eq!(r.turn_id.as_ref().map(TurnId::as_str), Some("ts1"));
+}
+
+// SPAWN+FAKE-WORKER RED — Provider::Fake::build_command must invoke the fake-worker backing program
+// (the single-binary `fake-worker` subcommand), NOT the bare placeholder vec!["fake"] (no backing
+// binary). This is what makes launch(dry_run=false)'s spawn path exercisable with NO subscription
+// provider. Golden intent: fake_worker.py + provider_cli/fake.py — a subscription-free backing worker.
+#[test]
+fn fake_build_command_invokes_fake_worker_not_bare_fake() {
+    let adapter = get_adapter(Provider::Fake);
+    let argv = adapter
+        .build_command(AuthMode::Subscription, None, None, None)
+        .expect("fake build_command");
+    assert_ne!(
+        argv,
+        vec!["fake".to_string()],
+        "Provider::Fake::build_command must not be the bare placeholder vec![\"fake\"] (no backing binary)"
+    );
+    assert!(
+        argv.iter().any(|a| a == "fake-worker"),
+        "Provider::Fake::build_command must invoke the `fake-worker` subcommand so the spawn path runs the fake backing worker; got {argv:?}"
+    );
+}

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

@@ -0,0 +1,208 @@
+fn node(id: &str, role: &str, state: &str) -> serde_json::Value {
+    serde_json::json!({"node_id": id, "role": role, "state": state})
+}
+
+#[test]
+fn idle_any_non_idle_node_blocks_ping_with_node_reason() {
+    // probe: working → node_working, unknown → node_unknown,
+    // blocked_on_human → node_blocked_on_human, abnormal → node_abnormal,
+    // missing-state → node_unknown. should_ping=False every time.
+    // BLOOD-LINE: Unknown node blocks the ping via NoPingReason::Node(Unknown).
+    for (state, expect) in [
+        ("working", NoPingReason::Node(TurnState::Working)),
+        ("unknown", NoPingReason::Node(TurnState::Unknown)),
+        ("blocked_on_human", NoPingReason::Node(TurnState::BlockedOnHuman)),
+        ("abnormal", NoPingReason::Node(TurnState::Abnormal)),
+    ] {
+        let r = evaluate_takeover_reminder(&[node("w1", "worker", state)], None, 100.0, 60.0)
+            .expect("evaluate ok");
+        assert!(!r.should_ping, "{state} node must block ping");
+        assert_eq!(r.reason, expect, "{state} → {}", expect.reason_str());
+    }
+    // The exact `node_<state>` wire strings the Python `_result` emits.
+    assert_eq!(NoPingReason::Node(TurnState::Working).reason_str(), "node_working");
+    assert_eq!(NoPingReason::Node(TurnState::Unknown).reason_str(), "node_unknown");
+    assert_eq!(
+        NoPingReason::Node(TurnState::BlockedOnHuman).reason_str(),
+        "node_blocked_on_human"
+    );
+    assert_eq!(NoPingReason::Node(TurnState::Abnormal).reason_str(), "node_abnormal");
+    // missing-state node → node_unknown (state defaults to unknown, idle_predicate.py:49).
+    let missing = serde_json::json!({"node_id": "w1", "role": "worker"});
+    let r = evaluate_takeover_reminder(&[missing], None, 100.0, 60.0).expect("evaluate ok");
+    assert!(!r.should_ping);
+    assert_eq!(r.reason, NoPingReason::Node(TurnState::Unknown));
+}
+
+#[test]
+fn idle_all_idle_but_not_armed_blocks() {
+    // probe all_idle_not_armed → should_ping=False, reason=not_armed_no_worker_turn.
+    // Worker idle alone never arms; only a DELEGATED state arms the watch (C1).
+    let r = evaluate_takeover_reminder(&[node("w1", "worker", "idle")], None, 100.0, 60.0)
+        .expect("evaluate ok");
+    assert!(!r.should_ping);
+    assert_eq!(r.reason, NoPingReason::NotArmedNoWorkerTurn);
+}
+
+#[test]
+fn idle_armed_debounce_active_then_ping() {
+    // probe armed_debounce_active (all_idle_since=100, now=130, debounce=60,
+    // elapsed=30 < 60) → should_ping=False, reason=debounce_active.
+    let ms = serde_json::json!({
+        "opened_worker_turn_since_ack": true,
+        "all_idle_since": 100.0,
+        "pinged_for_episode": serde_json::Value::Null
+    });
+    let active = evaluate_takeover_reminder(&[node("w1", "worker", "idle")], Some(&ms), 130.0, 60.0)
+        .expect("evaluate ok");
+    assert!(!active.should_ping);
+    assert_eq!(active.reason, NoPingReason::DebounceActive);
+    // probe armed_debounce_elapsed (now=160, elapsed=60 >= 60) →
+    // should_ping=True, reason=all_idle_debounce_elapsed.
+    let elapsed = evaluate_takeover_reminder(&[node("w1", "worker", "idle")], Some(&ms), 160.0, 60.0)
+        .expect("evaluate ok");
+    assert!(elapsed.should_ping, "ping must fire at/after debounce");
+    assert_eq!(elapsed.reason, NoPingReason::AllIdleDebounceElapsed);
+    assert!(elapsed.message.is_some(), "ping carries the stored neutral message");
+}
+
+#[test]
+fn idle_suppressed_is_acknowledged_and_already_pinged_guard() {
+    // probe armed_suppressed_acknowledged → should_ping=False, reason=acknowledged.
+    let supp = serde_json::json!({
+        "opened_worker_turn_since_ack": true,
+        "suppressed": true,
+        "all_idle_since": 100.0
+    });
+    let r = evaluate_takeover_reminder(&[node("w1", "worker", "idle")], Some(&supp), 200.0, 60.0)
+        .expect("evaluate ok");
+    assert!(!r.should_ping);
+    assert_eq!(r.reason, NoPingReason::Acknowledged);
+    // probe already_pinged_this_episode (pinged_for_episode == all_idle_since) →
+    // should_ping=False, reason=already_pinged_this_episode.
+    let pinged = serde_json::json!({
+        "opened_worker_turn_since_ack": true,
+        "all_idle_since": 100.0,
+        "pinged_for_episode": 100.0
+    });
+    let r2 = evaluate_takeover_reminder(&[node("w1", "worker", "idle")], Some(&pinged), 200.0, 60.0)
+        .expect("evaluate ok");
+    assert!(!r2.should_ping);
+    assert_eq!(r2.reason, NoPingReason::AlreadyPingedThisEpisode);
+}
+
+#[test]
+fn idle_interrupted_counts_as_idle_and_appears_in_interrupted_nodes() {
+    // probe interrupted_counts_idle_ping → should_ping=True AND
+    // interrupted_nodes=["w1"] (C12: idle_interrupted is idle but annotated).
+    let armed = serde_json::json!({
+        "opened_worker_turn_since_ack": true,
+        "all_idle_since": 100.0,
+        "pinged_for_episode": serde_json::Value::Null
+    });
+    let r = evaluate_takeover_reminder(
+        &[node("w1", "worker", "idle_interrupted")],
+        Some(&armed),
+        200.0,
+        60.0,
+    )
+    .expect("evaluate ok");
+    assert!(r.should_ping);
+    assert_eq!(r.reason, NoPingReason::AllIdleDebounceElapsed);
+    assert_eq!(r.interrupted_nodes, vec!["w1".to_string()]);
+}
+
+#[test]
+fn idle_leader_activity_never_arms_but_leader_idle_allows_ping() {
+    // probe leader_working_does_not_arm: leader-only working never arms; the
+    // working node still BLOCKS the ping → reason=node_working, should_ping=False.
+    let r = evaluate_takeover_reminder(&[node("leader", "leader", "working")], None, 100.0, 60.0)
+        .expect("evaluate ok");
+    assert!(!r.should_ping);
+    assert_eq!(r.reason, NoPingReason::Node(TurnState::Working));
+    // probe leader_and_worker_idle_armed_ping: once a WORKER opened a turn the
+    // watch is armed; leader+worker both idle past debounce → should_ping=True.
+    let armed = serde_json::json!({
+        "opened_worker_turn_since_ack": true,
+        "all_idle_since": 100.0,
+        "pinged_for_episode": serde_json::Value::Null
+    });
+    let nodes = [node("leader", "leader", "idle"), node("w1", "worker", "idle")];
+    let r2 = evaluate_takeover_reminder(&nodes, Some(&armed), 200.0, 60.0).expect("evaluate ok");
+    assert!(r2.should_ping);
+    assert_eq!(r2.reason, NoPingReason::AllIdleDebounceElapsed);
+}
+
+// ---- (c) trust-prompt recognizer (REAL fixtures, own-vs-foreign) ----
+//
+// NOTE: the own-vs-foreign trust recognizer lives in messaging/leader_panes.py
+// (step 9/10 owns it per card §42). The provider.rs skeleton exposes only
+// `status_patterns()` (idle/processing/trust regex set) — driven RED below.
+// Full own-vs-foreign realpath judgement + truncated-workspace logic deferred.
+
+// Real fixtures (mirrored into the rust workspace from team-agent-public).
+const CLAUDE_IDLE_FIXTURE: &str = include_str!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/../../snapshot/fixtures/idle_prompts/claude_code_idle.txt"
+));
+const CODEX_IDLE_FIXTURE: &str = include_str!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/../../snapshot/fixtures/idle_prompts/codex_idle.txt"
+));
+const CODEX_WORKING_FIXTURE: &str = include_str!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/../../snapshot/fixtures/idle_prompts/codex_working.txt"
+));
+
+fn fixture_matches(re: &regex::Regex, fixture: &str) -> bool {
+    fixture.lines().any(|l| re.is_match(l))
+}
+
+#[test]
+fn claude_status_patterns_compile() {
+    // provider_cli/claude.py:225 status_patterns idle=r"[>❯]\s".
+    // The real fixture has prompt lines like "❯ /compact" → idle MUST match.
+    // The processing pattern r"[✶✢✽✻✳·].*…" must NOT match those idle prompt lines.
+    let adapter = get_adapter(Provider::ClaudeCode);
+    let pats = adapter.status_patterns().expect("status_patterns ok");
+    assert!(
+        fixture_matches(&pats.idle, CLAUDE_IDLE_FIXTURE),
+        "claude idle pattern must match a '❯ ' prompt line in the idle fixture"
+    );
+    assert!(
+        pats.idle.is_match("❯ /compact"),
+        "claude idle pattern matches the canonical prompt line"
+    );
+    assert!(
+        !pats.processing.is_match("❯ /compact"),
+        "claude processing pattern must NOT match an idle prompt line"
+    );
+}
+
+#[test]
+fn codex_status_patterns_compile() {
+    // provider_cli/codex.py:140 idle=r"(›|❯|codex>)" processing=r"•.*esc to interrupt".
+    // codex_idle.txt has a "› Find and fix a bug…" prompt → idle matches.
+    // codex_working.txt has a "• …esc to interrupt" spinner → processing matches.
+    let adapter = get_adapter(Provider::Codex);
+    let pats = adapter.status_patterns().expect("status_patterns ok");
+    assert!(
+        fixture_matches(&pats.idle, CODEX_IDLE_FIXTURE),
+        "codex idle pattern must match a '›' prompt line"
+    );
+    assert!(
+        CODEX_WORKING_FIXTURE.lines().any(|l| pats.processing.is_match(l)),
+        "codex processing pattern must match the 'esc to interrupt' spinner"
+    );
+    // The discriminator: a pure working-status footer line carries no prompt char.
+    assert!(
+        !pats.idle.is_match("  gpt-5.5 medium · /private/tmp/working"),
+        "codex idle pattern must NOT match a bare status footer"
+    );
+}
+
+// ---- (d) abnormal dedup key (signature, Option<TurnId>) ----
+//
+// NOTE: read_fault_facts lives in provider_state; not on the skeleton trait.
+// Golden dedup keys recorded below; flagged deferred for the fault-facts entry.
+