@team-agent/installer 0.4.5 → 0.4.7

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.4.5"
+version = "0.4.7"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.4.5"
+version = "0.4.7"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/adapters.rs

@@ -240,11 +240,16 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
         }
     };
     if args.summary {
+        // 0.4.x compact slimming: `--summary` renders the five-line triage
+        // text via `format_status_summary`, which needs the full payload
+        // fields (coordinator, leader_receiver, agent_health, queued_messages,
+        // latest_results). The slim compact projection drops those, so the
+        // summary path must request the full payload (compact=false).
         let value = status_port::status_scoped(
             &selected.run_workspace,
             &selected.state,
             Some(&selected.team_key),
-            true,
+            false,
             false,
         )?;
         return Ok(CmdResult::human(append_reminder(

package/crates/team-agent/src/cli/status_port.rs

@@ -601,39 +601,127 @@ use rusqlite::params;
         Ok(Value::Array(values))
     }
 
+    /// 0.4.x: slim default compact payload — exactly 7 top-level fields.
+    /// Diagnostic detail moves to `--detail`. Plan:
+    /// /Users/alauda/Documents/code/team-agent-public/.team/artifacts/status-compact-plan.md
     fn compact_status(full: Value) -> Value {
+        let not_ready = compact_not_ready(&full);
+        let ready = compact_ready(&full, &not_ready);
         json!({
+            "ok": true,
             "team": full.get("team").cloned().unwrap_or(Value::Null),
             "session_name": full.get("session_name").cloned().unwrap_or(Value::Null),
-            "leader_topology": full.get("leader_topology").cloned().unwrap_or_else(|| json!("managed")),
-            "is_external_leader": full.get("is_external_leader").cloned().unwrap_or(Value::Bool(false)),
             "leader_attach_command": full.get("leader_attach_command").cloned().unwrap_or(Value::Null),
-            "leader_client": full.get("leader_client").cloned().unwrap_or(Value::Null),
-            "tmux_session_present": full.get("tmux_session_present").cloned().unwrap_or(Value::Bool(false)),
-            "all_spawned": full.get("all_spawned").cloned().unwrap_or(Value::Bool(false)),
-            "all_attached_receiver": full.get("all_attached_receiver").cloned().unwrap_or(Value::Bool(true)),
-            "all_resumable_have_session": full.get("all_resumable_have_session").cloned().unwrap_or(Value::Bool(true)),
-            "session_capture_complete": full.get("session_capture_complete").cloned().unwrap_or(Value::Bool(true)),
-            "session_capture_incomplete": full.get("session_capture_incomplete").cloned().unwrap_or(Value::Bool(false)),
-            "incomplete_session_capture_agents": full.get("incomplete_session_capture_agents").cloned().unwrap_or_else(|| json!([])),
-            "pending_session_agent_ids": full.get("pending_session_agent_ids").cloned().unwrap_or_else(|| json!([])),
-            "leader_receiver": compact_object(full.get("leader_receiver"), &[
-                "status", "provider", "mode", "session_name", "window_name", "pane_id", "pane_current_command",
-            ]),
+            "ready": ready,
+            "not_ready": not_ready,
             "agents": compact_agents(full.get("agents")),
-            "agent_health": full.get("agent_health").cloned().unwrap_or_else(|| json!({})),
-            "tasks": compact_tasks(full.get("tasks")),
-            "messages": full.get("messages").cloned().unwrap_or_else(|| json!({})),
-            "queued_messages": take_array(full.get("queued_messages"), 8),
-            "results": full.get("results").cloned().unwrap_or_else(|| json!({})),
-            "latest_results": take_array(full.get("latest_results"), 5),
-            "readiness": full.get("readiness").cloned().unwrap_or_else(|| json!({})),
-            "coordinator": compact_object(full.get("coordinator"), &["status", "pid", "metadata_ok", "schema_ok"]),
-            "reminder": full.get("reminder").cloned().unwrap_or_else(|| json!(crate::cli::STATUS_REMINDER)),
-            "last_events": take_array_tail(full.get("last_events"), 10),
         })
     }
 
+    /// Synthesized readiness boolean for the slim payload. Stricter than the
+    /// raw `readiness.ready` because it also folds in coordinator + schema +
+    /// tmux session presence so operators don't need to read separate booleans.
+    fn compact_ready(full: &Value, not_ready: &Value) -> bool {
+        not_ready.is_null()
+            && full
+                .get("readiness")
+                .and_then(|r| r.get("ready"))
+                .and_then(Value::as_bool)
+                .unwrap_or(false)
+            && full
+                .get("coordinator")
+                .and_then(|c| c.get("status"))
+                .and_then(Value::as_str)
+                .is_some_and(|s| s == "running" || s == "ok")
+            && full
+                .get("coordinator")
+                .and_then(|c| c.get("schema_ok"))
+                .and_then(Value::as_bool)
+                .unwrap_or(true)
+    }
+
+    /// Returns `Value::Null` when fully ready, otherwise an object:
+    /// `{"reasons": [...], "agents": [...]}` listing every gating issue.
+    fn compact_not_ready(full: &Value) -> Value {
+        let reasons = not_ready_reasons(full);
+        if reasons.is_empty() {
+            return Value::Null;
+        }
+        let agents = full
+            .get("incomplete_session_capture_agents")
+            .and_then(Value::as_array)
+            .cloned()
+            .or_else(|| {
+                full.get("pending_session_agent_ids")
+                    .and_then(Value::as_array)
+                    .cloned()
+            })
+            .unwrap_or_default();
+        let mut obj = Map::new();
+        obj.insert(
+            "reasons".to_string(),
+            Value::Array(reasons.into_iter().map(Value::String).collect()),
+        );
+        obj.insert("agents".to_string(), Value::Array(agents));
+        Value::Object(obj)
+    }
+
+    fn not_ready_reasons(full: &Value) -> Vec<String> {
+        let mut reasons = Vec::new();
+        let coord = full.get("coordinator");
+        let coord_status = coord
+            .and_then(|c| c.get("status"))
+            .and_then(Value::as_str)
+            .unwrap_or("");
+        if coord_status != "running" && coord_status != "ok" {
+            reasons.push("coordinator_not_running".to_string());
+        }
+        if coord
+            .and_then(|c| c.get("schema_ok"))
+            .and_then(Value::as_bool)
+            == Some(false)
+        {
+            reasons.push("coordinator_schema_not_ok".to_string());
+        }
+        if full
+            .get("tmux_session_present")
+            .and_then(Value::as_bool)
+            == Some(false)
+        {
+            reasons.push("tmux_session_missing".to_string());
+        }
+        let readiness = full.get("readiness");
+        if readiness
+            .and_then(|r| r.get("all_spawned"))
+            .and_then(Value::as_bool)
+            == Some(false)
+        {
+            reasons.push("workers_not_spawned".to_string());
+        }
+        if readiness
+            .and_then(|r| r.get("all_attached_receiver"))
+            .and_then(Value::as_bool)
+            == Some(false)
+        {
+            reasons.push("leader_receiver_unbound".to_string());
+        }
+        if readiness
+            .and_then(|r| r.get("session_capture_complete"))
+            .and_then(Value::as_bool)
+            == Some(false)
+        {
+            reasons.push("session_capture_incomplete".to_string());
+        }
+        if readiness
+            .and_then(|r| r.get("awaiting_trust_prompt"))
+            .and_then(Value::as_bool)
+            == Some(true)
+        {
+            reasons.push("awaiting_trust_prompt".to_string());
+        }
+        reasons
+    }
+
     fn compact_agents(value: Option<&Value>) -> Value {
         let Some(Value::Object(input)) = value else {
             return json!({});
@@ -645,56 +733,21 @@ use rusqlite::params;
         Value::Object(out)
     }
 
-    fn compact_agent_state(agent_id: &str, agent: &Value) -> Value {
+    /// 0.4.x: agent rows in the slim payload have exactly 4 fields. agent_id
+    /// is no longer copied in — the map key already carries it. Diagnostic
+    /// fields (model, tmux_window_present, session_id, captured_via,
+    /// attribution_confidence, display, interacted) move to `--detail`.
+    /// `activity` + `last_output_at` are preserved (RM-039-STAT-001).
+    fn compact_agent_state(_agent_id: &str, agent: &Value) -> Value {
         let Some(input) = agent.as_object() else {
             return json!({});
         };
         let mut out = Map::new();
-        out.insert(
-            "agent_id".to_string(),
-            input
-                .get("agent_id")
-                .cloned()
-                .unwrap_or_else(|| Value::String(agent_id.to_string())),
-        );
-        for key in [
-            "status",
-            "provider",
-            "model",
-            "tmux_window_present",
-            "session_id",
-            "captured_via",
-            "attribution_confidence",
-            // RM-039-STAT-001 fix (real-machine evidence 2026-06-22): the
-            // coordinator-tick activity classifier writes activity (status,
-            // confidence, rationale) to the top-level agent state, but the
-            // status --json compact projection dropped it. Operators saw
-            // "status: running" with no working/idle signal even when the
-            // pane was clearly producing output. Add the classifier output
-            // here so the compact form surfaces it.
-            // last_output_at is the timestamp the classifier advanced when
-            // the scrollback digest changed; keeping it adjacent to activity
-            // gives the operator a one-glance "is something moving" view.
-            // interacted is enriched in enrich_agents (true|false|never)
-            // and is the canonical "leader has ever sent this worker a
-            // message" signal — also needed for status sanity at a glance.
-            "activity",
-            "last_output_at",
-            "interacted",
-        ] {
+        for key in ["status", "provider", "activity", "last_output_at"] {
             if let Some(value) = input.get(key) {
                 out.insert(key.to_string(), value.clone());
             }
         }
-        if let Some(display) = input.get("display") {
-            let compact_display = compact_object(
-                Some(display),
-                &["backend", "status", "workspace_window", "pane_id", "pid", "pids", "reason"],
-            );
-            if compact_display.as_object().is_some_and(|obj| !obj.is_empty()) {
-                out.insert("display".to_string(), compact_display);
-            }
-        }
         Value::Object(out)
     }
 

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

@@ -36,7 +36,7 @@ use super::*;
     // projection MUST NOT collapse them.
     // =========================================================================
     #[test]
-    fn rm039_stat001_compact_status_preserves_activity_last_output_and_interacted() {
+    fn rm039_stat001_compact_status_preserves_activity_and_last_output() {
         let ws = seed_status_workspace();
         let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
         if let Some(agents) = state
@@ -99,13 +99,11 @@ use super::*;
             Some("2026-06-22T02:52:30+00:00"),
             "compact projection must preserve `last_output_at` for the \"is something moving\" view"
         );
-        // enrich_agents injects `interacted` from first_send_at; the
-        // compact path must carry it (operators read it as a one-glance
-        // \"has the leader ever sent this worker a message?\" signal).
-        assert_eq!(
-            agent.get("interacted").and_then(serde_json::Value::as_str),
-            Some("2026-01-01T00:00:00Z"),
-            "compact projection must preserve `interacted` from enrich_agents"
+        // 0.4.x compact slim: `interacted` moves to --detail; the 4-field
+        // compact agent row keeps only status/provider/activity/last_output_at.
+        assert!(
+            agent.get("interacted").is_none(),
+            "0.4.x: compact projection drops `interacted` (moved to --detail)"
         );
         let _ = std::fs::remove_dir_all(&ws);
     }
@@ -215,23 +213,37 @@ use super::*;
     #[test]
     fn status_port_status_compact_json_shape_against_seeded_fixture() {
         // cmd_status json branch (detail=false) delegates status_port::status(compact=true).
-        // compact_status (status/compact.py:8-37) projects to a STABLE key set; assert the
-        // load-bearing keys survive and `last_events` is bounded (compact truncates events).
+        // 0.4.x compact slim: exactly 7 top-level fields; diagnostics moved
+        // to --detail. Plan: .team/artifacts/status-compact-plan.md.
         let ws = seed_status_workspace();
         let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false)
             .expect("seeded fixture status should project a value");
         let obj = v.as_object().expect("--json status is a dict");
-        // compact_status's exact top-level key set (compact.py:9-37):
-        for key in [
+        // Exactly these 7 keys, no more.
+        let expected: std::collections::BTreeSet<&str> = [
+            "ok",
             "team",
             "session_name",
+            "leader_attach_command",
+            "ready",
+            "not_ready",
+            "agents",
+        ]
+        .iter()
+        .copied()
+        .collect();
+        let actual: std::collections::BTreeSet<&str> = obj.keys().map(String::as_str).collect();
+        assert_eq!(
+            actual, expected,
+            "0.4.x compact must expose exactly 7 keys; got {actual:?}"
+        );
+        // Diagnostic keys must NOT leak into the default compact payload.
+        for forbidden in [
             "leader_topology",
             "is_external_leader",
-            "leader_attach_command",
             "leader_client",
             "tmux_session_present",
             "leader_receiver",
-            "agents",
             "agent_health",
             "tasks",
             "messages",
@@ -239,23 +251,20 @@ use super::*;
             "results",
             "latest_results",
             "coordinator",
+            "readiness",
             "reminder",
             "last_events",
         ] {
-            assert!(obj.contains_key(key), "compact status missing key `{key}`");
+            assert!(
+                !obj.contains_key(forbidden),
+                "0.4.x: compact must NOT contain diagnostic key `{forbidden}` (--detail only)"
+            );
         }
-        assert_eq!(
-            obj.get("reminder").and_then(|v| v.as_str()),
-            Some(crate::cli::STATUS_REMINDER)
-        );
         // seeded agent surfaces through the projection.
         assert!(
             obj["agents"].as_object().unwrap().contains_key("a1"),
             "seeded agent a1 must appear in compact agents projection"
         );
-        // compact bounds: queued_messages[:8] and latest_results[:5] -> arrays.
-        assert!(obj["queued_messages"].is_array());
-        assert!(obj["latest_results"].as_array().unwrap().len() <= 5);
         let _ = std::fs::remove_dir_all(&ws);
     }
 
@@ -291,14 +300,17 @@ use super::*;
         }
         crate::state::persist::save_runtime_state(&ws, &state).unwrap();
 
-        let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
-
-        assert_eq!(v["leader_topology"], json!("managed"));
-        assert_eq!(v["is_external_leader"], json!(false));
-        let attach = v["leader_attach_command"]
+        // 0.4.x: leader_topology / is_external_leader moved to --detail.
+        // leader_attach_command stays in the slim compact payload.
+        let slim = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
+        let attach = slim["leader_attach_command"]
             .as_str()
-            .expect("managed status includes attach command");
+            .expect("compact still includes leader_attach_command");
         assert!(attach.contains("attach -t team-current:leader"), "{attach}");
+
+        let detail = status_port::status(&ws, /*compact=*/ false, /*detail=*/ true).expect("status detail");
+        assert_eq!(detail["leader_topology"], json!("managed"));
+        assert_eq!(detail["is_external_leader"], json!(false));
         let _ = std::fs::remove_dir_all(&ws);
     }
 
@@ -365,33 +377,48 @@ use super::*;
         }
         crate::state::persist::save_runtime_state(&ws, &state).unwrap();
 
-        let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
-
-        assert_eq!(v["leader_topology"], json!("managed"));
-        assert_eq!(v["is_external_leader"], json!(false));
-        let attach = v["leader_attach_command"]
+        // 0.4.x: topology/external markers moved to --detail; compact keeps attach.
+        let slim = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
+        let attach = slim["leader_attach_command"]
             .as_str()
             .expect("missing marker defaults to managed attach command");
         assert!(attach.contains("attach -t team-current:leader"), "{attach}");
+
+        let detail = status_port::status(&ws, /*compact=*/ false, /*detail=*/ true).expect("status detail");
+        assert_eq!(detail["leader_topology"], json!("managed"));
+        assert_eq!(detail["is_external_leader"], json!(false));
         let _ = std::fs::remove_dir_all(&ws);
     }
 
     #[test]
     fn status_port_status_detail_full_keeps_uncompacted_events() {
-        // cmd_status --json --detail -> status_port::status(compact=false): the FULL dict
-        // (queries.py:65-79) is returned WITHOUT compact_status truncation. Distinguishing
-        // invariant: full result preserves `tasks` rows verbatim (not compact_task-projected),
-        // so the seeded task's full row (incl. fields compact would drop) survives.
+        // 0.4.x: --detail (compact=false) preserves ALL diagnostic fields the
+        // compact slim payload drops. Pin the must-keep set so future
+        // refactors can't accidentally strip detail diagnostics.
         let ws = seed_status_workspace();
         let full = status_port::status(&ws, /*compact=*/ false, /*detail=*/ true)
             .expect("seeded fixture full status should project a value");
         let compact = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false)
             .expect("seeded fixture compact status should project a value");
-        // The CLI-owned invariant: detail=true => compact=false; the two projections MUST
-        // differ in shape (full carries `messages`/`results` count maps + verbatim tasks).
         assert_ne!(full, compact, "detail (full) and default (compact) projections must differ");
         let full_obj = full.as_object().expect("full status is a dict");
-        assert!(full_obj.contains_key("last_events"), "full status keeps last_events");
+        for key in [
+            "coordinator",
+            "readiness",
+            "leader_receiver",
+            "agent_health",
+            "tasks",
+            "messages",
+            "queued_messages",
+            "results",
+            "latest_results",
+            "last_events",
+        ] {
+            assert!(
+                full_obj.contains_key(key),
+                "0.4.x: --detail must preserve `{key}` (compact slimming escape hatch)"
+            );
+        }
         assert_eq!(full_obj["agents"].as_object().unwrap().len(), 1);
         let _ = std::fs::remove_dir_all(&ws);
     }
@@ -565,16 +592,15 @@ fn status_noncompact_coordinator_includes_ok() {
 }
 
 #[test]
-fn status_compact_coordinator_omits_ok() {
+fn status_compact_omits_coordinator_entirely() {
+    // 0.4.x compact slim: the entire `coordinator` block moved to --detail.
+    // Compact folds coordinator health into the top-level `ready`/`not_ready`
+    // synthesis (`coordinator_not_running` / `coordinator_schema_not_ok`).
     let ws = seed_status_workspace();
     let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
-    let coord = v.get("coordinator").and_then(|c| c.as_object()).expect("coordinator object");
-    let keys: std::collections::BTreeSet<&str> = coord.keys().map(String::as_str).collect();
-    let expected: std::collections::BTreeSet<&str> =
-        ["metadata_ok", "pid", "schema_ok", "status"].into_iter().collect();
-    assert_eq!(
-        keys, expected,
-        "compact coordinator key set must be EXACTLY {{metadata_ok,pid,schema_ok,status}} (no ok/metadata)"
+    assert!(
+        v.as_object().unwrap().get("coordinator").is_none(),
+        "0.4.x: compact must NOT include `coordinator`; reasons fold into not_ready"
     );
     let _ = std::fs::remove_dir_all(&ws);
 }

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

@@ -174,9 +174,14 @@ fn spine2_capture_missing_captures_session_id_for_missing_agent() {
     static N: AtomicU64 = AtomicU64::new(0);
     let tdir = std::env::temp_dir().join(format!("ta-rs-health-tx-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
     std::fs::create_dir_all(&tdir).unwrap();
+    // lane-046-capture-gap: Claude no-expected_session_id capture now requires
+    // positive_agent_id_match (TEAM_AGENT_ID=<id>) OR agent_path_match. Without
+    // a worker-identity signal, weak candidates can be leader transcripts and
+    // must not be attributed to a worker. The seeded transcript includes the
+    // TEAM_AGENT_ID marker for w1.
     std::fs::write(
         tdir.join("session.jsonl"),
-        r#"{"type":"user","sessionId":"sess-found","cwd":"x","message":{"content":"hi"}}"#,
+        r#"{"type":"user","sessionId":"sess-found","cwd":"x","message":{"content":"TEAM_AGENT_ID=w1 hi"}}"#,
     )
     .unwrap();
     let agents = serde_json::json!({

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

@@ -506,6 +506,50 @@ impl Coordinator {
         // operators unable to tell whether the failure was zero candidates,
         // multiple same-cwd candidates, stale pre-spawn candidates, or
         // expected-id miss. Architect §4 fix #4.
+        // 0.4.6 Stage 3: emit throttled `provider.session.transcript_missing`
+        // events for agents that transitioned into the transcript_missing
+        // capture_state on this pass. The capture pass only flags a
+        // transition (prev_state != next_state), so the event fires at
+        // most once per (agent_id, spawn_epoch) per state change.
+        for missing in &report.transcript_missing {
+            let agent = state
+                .get("agents")
+                .and_then(|a| a.get(missing.agent_id.as_str()));
+            let pane_id = agent
+                .and_then(|a| a.get("pane_id"))
+                .and_then(Value::as_str);
+            let pane_pid = agent.and_then(|a| a.get("pane_pid")).and_then(Value::as_u64);
+            let provider = agent.and_then(|a| a.get("provider")).and_then(Value::as_str);
+            let session_id_in_argv = agent
+                .and_then(|a| a.get("session_id_in_argv"))
+                .and_then(Value::as_str);
+            let first_send_at = agent
+                .and_then(|a| a.get("first_send_at"))
+                .and_then(Value::as_str);
+            let last_result_at = agent
+                .and_then(|a| a.get("last_result_at"))
+                .and_then(Value::as_str);
+            let last_pane_output_at = agent
+                .and_then(|a| a.get("last_pane_output_at"))
+                .and_then(Value::as_str);
+            event_log.write(
+                "provider.session.transcript_missing",
+                serde_json::json!({
+                    "agent_id": missing.agent_id,
+                    "provider": provider,
+                    "pane_id": pane_id,
+                    "pane_pid": pane_pid,
+                    "spawn_epoch": missing.spawn_epoch,
+                    "expected_session_id": missing.expected_session_id,
+                    "session_id_in_argv": session_id_in_argv,
+                    "spawn_cwd": missing.spawn_cwd,
+                    "candidate_count": missing.candidate_count,
+                    "first_send_at": first_send_at,
+                    "last_result_at": last_result_at,
+                    "last_pane_output_at": last_pane_output_at,
+                }),
+            )?;
+        }
         for ambiguous in report.ambiguous {
             let candidate_count = report
                 .candidate_count_by_agent
@@ -1612,16 +1656,7 @@ fn turn_state_wire(state: TurnState) -> &'static str {
     }
 }
 
-fn provider_wire(provider: crate::model::enums::Provider) -> &'static str {
-    match provider {
-        crate::model::enums::Provider::Claude => "claude",
-        crate::model::enums::Provider::ClaudeCode => "claude_code",
-        crate::model::enums::Provider::Codex => "codex",
-        crate::model::enums::Provider::Copilot => "copilot",
-        crate::model::enums::Provider::GeminiCli => "gemini_cli",
-        crate::model::enums::Provider::Fake => "fake",
-    }
-}
+use crate::provider::wire::provider_wire;
 
 #[derive(Debug, Clone)]
 struct AbnormalWatchAgent {
@@ -2365,17 +2400,7 @@ fn monotonic_seconds() -> f64 {
     }
 }
 
-fn parse_provider(raw: &str) -> Option<crate::model::enums::Provider> {
-    match raw {
-        "claude" => Some(crate::model::enums::Provider::Claude),
-        "claude_code" => Some(crate::model::enums::Provider::ClaudeCode),
-        "codex" => Some(crate::model::enums::Provider::Codex),
-        "copilot" => Some(crate::model::enums::Provider::Copilot),
-        "gemini_cli" => Some(crate::model::enums::Provider::GeminiCli),
-        "fake" => Some(crate::model::enums::Provider::Fake),
-        _ => None,
-    }
-}
+use crate::provider::wire::parse_provider;
 
 fn capture_window_target(
     agent: &Value,

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

@@ -9,28 +9,7 @@ use crate::provider::{Provider, RolloutPath, TurnState};
 
 use super::LeaderError;
 
-pub(crate) fn provider_wire(provider: Provider) -> &'static str {
-    match provider {
-        Provider::Claude => "claude",
-        Provider::ClaudeCode => "claude_code",
-        Provider::Codex => "codex",
-        Provider::Copilot => "copilot",
-        Provider::GeminiCli => "gemini_cli",
-        Provider::Fake => "fake",
-    }
-}
-
-pub(crate) fn parse_provider(s: &str) -> Option<Provider> {
-    match s {
-        "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,
-    }
-}
+pub(crate) use crate::provider::wire::{parse_provider, provider_wire};
 
 pub(crate) fn turn_state_wire(state: TurnState) -> &'static str {
     match state {