@team-agent/installer 0.2.11 → 0.3.1

package/crates/team-agent/src/coordinator/orphan.rs

@@ -0,0 +1,179 @@
+//! 孤儿自终止判定(Gap 37b)+ provider-neutral 异常轨(abnormal_track:整队消失检测 + 去重通知)。
+
+use std::hash::{Hash, Hasher};
+
+use serde_json::Value;
+
+use crate::model::enums::Provider;
+use crate::provider::{ProcessLiveness, Signature, TurnId, TurnState};
+
+use super::types::{
+    AbnormalDecision, AbnormalError, AbnormalNotification, AbnormalNotificationState,
+    AbnormalProcessOutput, MarkerStore, ProviderRegistry, TeamPresenceSnapshot, WholeTeamGoneClass,
+    WholeTeamGoneReport, WorkspacePath,
+};
+
+/// 孤儿自终止判定(`__main__.py:51-59`,Gap 37b)。仅当
+/// `current_ppid != initial_ppid ∧ current_ppid == 1 ∧ !workspace.exists()` 三者**同时**成立 → true。
+/// 少一个条件都不能误杀正常 daemon(card §91)。
+pub fn should_orphan_self_terminate(
+    initial_ppid: u32,
+    current_ppid: u32,
+    workspace: &WorkspacePath,
+) -> bool {
+    current_ppid != initial_ppid && current_ppid == 1 && !workspace.as_path().exists()
+}
+
+// ===========================================================================
+// abnormal_track 公共面(abnormal_track.py)—— Gap 32 §4 provider-neutral
+// ===========================================================================
+
+/// #236 dedicated `worker.abnormal_exit` surface.
+///
+/// This is intentionally separate from `process_abnormal_records`: the generic
+/// abnormal path is transcript-only, while `worker.abnormal_exit` requires the
+/// provider-process-dead AND latest-explicit-error gate before leader notification.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "event")]
+pub enum WorkerAbnormalExitSurface {
+    #[serde(rename = "worker.abnormal_exit")]
+    WorkerAbnormalExit {
+        agent_id: String,
+        provider: Provider,
+        path: String,
+        provider_process_dead: bool,
+        latest_explicit_error: bool,
+        signature: Signature,
+        turn_id: Option<TurnId>,
+        process_liveness: ProcessLiveness,
+    },
+    #[serde(rename = "abnormal_exit.single_signal_suppressed")]
+    SingleSignalSuppressed {
+        agent_id: String,
+        provider: Provider,
+        path: String,
+        provider_process_dead: bool,
+        latest_explicit_error: bool,
+        reason: String,
+    },
+}
+
+/// `process_abnormal_records`(`abnormal_track.py:14`)。把原始 provider session records 经
+/// provider reader 翻译成结构化 fault facts(本 module **不命名 provider、不读屏**),catch-bias
+/// (C9)+ `(signature, turn_id|fingerprint)` 去重(C8)。`registry` 携带 provider + 黑白名单。
+pub fn process_abnormal_records(
+    records: &[Value],
+    registry: &dyn ProviderRegistry,
+    provider: Provider,
+    notification_state: &AbnormalNotificationState,
+) -> Result<AbnormalProcessOutput, AbnormalError> {
+    let lists = registry.error_lists(provider);
+    let mut state = notification_state.clone();
+    let mut notifications = Vec::new();
+    for record in records {
+        let raw = record
+            .get("raw")
+            .and_then(Value::as_str)
+            .unwrap_or_else(|| record.as_str().unwrap_or(""))
+            .to_string();
+        let signature = record
+            .get("signature")
+            .and_then(Value::as_str)
+            .unwrap_or("unknown")
+            .to_string();
+        let signature_lower = signature.to_lowercase();
+        let turn_id = record.get("turn_id").and_then(Value::as_str).map(TurnId::new);
+        let bucket = match &turn_id {
+            Some(id) => id.as_str().to_string(),
+            None => stable_fingerprint(record),
+        };
+        let key = format!("{signature}\0{bucket}");
+        if state.seen.contains(&key) {
+            continue;
+        }
+        state.seen.insert(key);
+        if lists.whitelist.iter().any(|needle| raw.contains(needle)) {
+            continue;
+        }
+        let decision = if lists.blacklist.iter().any(|needle| {
+            raw.contains(needle) || signature_lower.contains(&needle.to_lowercase())
+        }) {
+            AbnormalDecision::NotifyBlacklist
+        } else {
+            AbnormalDecision::NotifyDefault
+        };
+        let kind = record.get("kind").and_then(Value::as_str);
+        notifications.push(AbnormalNotification {
+            signature,
+            turn_id,
+            state: if kind == Some("approval") {
+                TurnState::BlockedOnHuman
+            } else {
+                TurnState::Abnormal
+            },
+            decision,
+            provider: Some(provider),
+            raw: record.clone(),
+        });
+    }
+    Ok(AbnormalProcessOutput {
+        notifications,
+        notification_state: state,
+    })
+}
+
+/// `detect_whole_team_gone`(`abnormal_track.py:91`,C10/C13)。coordinator-independent 整队消失检测:
+/// 全死(coordinator + leader + 所有 worker + 所有 session)且非 clean_shutdown/restart →
+/// 写 durable marker + 延迟到下条 leader 命令再 escalate。clean/restart 静默。
+pub fn detect_whole_team_gone(
+    snapshot: &TeamPresenceSnapshot,
+    marker_store: &mut dyn MarkerStore,
+) -> WholeTeamGoneReport {
+    let any_provider_alive = snapshot.provider_processes_alive.iter().any(|alive| *alive);
+    if snapshot.coordinator_alive
+        || snapshot.leader_alive
+        || any_provider_alive
+        || snapshot.tmux_sessions_present
+    {
+        return whole_team_report(false, WholeTeamGoneClass::Alive, false, false, false);
+    }
+    if snapshot.clean_shutdown {
+        return whole_team_report(true, WholeTeamGoneClass::CleanShutdown, false, false, false);
+    }
+    if snapshot.restart_in_progress {
+        return whole_team_report(true, WholeTeamGoneClass::RestartInProgress, false, false, false);
+    }
+    let marker_written = marker_store.set_marker(
+        "whole_team_gone",
+        serde_json::json!({"classification": "unexpected_exit"}),
+    );
+    whole_team_report(
+        true,
+        WholeTeamGoneClass::UnexpectedExit,
+        true,
+        true,
+        marker_written,
+    )
+}
+
+fn stable_fingerprint(value: &Value) -> String {
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    serde_json::to_string(value).unwrap_or_else(|_| value.to_string()).hash(&mut hasher);
+    format!("{:016x}", hasher.finish())
+}
+
+fn whole_team_report(
+    whole_team_gone: bool,
+    classification: WholeTeamGoneClass,
+    notify: bool,
+    escalate_user_on_next_leader_command: bool,
+    marker_written: bool,
+) -> WholeTeamGoneReport {
+    WholeTeamGoneReport {
+        whole_team_gone,
+        classification,
+        notify,
+        escalate_user_on_next_leader_command,
+        marker_written,
+    }
+}

package/crates/team-agent/src/coordinator/tests/abnormal.rs

@@ -0,0 +1,255 @@
+use super::*;
+
+// ═════════════════════════════════════════════════════════════════════════
+// GROUP E — abnormal_track classify / dedup (abnormal_track.py) — RED
+//   provider-neutral:断言 ZERO adapter_for 调用(MUST-NOT-13)。
+//   ASSUMPTION:传入 `records` 是 provider reader 已产出的结构化 fault facts
+//   ({signature, turn_id?, kind?, raw}),即 read_fault_facts 的输出形;abnormal_track
+//   只对它做 catch-bias + (signature, turn_id|fingerprint) 去重(error_lists 来自注入
+//   registry,绝不经 adapter_for 触碰 provider client)。
+// ═════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn abnormal_default_notify_for_structured_fault() {
+    // abnormal_track.py:204 — C9 catch-bias: 无黑白名单命中 → notify_default.
+    let reg = MockRegistry::new(&[], &[]);
+    let records = vec![serde_json::json!({"raw": "session line"})];
+    let out = process_abnormal_records(
+        &records,
+        &reg,
+        Provider::Codex,
+        &AbnormalNotificationState::default(),
+    )
+    .unwrap();
+    assert_eq!(out.notifications.len(), 1);
+    assert_eq!(out.notifications[0].decision, AbnormalDecision::NotifyDefault);
+    // §84:绝不触碰 provider adapter client。
+    assert_eq!(reg.adapter_calls.get(), 0, "MUST NOT call adapter_for (provider client)");
+}
+
+#[test]
+fn abnormal_blacklist_hit_yields_notify_blacklist() {
+    // abnormal_track.py:203 — blacklist 命中 → notify_blacklist.
+    let reg = MockRegistry::new(&[], &["boom"]);
+    let records = vec![serde_json::json!({"raw": "kaboom: boom happened"})];
+    let out = process_abnormal_records(
+        &records,
+        &reg,
+        Provider::Codex,
+        &AbnormalNotificationState::default(),
+    )
+    .unwrap();
+    assert_eq!(out.notifications.len(), 1);
+    assert_eq!(out.notifications[0].decision, AbnormalDecision::NotifyBlacklist);
+    assert_eq!(reg.adapter_calls.get(), 0);
+}
+
+#[test]
+fn abnormal_whitelist_beats_blacklist_and_skips() {
+    // abnormal_track.py:200-201 — whitelist > blacklist > default. 同命中 → skip, 0 notify.
+    let reg = MockRegistry::new(&["boom"], &["boom"]);
+    let records = vec![serde_json::json!({"raw": "boom transient"})];
+    let out = process_abnormal_records(
+        &records,
+        &reg,
+        Provider::Codex,
+        &AbnormalNotificationState::default(),
+    )
+    .unwrap();
+    assert_eq!(out.notifications.len(), 0, "whitelist wins → skip (probe confirmed)");
+    assert_eq!(reg.adapter_calls.get(), 0);
+}
+
+#[test]
+fn abnormal_approval_kind_maps_to_blocked_on_human() {
+    // abnormal_track.py:74 — kind=="approval" → state blocked_on_human, else abnormal.
+    let reg = MockRegistry::new(&[], &[]);
+    let records = vec![serde_json::json!({"raw": "approve?", "kind": "approval"})];
+    let out = process_abnormal_records(
+        &records,
+        &reg,
+        Provider::Codex,
+        &AbnormalNotificationState::default(),
+    )
+    .unwrap();
+    assert_eq!(out.notifications.len(), 1);
+    assert_eq!(out.notifications[0].state, TurnState::BlockedOnHuman);
+}
+
+#[test]
+fn abnormal_same_turn_id_folds_to_one_notification() {
+    // abnormal_track.py:60-68 — C8 dedup: same (signature, turn_id) → one notify.
+    let reg = MockRegistry::new(&[], &[]);
+    let records = vec![
+        serde_json::json!({"signature": "sig_a", "turn_id": "t1", "raw": "boom"}),
+        serde_json::json!({"signature": "sig_a", "turn_id": "t1", "raw": "boom"}),
+    ];
+    let out = process_abnormal_records(
+        &records,
+        &reg,
+        Provider::Codex,
+        &AbnormalNotificationState::default(),
+    )
+    .unwrap();
+    assert_eq!(out.notifications.len(), 1, "retry-loop in SAME turn folds (probe: 1)");
+    // seen 状态回存,key = "sig_a\0t1"。
+    assert!(out.notification_state.seen.contains("sig_a\u{0}t1"));
+}
+
+#[test]
+fn abnormal_missing_turn_id_distinct_faults_each_notify() {
+    // abnormal_track.py:64 — turn_id None → per-record content fingerprint bucket:
+    // 不同 fault 各自 notify(绝不折叠进全局桶,probe: 2)。
+    let reg = MockRegistry::new(&[], &[]);
+    let records = vec![
+        serde_json::json!({"signature": "sig_b", "raw": "alpha"}),
+        serde_json::json!({"signature": "sig_b", "raw": "beta"}),
+    ];
+    let out = process_abnormal_records(
+        &records,
+        &reg,
+        Provider::Codex,
+        &AbnormalNotificationState::default(),
+    )
+    .unwrap();
+    assert_eq!(out.notifications.len(), 2, "distinct raw → 2 notifies (probe)");
+}
+
+#[test]
+fn abnormal_missing_turn_id_identical_faults_fold() {
+    // abnormal_track.py:64-68 — identical raw + missing turn_id → same fingerprint → fold (probe: 1).
+    let reg = MockRegistry::new(&[], &[]);
+    let records = vec![
+        serde_json::json!({"signature": "sig_c", "raw": "same"}),
+        serde_json::json!({"signature": "sig_c", "raw": "same"}),
+    ];
+    let out = process_abnormal_records(
+        &records,
+        &reg,
+        Provider::Codex,
+        &AbnormalNotificationState::default(),
+    )
+    .unwrap();
+    assert_eq!(out.notifications.len(), 1, "identical raw folds even w/o turn_id (probe)");
+}
+
+#[test]
+fn abnormal_preseeded_seen_suppresses_duplicate_across_calls() {
+    // abnormal_track.py:67 — key already in seen → skip notification (cross-tick dedup).
+    let reg = MockRegistry::new(&[], &[]);
+    let mut state = AbnormalNotificationState::default();
+    state.seen.insert("sig_a\u{0}t1".to_string());
+    let records = vec![serde_json::json!({"signature": "sig_a", "turn_id": "t1", "raw": "boom"})];
+    let out = process_abnormal_records(
+        &records,
+        &reg,
+        Provider::Codex,
+        &state,
+    )
+    .unwrap();
+    assert_eq!(out.notifications.len(), 0, "pre-seeded seen suppresses (probe: 0)");
+}
+
+// ═════════════════════════════════════════════════════════════════════════
+// GROUP F — detect_whole_team_gone (abnormal_track.py:91) — clean vs unexpected — RED
+// ═════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn whole_team_gone_alive_when_any_present() {
+    // abnormal_track.py:117-127 — any alive → not whole_gone, silent.
+    let snap = TeamPresenceSnapshot {
+        coordinator_alive: true,
+        leader_alive: false,
+        provider_processes_alive: vec![false],
+        tmux_sessions_present: false,
+        clean_shutdown: false,
+        restart_in_progress: false,
+    };
+    let mut ms = MapMarkerStore::ok();
+    let r = detect_whole_team_gone(&snap, &mut ms);
+    assert!(!r.whole_team_gone);
+    assert_eq!(r.classification, WholeTeamGoneClass::Alive);
+    assert!(!r.notify);
+    assert!(!r.marker_written);
+    assert!(ms.markers.is_empty());
+}
+
+#[test]
+fn whole_team_gone_clean_shutdown_is_silent() {
+    // abnormal_track.py:129-130 — clean_shutdown → silent, NO marker.
+    let snap = TeamPresenceSnapshot {
+        coordinator_alive: false,
+        leader_alive: false,
+        provider_processes_alive: vec![false],
+        tmux_sessions_present: false,
+        clean_shutdown: true,
+        restart_in_progress: false,
+    };
+    let mut ms = MapMarkerStore::ok();
+    let r = detect_whole_team_gone(&snap, &mut ms);
+    assert!(r.whole_team_gone);
+    assert_eq!(r.classification, WholeTeamGoneClass::CleanShutdown);
+    assert!(!r.notify);
+    assert!(!r.escalate_user_on_next_leader_command);
+    assert!(!r.marker_written);
+    assert!(ms.markers.is_empty(), "clean shutdown writes NO durable marker");
+}
+
+#[test]
+fn whole_team_gone_restart_in_progress_is_silent() {
+    // abnormal_track.py:131-132 — restart_in_progress → silent.
+    let snap = TeamPresenceSnapshot {
+        coordinator_alive: false,
+        leader_alive: false,
+        provider_processes_alive: vec![false],
+        tmux_sessions_present: false,
+        clean_shutdown: false,
+        restart_in_progress: true,
+    };
+    let mut ms = MapMarkerStore::ok();
+    let r = detect_whole_team_gone(&snap, &mut ms);
+    assert!(r.whole_team_gone);
+    assert_eq!(r.classification, WholeTeamGoneClass::RestartInProgress);
+    assert!(!r.notify);
+    assert!(!r.marker_written);
+}
+
+#[test]
+fn whole_team_gone_unexpected_writes_marker_and_defers_escalation() {
+    // abnormal_track.py:134-147 — 闪退: durable marker + deferred escalation, notify.
+    let snap = TeamPresenceSnapshot {
+        coordinator_alive: false,
+        leader_alive: false,
+        provider_processes_alive: vec![false, false],
+        tmux_sessions_present: false,
+        clean_shutdown: false,
+        restart_in_progress: false,
+    };
+    let mut ms = MapMarkerStore::ok();
+    let r = detect_whole_team_gone(&snap, &mut ms);
+    assert!(r.whole_team_gone);
+    assert_eq!(r.classification, WholeTeamGoneClass::UnexpectedExit);
+    assert!(r.notify);
+    assert!(r.escalate_user_on_next_leader_command, "defer to next leader command");
+    assert!(r.marker_written);
+    assert!(ms.markers.contains_key("whole_team_gone"), "durable marker named whole_team_gone");
+}
+
+#[test]
+fn whole_team_gone_unexpected_marker_failure_reflected() {
+    // abnormal_track.py:146 — marker_written = bool(_marker_set(...)); 落盘失败 → false,
+    // 但仍 notify + escalate(分类不变)。
+    let snap = TeamPresenceSnapshot {
+        coordinator_alive: false,
+        leader_alive: false,
+        provider_processes_alive: vec![false],
+        tmux_sessions_present: false,
+        clean_shutdown: false,
+        restart_in_progress: false,
+    };
+    let mut ms = MapMarkerStore::failing();
+    let r = detect_whole_team_gone(&snap, &mut ms);
+    assert_eq!(r.classification, WholeTeamGoneClass::UnexpectedExit);
+    assert!(r.notify);
+    assert!(!r.marker_written, "marker set failed → marker_written false");
+}