@team-agent/installer 0.2.11 → 0.3.1

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

@@ -0,0 +1,456 @@
+//! JSONL→neutral turn-state 翻译 + idle take-over predicate(`provider_state.common` +
+//! `idle_predicate` 的 Rust 等价)。leader 经注入的 TurnStateClassifier 调到这里。
+
+use super::helpers::parse_jsonl_records;
+use super::types::{
+    ClassifyResult, ClassifySource, FactKind, FaultFact, NoPingReason, ProcessLiveness, ProviderError,
+    RemindResult, Signature, TurnId, TurnState,
+};
+use super::Provider;
+
+/// `provider_state.read_turn_state(provider, session_log_text, process, file_silence_seconds)`
+/// (`__init__.py:18` + `common.classify_with_reader`/`decide_state`)。
+///
+/// 流程:`parse_jsonl` → per-provider `extract_facts`(claude/codex)→ `decide_state`。
+/// **归一**:`claude_code` → `claude` reader(`__init__.py:88` `_reader_provider`)。
+/// **铁律**:不可读/空/无 lifecycle / 进程不可验 → `TurnState::Unknown`,**绝不 idle**(C5)。
+/// `file_silence_seconds` 被显式丢弃——open turn 永不被静默 demote(C14,`__init__.py:32`)。
+pub fn classify(
+    provider: Provider,
+    session_log_text: &str,
+    process: ProcessLiveness,
+    file_silence_seconds: f64,
+) -> Result<ClassifyResult, ProviderError> {
+    let _ = file_silence_seconds;
+    let records = parse_jsonl_records(session_log_text);
+    if records.is_empty() {
+        return Ok(classify_result(
+            TurnState::Unknown,
+            None,
+            "unreadable_or_empty",
+            ClassifySource::SessionFile,
+            Vec::new(),
+        ));
+    }
+    let facts = extract_lifecycle_facts(provider, &records);
+    let Some(fact) = facts.last() else {
+        return Ok(classify_result(
+            TurnState::Unknown,
+            None,
+            "no_turn_lifecycle_fact",
+            ClassifySource::SessionFile,
+            Vec::new(),
+        ));
+    };
+    Ok(decide_state(fact, process))
+}
+
+pub fn latest_explicit_error_fact(provider: Provider, session_log_text: &str) -> Option<FaultFact> {
+    let record = latest_jsonl_record(session_log_text)?;
+    match provider {
+        Provider::Codex => codex_latest_explicit_error_fact(&record),
+        Provider::Claude | Provider::ClaudeCode => claude_latest_explicit_error_fact(&record),
+        Provider::GeminiCli | Provider::Fake => None,
+    }
+}
+
+/// `idle_predicate.evaluate_takeover_reminder(nodes, monitor_state, now, debounce)`
+/// (`idle_predicate.py:20`)。中性 take-over reminder 判定。
+///
+/// 规则:仅 worker 的 delegated 态 arm(C1);任何非 `{idle, idle_interrupted}` node
+/// 立刻 block 并报 `Node(state)`(C5/C14);全 idle + armed + debounce 到期 → ping(C2/C11);
+/// `idle_interrupted` 算 idle 但进 `interrupted_nodes`(C12)。
+///
+/// 节点输入用 `serde_json::Value`(承载 `{node_id, role, state}` dict 形态),与 Python
+/// 一致;`monitor_state` 同。porter 在 impl 时换成 typed `IdleNode`/`MonitorState`。
+pub fn evaluate_takeover_reminder(
+    nodes: &[serde_json::Value],
+    monitor_state: Option<&serde_json::Value>,
+    now_monotonic: f64,
+    debounce_seconds: f64,
+) -> Result<RemindResult, ProviderError> {
+    if nodes.is_empty() {
+        return Ok(remind(false, NoPingReason::NoNodes, Vec::new(), None));
+    }
+
+    let mut interrupted = Vec::new();
+    for node in nodes {
+        let state = node_state(node);
+        match state {
+            TurnState::Idle => {}
+            TurnState::IdleInterrupted => {
+                if let Some(id) = node.get("node_id").and_then(serde_json::Value::as_str) {
+                    interrupted.push(id.to_string());
+                }
+            }
+            TurnState::Working => {
+                return Ok(remind(false, NoPingReason::Node(TurnState::Working), Vec::new(), None));
+            }
+            TurnState::BlockedOnHuman => {
+                return Ok(remind(false, NoPingReason::Node(TurnState::BlockedOnHuman), Vec::new(), None));
+            }
+            TurnState::Abnormal => {
+                return Ok(remind(false, NoPingReason::Node(TurnState::Abnormal), Vec::new(), None));
+            }
+            TurnState::Unknown => {
+                return Ok(remind(false, NoPingReason::Node(TurnState::Unknown), Vec::new(), None));
+            }
+        }
+    }
+
+    let Some(ms) = monitor_state else {
+        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+    };
+    if ms.get("opened_worker_turn_since_ack").and_then(serde_json::Value::as_bool) != Some(true) {
+        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+    }
+    if ms.get("suppressed").and_then(serde_json::Value::as_bool) == Some(true) {
+        return Ok(remind(false, NoPingReason::Acknowledged, Vec::new(), None));
+    }
+    let Some(all_idle_since) = ms.get("all_idle_since").and_then(serde_json::Value::as_f64) else {
+        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+    };
+    if ms.get("pinged_for_episode").and_then(serde_json::Value::as_f64) == Some(all_idle_since) {
+        return Ok(remind(false, NoPingReason::AlreadyPingedThisEpisode, Vec::new(), None));
+    }
+    if now_monotonic - all_idle_since < debounce_seconds {
+        return Ok(remind(false, NoPingReason::DebounceActive, Vec::new(), None));
+    }
+    Ok(remind(
+        true,
+        NoPingReason::AllIdleDebounceElapsed,
+        interrupted,
+        Some("All worker turns are idle.".to_string()),
+    ))
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct LifecycleFact {
+    kind: FactKind,
+    turn_id: Option<TurnId>,
+    reason: String,
+    annotations: Vec<String>,
+}
+
+fn classify_result(
+    state: TurnState,
+    turn_id: Option<TurnId>,
+    reason: &str,
+    source: ClassifySource,
+    annotations: Vec<String>,
+) -> ClassifyResult {
+    ClassifyResult {
+        state,
+        turn_id,
+        reason: reason.to_string(),
+        source,
+        annotations,
+        diagnostics: Vec::new(),
+    }
+}
+
+fn extract_lifecycle_facts(provider: Provider, records: &[serde_json::Value]) -> Vec<LifecycleFact> {
+    records
+        .iter()
+        .filter_map(|record| match provider {
+            Provider::Claude | Provider::ClaudeCode => claude_lifecycle_fact(record),
+            Provider::Codex => codex_lifecycle_fact(record),
+            Provider::GeminiCli | Provider::Fake => None,
+        })
+        .collect()
+}
+
+fn latest_jsonl_record(text: &str) -> Option<serde_json::Value> {
+    let last = text
+        .lines()
+        .rev()
+        .map(str::trim)
+        .find(|line| !line.is_empty())?;
+    serde_json::from_str::<serde_json::Value>(last).ok()
+}
+
+fn codex_latest_explicit_error_fact(record: &serde_json::Value) -> Option<FaultFact> {
+    let method = record.get("method").and_then(serde_json::Value::as_str);
+    if method.is_some_and(|method| method.ends_with("requestApproval")) {
+        return None;
+    }
+    if method != Some("turn/completed") {
+        return None;
+    }
+    let turn = record.get("params").and_then(|p| p.get("turn"))?;
+    if turn.get("status").and_then(serde_json::Value::as_str) != Some("failed") {
+        return None;
+    }
+    Some(FaultFact {
+        signature: Signature::new("turn_failed"),
+        turn_id: turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+        kind: FactKind::Failed,
+    })
+}
+
+fn claude_latest_explicit_error_fact(record: &serde_json::Value) -> Option<FaultFact> {
+    if claude_record_has_error_tool_result(record) {
+        return None;
+    }
+    if record.get("type").and_then(serde_json::Value::as_str) != Some("system")
+        || record.get("subtype").and_then(serde_json::Value::as_str) != Some("api_error")
+        || record.get("level").and_then(serde_json::Value::as_str) != Some("error")
+    {
+        return None;
+    }
+    Some(FaultFact {
+        signature: Signature::new("api_error"),
+        turn_id: record
+            .get("sessionId")
+            .or_else(|| record.get("parentUuid"))
+            .or_else(|| record.get("uuid"))
+            .and_then(serde_json::Value::as_str)
+            .map(TurnId::new),
+        kind: FactKind::Error,
+    })
+}
+
+fn claude_record_has_error_tool_result(record: &serde_json::Value) -> bool {
+    record
+        .get("message")
+        .and_then(|m| m.get("content"))
+        .and_then(serde_json::Value::as_array)
+        .is_some_and(|items| {
+            items.iter().any(|item| {
+                item.get("type").and_then(serde_json::Value::as_str) == Some("tool_result")
+                    && item.get("is_error").and_then(serde_json::Value::as_bool) == Some(true)
+            })
+        })
+}
+
+fn decide_state(fact: &LifecycleFact, process: ProcessLiveness) -> ClassifyResult {
+    match fact.kind {
+        FactKind::TurnOpen => match process {
+            ProcessLiveness::Alive => classify_result(
+                TurnState::Working,
+                fact.turn_id.clone(),
+                "open_turn",
+                ClassifySource::SessionFile,
+                Vec::new(),
+            ),
+            ProcessLiveness::Dead => classify_result(
+                TurnState::Abnormal,
+                fact.turn_id.clone(),
+                "crashed_mid_turn",
+                ClassifySource::ProcessGuard,
+                vec!["crashed_mid_turn".to_string()],
+            ),
+            ProcessLiveness::Unverifiable => classify_result(
+                TurnState::Unknown,
+                fact.turn_id.clone(),
+                "process_identity_unverified",
+                ClassifySource::ProcessGuard,
+                Vec::new(),
+            ),
+        },
+        FactKind::TurnComplete => classify_result(
+            TurnState::Idle,
+            fact.turn_id.clone(),
+            &fact.reason,
+            ClassifySource::SessionFile,
+            fact.annotations.clone(),
+        ),
+        FactKind::Interrupted => classify_result(
+            TurnState::IdleInterrupted,
+            fact.turn_id.clone(),
+            &fact.reason,
+            ClassifySource::SessionFile,
+            fact.annotations.clone(),
+        ),
+        FactKind::Failed | FactKind::Error => classify_result(
+            TurnState::Abnormal,
+            fact.turn_id.clone(),
+            &fact.reason,
+            ClassifySource::SessionFile,
+            fact.annotations.clone(),
+        ),
+        FactKind::Approval => classify_result(
+            TurnState::BlockedOnHuman,
+            fact.turn_id.clone(),
+            &fact.reason,
+            ClassifySource::SessionFile,
+            fact.annotations.clone(),
+        ),
+    }
+}
+
+fn claude_lifecycle_fact(record: &serde_json::Value) -> Option<LifecycleFact> {
+    let record_type = record.get("type").and_then(serde_json::Value::as_str);
+    if record_type == Some("assistant") {
+        let stop_reason = record
+            .get("message")
+            .and_then(|m| m.get("stop_reason"))
+            .and_then(serde_json::Value::as_str)?;
+        let turn_id = record.get("requestId").and_then(serde_json::Value::as_str).map(TurnId::new);
+        return match stop_reason {
+            "tool_use" => Some(lifecycle(FactKind::TurnOpen, turn_id, "open_turn", Vec::new())),
+            "end_turn" => Some(lifecycle(FactKind::TurnComplete, turn_id, "end_turn", Vec::new())),
+            "stop_sequence" => Some(lifecycle(
+                FactKind::TurnComplete,
+                turn_id,
+                "stop_sequence",
+                Vec::new(),
+            )),
+            _ => None,
+        };
+    }
+    if record_type == Some("user") && claude_user_interrupted(record) {
+        return Some(lifecycle(
+            FactKind::Interrupted,
+            record.get("uuid").and_then(serde_json::Value::as_str).map(TurnId::new),
+            "user_interrupt",
+            vec!["interrupted".to_string()],
+        ));
+    }
+    None
+}
+
+fn codex_lifecycle_fact(record: &serde_json::Value) -> Option<LifecycleFact> {
+    if record.get("type").and_then(serde_json::Value::as_str) == Some("event_msg") {
+        let payload = record.get("payload")?;
+        let payload_type = payload.get("type").and_then(serde_json::Value::as_str)?;
+        let turn_id = payload
+            .get("turn_id")
+            .and_then(serde_json::Value::as_str)
+            .map(TurnId::new);
+        return match payload_type {
+            "task_started" => Some(lifecycle(
+                FactKind::TurnOpen,
+                turn_id,
+                "task_started",
+                Vec::new(),
+            )),
+            "task_complete" => Some(lifecycle(
+                FactKind::TurnComplete,
+                turn_id,
+                "task_complete",
+                Vec::new(),
+            )),
+            "turn_aborted" => {
+                let reason = payload
+                    .get("reason")
+                    .and_then(serde_json::Value::as_str)
+                    .unwrap_or("interrupted");
+                Some(lifecycle(
+                    FactKind::Interrupted,
+                    turn_id,
+                    reason,
+                    vec!["interrupted".to_string()],
+                ))
+            }
+            _ => None,
+        };
+    }
+    if record.get("jsonrpc").is_some() {
+        let method = record.get("method").and_then(serde_json::Value::as_str);
+        if method == Some("turn/completed") {
+            let turn = record.get("params").and_then(|p| p.get("turn"))?;
+            let turn_id = turn
+                .get("id")
+                .and_then(serde_json::Value::as_str)
+                .map(TurnId::new);
+            return match turn.get("status").and_then(serde_json::Value::as_str) {
+                Some("completed") => Some(lifecycle(
+                    FactKind::TurnComplete,
+                    turn_id,
+                    "completed",
+                    Vec::new(),
+                )),
+                Some("interrupted") => Some(lifecycle(
+                    FactKind::Interrupted,
+                    turn_id,
+                    "interrupted",
+                    vec!["interrupted".to_string()],
+                )),
+                Some("inProgress") => Some(lifecycle(
+                    FactKind::TurnOpen,
+                    turn_id,
+                    "open_turn",
+                    Vec::new(),
+                )),
+                Some("failed") => Some(lifecycle(
+                    FactKind::Failed,
+                    turn_id,
+                    "turn_failed",
+                    vec!["turn_failed".to_string()],
+                )),
+                Some(_) | None => None,
+            };
+        }
+        if method.is_some_and(|m| m.ends_with("requestApproval")) {
+            return Some(lifecycle(
+                FactKind::Approval,
+                record
+                    .get("params")
+                    .and_then(|p| p.get("turnId"))
+                    .or_else(|| record.get("params").and_then(|p| p.get("turn_id")))
+                    .and_then(serde_json::Value::as_str)
+                    .map(TurnId::new),
+                "approval_required",
+                vec!["awaiting_approval".to_string()],
+            ));
+        }
+    }
+    None
+}
+
+fn lifecycle(
+    kind: FactKind,
+    turn_id: Option<TurnId>,
+    reason: &str,
+    annotations: Vec<String>,
+) -> LifecycleFact {
+    LifecycleFact {
+        kind,
+        turn_id,
+        reason: reason.to_string(),
+        annotations,
+    }
+}
+
+fn claude_user_interrupted(record: &serde_json::Value) -> bool {
+    record
+        .get("message")
+        .and_then(|m| m.get("content"))
+        .and_then(serde_json::Value::as_array)
+        .is_some_and(|items| {
+            items.iter().any(|item| {
+                item.get("type").and_then(serde_json::Value::as_str) == Some("text")
+                    && item
+                        .get("text")
+                        .and_then(serde_json::Value::as_str)
+                        == Some("[Request interrupted by user]")
+            })
+        })
+}
+
+fn node_state(node: &serde_json::Value) -> TurnState {
+    match node.get("state").and_then(serde_json::Value::as_str) {
+        Some("idle") => TurnState::Idle,
+        Some("working") => TurnState::Working,
+        Some("idle_interrupted") => TurnState::IdleInterrupted,
+        Some("blocked_on_human") => TurnState::BlockedOnHuman,
+        Some("abnormal") => TurnState::Abnormal,
+        Some("unknown") | None => TurnState::Unknown,
+        Some(_) => TurnState::Unknown,
+    }
+}
+
+fn remind(
+    should_ping: bool,
+    reason: NoPingReason,
+    interrupted_nodes: Vec<String>,
+    message: Option<String>,
+) -> RemindResult {
+    RemindResult {
+        should_ping,
+        reason,
+        interrupted_nodes,
+        message,
+    }
+}

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

@@ -0,0 +1,136 @@
+//! abnormal track 消费的 fault/approval facts 抽取(`provider_state.read_fault_facts`)。
+
+use super::types::{FactKind, FaultFact, Signature, TurnId};
+use super::Provider;
+
+/// `provider_state.read_fault_facts(provider, records)`(`__init__.py:46`)。
+/// 从已解析 records 抽取 fault/approval facts(kind ∈ {error, failed, approval}),
+/// 携 `(signature, turn_id)` C8 dedup key。`api_error` 无 ids 时 `turn_id == None`。
+pub fn read_fault_facts(records: &[serde_json::Value], provider: Provider) -> Vec<FaultFact> {
+    records
+        .iter()
+        .filter_map(|record| fault_fact(provider, record))
+        .collect()
+}
+
+pub fn explicit_error_fact(record: &serde_json::Value, provider: Provider) -> Option<FaultFact> {
+    match provider {
+        Provider::Codex => codex_explicit_error_fact(record),
+        Provider::Claude | Provider::ClaudeCode => claude_explicit_error_fact(record),
+        Provider::GeminiCli | Provider::Fake => None,
+    }
+}
+
+fn claude_explicit_error_fact(record: &serde_json::Value) -> Option<FaultFact> {
+    if record.get("type").and_then(serde_json::Value::as_str) != Some("system")
+        || record.get("subtype").and_then(serde_json::Value::as_str) != Some("api_error")
+        || record.get("level").and_then(serde_json::Value::as_str) != Some("error")
+    {
+        return None;
+    }
+    Some(FaultFact {
+        signature: Signature::new("api_error"),
+        turn_id: record
+            .get("sessionId")
+            .or_else(|| record.get("parentUuid"))
+            .or_else(|| record.get("uuid"))
+            .and_then(serde_json::Value::as_str)
+            .map(TurnId::new),
+        kind: FactKind::Error,
+    })
+}
+
+fn codex_explicit_error_fact(record: &serde_json::Value) -> Option<FaultFact> {
+    if record.get("method").and_then(serde_json::Value::as_str) != Some("turn/completed") {
+        return None;
+    }
+    let turn = record.get("params").and_then(|p| p.get("turn"))?;
+    if turn.get("status").and_then(serde_json::Value::as_str) != Some("failed") {
+        return None;
+    }
+    Some(FaultFact {
+        signature: Signature::new("turn_failed"),
+        turn_id: turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+        kind: FactKind::Failed,
+    })
+}
+
+fn fault_fact(provider: Provider, record: &serde_json::Value) -> Option<FaultFact> {
+    match provider {
+        Provider::Claude | Provider::ClaudeCode => claude_fault_fact(record),
+        Provider::Codex => codex_fault_fact(record),
+        Provider::GeminiCli | Provider::Fake => None,
+    }
+}
+
+fn claude_fault_fact(record: &serde_json::Value) -> Option<FaultFact> {
+    if record.get("type").and_then(serde_json::Value::as_str) == Some("system")
+        && record.get("subtype").and_then(serde_json::Value::as_str) == Some("api_error")
+        && record.get("level").and_then(serde_json::Value::as_str) == Some("error")
+    {
+        return Some(FaultFact {
+            signature: Signature::new("api_error"),
+            turn_id: record
+                .get("sessionId")
+                .or_else(|| record.get("parentUuid"))
+                .or_else(|| record.get("uuid"))
+                .and_then(serde_json::Value::as_str)
+                .map(TurnId::new),
+            kind: FactKind::Error,
+        });
+    }
+    if record.get("type").and_then(serde_json::Value::as_str) == Some("user")
+        && claude_has_error_tool_result(record)
+    {
+        return Some(FaultFact {
+            signature: Signature::new("tool_result_is_error"),
+            turn_id: record
+                .get("parentUuid")
+                .or_else(|| record.get("uuid"))
+                .and_then(serde_json::Value::as_str)
+                .map(TurnId::new),
+            kind: FactKind::Error,
+        });
+    }
+    None
+}
+
+fn claude_has_error_tool_result(record: &serde_json::Value) -> bool {
+    record
+        .get("message")
+        .and_then(|m| m.get("content"))
+        .and_then(serde_json::Value::as_array)
+        .is_some_and(|items| {
+            items.iter().any(|item| {
+                item.get("type").and_then(serde_json::Value::as_str) == Some("tool_result")
+                    && item.get("is_error").and_then(serde_json::Value::as_bool) == Some(true)
+            })
+        })
+}
+
+fn codex_fault_fact(record: &serde_json::Value) -> Option<FaultFact> {
+    let method = record.get("method").and_then(serde_json::Value::as_str);
+    if method == Some("turn/completed") {
+        let turn = record.get("params").and_then(|p| p.get("turn"))?;
+        if turn.get("status").and_then(serde_json::Value::as_str) == Some("failed") {
+            return Some(FaultFact {
+                signature: Signature::new("turn_failed"),
+                turn_id: turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+                kind: FactKind::Failed,
+            });
+        }
+    }
+    if method.is_some_and(|m| m.ends_with("requestApproval")) {
+        return Some(FaultFact {
+            signature: Signature::new("approval_required"),
+            turn_id: record
+                .get("params")
+                .and_then(|p| p.get("turnId"))
+                .or_else(|| record.get("params").and_then(|p| p.get("turn_id")))
+                .and_then(serde_json::Value::as_str)
+                .map(TurnId::new),
+            kind: FactKind::Approval,
+        });
+    }
+    None
+}

package/crates/team-agent/src/provider/helpers.rs

@@ -0,0 +1,41 @@
+//! provider 跨子模块共享 helper:JSONL 解析 / session_id 抽取 / 正则编译。
+
+use super::types::{ProviderError, StatusPatterns};
+
+pub(crate) fn parse_jsonl_records(text: &str) -> Vec<serde_json::Value> {
+    if text.trim().is_empty() {
+        return Vec::new();
+    }
+    text.lines()
+        .filter_map(|line| {
+            let trimmed = line.trim();
+            if trimmed.is_empty() {
+                None
+            } else {
+                serde_json::from_str::<serde_json::Value>(trimmed).ok()
+            }
+        })
+        .collect()
+}
+
+pub(crate) fn find_session_id(record: &serde_json::Value) -> Option<String> {
+    if let Some(s) = record.get("sessionId").and_then(serde_json::Value::as_str) {
+        return Some(s.to_string());
+    }
+    record
+        .get("session_id")
+        .and_then(serde_json::Value::as_str)
+        .map(ToString::to_string)
+}
+
+pub(crate) fn patterns(idle: &str, processing: &str, error: &str) -> Result<StatusPatterns, ProviderError> {
+    Ok(StatusPatterns {
+        idle: compile_regex(idle)?,
+        processing: compile_regex(processing)?,
+        error: compile_regex(error)?,
+    })
+}
+
+fn compile_regex(pattern: &str) -> Result<regex::Regex, ProviderError> {
+    regex::Regex::new(pattern).map_err(|e| ProviderError::Command(format!("regex {pattern}: {e}")))
+}

package/crates/team-agent/src/provider/mod.rs

@@ -0,0 +1,53 @@
+//! step 8 · provider — type + trait SKELETON (ROUND-0).
+//!
+//! Design doc: `docs/phase0/subsystems/08-provider.md`
+//! (type-inventory table lines ~48-67, public API list ~71-81, module map ~128-137).
+//! Truth source (READ-ONLY snapshot `team-agent-public` @ v0.2.11 / `439bef8`):
+//!   - `provider_cli/base.py` · `adapter.py` · `claude.py` · `codex.py` · `gemini.py` · `fake.py`
+//!   - `provider_cli/prompt.py` · `registry.py` · `unsupported.py` · `providers.py`
+//!   - `idle_predicate.py`
+//!   - `provider_state/common.py` (`decide_state`/`process_liveness`/`_CLOSING`)
+//!   - `provider_state/{claude,codex,registry,__init__}.py`
+//!   - `approvals/{constants,parsing,runtime_prompts,status}.py`
+//!
+//! 职责(doc §职责): per-provider 命令构造 / session 捕获 / JSONL→neutral turn-state
+//! 翻译 / idle take-over predicate / runtime approval·trust prompt 检测应答。
+//!
+//! 铁律(doc §bug/陷阱):
+//!   - **unknown 永不当 idle**:`TurnState` 穷尽 match,无 `_ => idle` 兜底。
+//!   - **bug-085 None 漏穿**:`session_id`/`rollout_path`/`turn_id` 全 `Option<T>`,穷尽处理 `None`。
+//!   - **MUST-NOT-13**:idle/classify/selftest/abnormal 路径零 provider client / network SDK。
+//!   - §10:本子系统跑在 daemon tick 入口,fallible 方法返 `Result`,实现层禁 unwrap/expect/panic
+//!     (`#![deny(...)]` 由 leader 在 integration 时加,本 ROUND-0 skeleton 不加)。
+//!
+//! ROUND-0:仅类型 + trait 签名。自由函数 / placeholder impl body 一律
+//! `unimplemented!("step8 port: <what>")`。
+
+// §10:daemon tick / idle / classify 路径,实现层禁 unwrap/expect/panic(unimplemented! 未实现 stub 不算)。
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+
+// REUSE — 不重定义(doc ADJUDICATION):`Provider` 单 `ClaudeCode` 变体归一 claude/claude_code;
+// `AuthMode` 决定 fork 能力 / MCP config 路径 / claude compatible_api fallback 分支。
+// 复用 model::enums 的 Provider/AuthMode,并 re-export(下游惯于 `provider::Provider` 取用)。
+pub use crate::model::enums::{AuthMode, Provider};
+
+pub mod adapter;
+pub mod approvals;
+pub mod classify;
+pub mod faults;
+pub mod startup_prompt;
+pub mod types;
+// helpers 全部原为模块私有(JSONL 解析 / 正则编译),非根可见 → 私有 mod,不参与 re-export。
+mod helpers;
+
+// RE-EXPORT INVARIANT:外部 `crate::provider::X` + 测试 `use super::*` 解析不变。
+pub use adapter::*;
+pub use approvals::parsing::*;
+pub use approvals::runtime_prompts::*;
+pub use classify::*;
+pub use faults::*;
+pub use startup_prompt::*;
+pub use types::*;
+
+#[cfg(test)]
+mod tests;