@team-agent/installer 0.4.11 → 0.5.1

package/crates/team-agent/src/provider/adapters/claude.rs

@@ -3,14 +3,9 @@
 //! Extracted from `provider/adapter.rs` (0.4.x decoupling step 2). Pure
 //! extraction — byte-identical to the original inline forms. Scope kept
 //! small on purpose: base command + permission/disallowed-tool mapping +
-//! launch wrapper. Auth hints (`claude_auth_hint`), capture-related
-//! helpers (`claude_projects_dir_for_cwd`, `encode_claude_projects_dir`,
-//! `rollout_path_has_claude_leader_marker`,
-//! `claude_records_have_leader_marker`), and the context-aware model
-//! resolver (`claude_context_model`) stay in `adapter.rs` because they
-//! depend on adapter-private utilities (capture scanning, `command_on_path`,
-//! `ProfileLaunchContext`). A later step can move those into a session
-//! store / auth descriptor hook.
+//! launch wrapper. Auth hints (`claude_auth_hint`) and the context-aware model
+//! resolver (`claude_context_model`) stay in `adapter.rs`; capture scanning
+//! helpers now live under `provider/session_scan/claude.rs`.
 
 use crate::model::enums::AuthMode;
 use crate::provider::adapter::{

package/crates/team-agent/src/provider/adapters/copilot.rs

@@ -3,11 +3,8 @@
 //! Extracted from `provider/adapter.rs` (0.4.x decoupling step 2). Pure
 //! extraction — byte-identical to the original inline forms. Scope kept
 //! small: base command + resume + permission flags + MCP type→transport
-//! translation. Auth hint (`copilot_auth_hint`) and session store scan
-//! (`scan_copilot_session_store`, `copilot_candidate`) stay in
-//! `adapter.rs` because they depend on `command_on_path` /
-//! `CaptureSessionContext` / sqlite session-store helpers. Step 3 of the
-//! decoupling plan can move those into provider session store hooks.
+//! translation. Auth hint (`copilot_auth_hint`) stays in `adapter.rs`;
+//! session-store scanning lives under `provider/session_scan/copilot.rs`.
 
 use crate::model::enums::AuthMode;
 use crate::provider::McpConfig;

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

@@ -184,10 +184,22 @@ fn extract_xml_tag(text: &str, tag: &str) -> Option<String> {
 }
 
 pub fn latest_explicit_error_fact(provider: Provider, session_log_text: &str) -> Option<FaultFact> {
-    let record = latest_jsonl_record(session_log_text)?;
+    session_log_text
+        .lines()
+        .rev()
+        .map(str::trim)
+        .filter(|line| !line.is_empty())
+        .filter_map(|line| serde_json::from_str::<serde_json::Value>(line).ok())
+        .find_map(|record| latest_explicit_error_fact_for_record(provider, &record))
+}
+
+fn latest_explicit_error_fact_for_record(
+    provider: Provider,
+    record: &serde_json::Value,
+) -> Option<FaultFact> {
     match provider {
-        Provider::Codex => codex_latest_explicit_error_fact(&record),
-        Provider::Claude | Provider::ClaudeCode => claude_latest_explicit_error_fact(&record),
+        Provider::Codex => codex_latest_explicit_error_fact(record),
+        Provider::Claude | Provider::ClaudeCode => claude_latest_explicit_error_fact(record),
         // C-3-5 cr verdict: copilot N35 通知不依赖 turn-state 分类;一期 Unknown,
         // 与 GeminiCli/Fake 同精神。二期接 sqlite turns 表后再回填。
         Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
@@ -302,15 +314,6 @@ fn extract_lifecycle_facts(provider: Provider, records: &[serde_json::Value]) ->
         .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")) {
@@ -323,46 +326,18 @@ fn codex_latest_explicit_error_fact(record: &serde_json::Value) -> Option<FaultF
     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,
-    })
+    Some(FaultFact::new(
+        Signature::new("turn_failed"),
+        turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+        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")
-    {
+    if super::faults::claude_record_has_error_tool_result(record) {
         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)
-            })
-        })
+    super::faults::claude_explicit_error_fact(record)
 }
 
 fn decide_state(fact: &LifecycleFact, process: ProcessLiveness) -> ClassifyResult {
@@ -443,7 +418,7 @@ fn claude_lifecycle_fact(record: &serde_json::Value) -> Option<LifecycleFact> {
             vec!["api_error".to_string()],
         ));
     }
-    if record_type == Some("user") && claude_record_has_error_tool_result(record) {
+    if record_type == Some("user") && super::faults::claude_record_has_error_tool_result(record) {
         return Some(lifecycle(
             FactKind::Error,
             record

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

@@ -39,10 +39,7 @@ pub enum CommandPlanKind {
 pub fn honors_session_id_for_base_spawn(provider: Provider) -> bool {
     matches!(
         provider,
-        Provider::Codex
-            | Provider::Claude
-            | Provider::ClaudeCode
-            | Provider::Copilot
+        Provider::Claude | Provider::ClaudeCode | Provider::Copilot
     )
 }
 
@@ -56,9 +53,21 @@ mod tests {
     }
 
     #[test]
-    fn real_providers_honor_session_id() {
-        for p in [Provider::Codex, Provider::Claude, Provider::Copilot] {
-            assert!(honors_session_id_for_base_spawn(p));
+    fn provider_matrix_for_base_spawn_session_id_support() {
+        let cases = [
+            (Provider::Claude, true),
+            (Provider::ClaudeCode, true),
+            (Provider::Copilot, true),
+            (Provider::Codex, false),
+            (Provider::GeminiCli, false),
+            (Provider::Fake, false),
+        ];
+        for (provider, expected) in cases {
+            assert_eq!(
+                honors_session_id_for_base_spawn(provider),
+                expected,
+                "{provider:?}"
+            );
         }
     }
 

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

@@ -5,7 +5,7 @@ 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`。
+/// 携 `(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()
@@ -22,23 +22,30 @@ pub fn explicit_error_fact(record: &serde_json::Value, provider: Provider) -> Op
     }
 }
 
-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;
+pub(crate) fn claude_explicit_error_fact(record: &serde_json::Value) -> Option<FaultFact> {
+    if claude_record_is_system_api_error(record) {
+        return Some(FaultFact::new(
+            Signature::new("api_error"),
+            claude_system_api_error_turn_id(record),
+            FactKind::Error,
+        ));
     }
-    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 claude_record_is_assistant_api_error(record) {
+        return Some(
+            FaultFact::new(
+                Signature::new("api_error"),
+                claude_assistant_api_error_turn_id(record),
+                FactKind::Error,
+            )
+            .with_api_error_details(
+                record.get("apiErrorStatus").and_then(serde_json::Value::as_i64),
+                non_empty_string_field(record, "error"),
+                non_empty_string_field(record, "requestId"),
+                non_empty_string_field(record, "uuid"),
+            ),
+        );
+    }
+    None
 }
 
 fn codex_explicit_error_fact(record: &serde_json::Value) -> Option<FaultFact> {
@@ -49,11 +56,11 @@ fn codex_explicit_error_fact(record: &serde_json::Value) -> Option<FaultFact> {
     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,
-    })
+    Some(FaultFact::new(
+        Signature::new("turn_failed"),
+        turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+        FactKind::Failed,
+    ))
 }
 
 fn fault_fact(provider: Provider, record: &serde_json::Value) -> Option<FaultFact> {
@@ -65,38 +72,26 @@ fn fault_fact(provider: Provider, record: &serde_json::Value) -> Option<FaultFac
 }
 
 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 let Some(fact) = claude_explicit_error_fact(record) {
+        return Some(fact);
     }
     if record.get("type").and_then(serde_json::Value::as_str) == Some("user")
-        && claude_has_error_tool_result(record)
+        && claude_record_has_error_tool_result(record)
     {
-        return Some(FaultFact {
-            signature: Signature::new("tool_result_is_error"),
-            turn_id: record
+        return Some(FaultFact::new(
+            Signature::new("tool_result_is_error"),
+            record
                 .get("parentUuid")
                 .or_else(|| record.get("uuid"))
                 .and_then(serde_json::Value::as_str)
                 .map(TurnId::new),
-            kind: FactKind::Error,
-        });
+            FactKind::Error,
+        ));
     }
     None
 }
 
-fn claude_has_error_tool_result(record: &serde_json::Value) -> bool {
+pub(crate) fn claude_record_has_error_tool_result(record: &serde_json::Value) -> bool {
     record
         .get("message")
         .and_then(|m| m.get("content"))
@@ -109,29 +104,74 @@ fn claude_has_error_tool_result(record: &serde_json::Value) -> bool {
         })
 }
 
+fn claude_record_is_system_api_error(record: &serde_json::Value) -> bool {
+    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")
+}
+
+fn claude_system_api_error_turn_id(record: &serde_json::Value) -> Option<TurnId> {
+    record
+        .get("sessionId")
+        .or_else(|| record.get("parentUuid"))
+        .or_else(|| record.get("uuid"))
+        .and_then(serde_json::Value::as_str)
+        .map(TurnId::new)
+}
+
+fn claude_record_is_assistant_api_error(record: &serde_json::Value) -> bool {
+    record.get("type").and_then(serde_json::Value::as_str) == Some("assistant")
+        && record
+            .get("message")
+            .and_then(|message| message.get("role"))
+            .and_then(serde_json::Value::as_str)
+            == Some("assistant")
+        && record.get("isApiErrorMessage").and_then(serde_json::Value::as_bool) == Some(true)
+        && (record.get("apiErrorStatus").and_then(serde_json::Value::as_i64).is_some()
+            || non_empty_string_field(record, "error").is_some()
+            || non_empty_string_field(record, "requestId").is_some())
+}
+
+fn claude_assistant_api_error_turn_id(record: &serde_json::Value) -> Option<TurnId> {
+    record
+        .get("uuid")
+        .or_else(|| record.get("parentUuid"))
+        .or_else(|| record.get("sessionId"))
+        .and_then(serde_json::Value::as_str)
+        .map(TurnId::new)
+}
+
+fn non_empty_string_field(record: &serde_json::Value, key: &str) -> Option<String> {
+    record
+        .get(key)
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+}
+
 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,
-            });
+            return Some(FaultFact::new(
+                Signature::new("turn_failed"),
+                turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+                FactKind::Failed,
+            ));
         }
     }
     if method.is_some_and(|m| m.ends_with("requestApproval")) {
-        return Some(FaultFact {
-            signature: Signature::new("approval_required"),
-            turn_id: record
+        return Some(FaultFact::new(
+            Signature::new("approval_required"),
+            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,
-        });
+            FactKind::Approval,
+        ));
     }
     None
 }

package/crates/team-agent/src/provider/session/capture.rs

@@ -7,6 +7,7 @@ use crate::provider::{
     CapturedSession, CapturedSessionCandidate, CaptureSessionContext, Provider, ProviderAdapter,
     ProviderError, SessionId,
 };
+use crate::provider::wire::{is_claude_family, parse_provider};
 
 pub const SESSION_CAPTURE_CONVERGENCE_DEADLINE_MS: u64 = 12_000;
 pub const SESSION_CAPTURE_CONVERGENCE_POLL_MS: u64 = 250;
@@ -499,7 +500,7 @@ pub fn recover_resume_session_from_events(
         };
         // E57 postflight (lane-046-capture-gap): the capture allocator already
         // refuses Claude leader transcripts (P0 d39b5104,
-        // claude_records_have_leader_marker in provider/adapter.rs). Event-log
+        // provider/session_scan/claude.rs leader marker). Event-log
         // repair must apply the SAME filter — otherwise a stale `session.captured`
         // event from a pre-fix run (or from a window where the allocator was
         // bypassed) still pulls the 590MB leader transcript onto a worker on the
@@ -507,7 +508,7 @@ pub fn recover_resume_session_from_events(
         // release-engineer via captured_via=event_log_repair). The check is
         // a no-op for non-Claude providers.
         if let Some(p) = provider {
-            if crate::provider::adapter::rollout_path_has_claude_leader_marker(p, &rollout_path) {
+            if crate::provider::session_scan::rollout_path_has_claude_leader_marker(p, &rollout_path) {
                 continue;
             }
         }
@@ -752,7 +753,7 @@ fn agent_session_complete(agent: &Value) -> bool {
         return false;
     }
     let provider_wire = agent.get("provider").and_then(Value::as_str).unwrap_or("");
-    if matches!(provider_wire, "claude" | "claude-code" | "claude_code") {
+    if parse_provider(provider_wire).is_some_and(is_claude_family) {
         return claude_rollout_has_lifecycle_records(path);
     }
     true
@@ -1126,18 +1127,6 @@ fn captured_provider_session_keys(captured: &CapturedSession) -> BTreeSet<String
     keys
 }
 
-fn parse_provider(raw: &str) -> Option<Provider> {
-    match raw {
-        "claude" => Some(Provider::Claude),
-        "claude_code" => Some(Provider::ClaudeCode),
-        "codex" => Some(Provider::Codex),
-        "copilot" => Some(Provider::Copilot),
-        "gemini_cli" => Some(Provider::GeminiCli),
-        "fake" => Some(Provider::Fake),
-        _ => None,
-    }
-}
-
 #[cfg(test)]
 pub(crate) mod test_support {
     use super::*;