@team-agent/installer 0.5.66 → 0.5.69

package/Cargo.lock

@@ -325,6 +325,12 @@ version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
+[[package]]
+name = "md5"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
+
 [[package]]
 name = "memchr"
 version = "2.8.0"
@@ -575,12 +581,13 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.66"
+version = "0.5.69"
 dependencies = [
  "anyhow",
  "chrono",
  "conpty-transport",
  "libc",
+ "md5",
  "regex",
  "rusqlite",
  "serde",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.66"
+version = "0.5.69"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/Cargo.toml

@@ -22,6 +22,7 @@ thiserror.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 sha2.workspace = true
+md5 = "0.7"
 regex.workspace = true
 chrono.workspace = true
 libc.workspace = true

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

@@ -1536,6 +1536,11 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
             args.team.as_deref(),
             &mut value,
         );
+        crate::cli::diagnose::append_registry_channel_unbound_to_report(
+            &args.workspace,
+            args.team.as_deref(),
+            &mut value,
+        );
         value
     };
     Ok(CmdResult::from_json(value, args.json))

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

@@ -9,6 +9,74 @@ use crate::model::pane_authority_refusal::{
 use crate::provider::wire::{command_name, parse_provider, provider_wire};
 use crate::transport::Transport;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "snake_case")]
+pub(crate) enum PiBackingStatus {
+    Pending,
+    Captured,
+    Missing,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "snake_case")]
+pub(crate) enum PiMcpStatus {
+    Unavailable,
+    ConfiguredLazy,
+    RoundtripVerified,
+}
+
+pub(crate) struct PiDoctorInput {
+    pub executable_chain_verified: bool,
+    pub pi_version: Option<String>,
+    pub adapter_version: Option<String>,
+    pub catalog_sha256: Option<String>,
+    pub selected_model: Option<String>,
+    pub candidate_executable: Option<std::path::PathBuf>,
+    pub wrapper: Option<std::path::PathBuf>,
+    pub mcp_roundtrip_at: Option<String>,
+    pub backing: PiBackingStatus,
+    pub activity: crate::provider::TurnState,
+    pub activity_source: crate::provider::ClassifySource,
+    pub env_key_names: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+pub(crate) struct PiDoctorFacts {
+    pub mcp: PiMcpStatus,
+    pub mcp_connected: bool,
+    pub backing: PiBackingStatus,
+    pub activity: crate::provider::TurnState,
+    pub activity_source: crate::provider::ClassifySource,
+    pub auth_hint: crate::provider::AuthHintStatus,
+}
+
+pub(crate) fn pi_doctor_facts(input: PiDoctorInput) -> PiDoctorFacts {
+    let mcp = if input.mcp_roundtrip_at.is_some() {
+        PiMcpStatus::RoundtripVerified
+    } else if input.wrapper.is_some() {
+        PiMcpStatus::ConfiguredLazy
+    } else {
+        PiMcpStatus::Unavailable
+    };
+    let _ = (
+        input.executable_chain_verified,
+        input.pi_version,
+        input.adapter_version,
+        input.catalog_sha256,
+        input.selected_model,
+        input.candidate_executable,
+        input.env_key_names,
+    );
+    PiDoctorFacts {
+        mcp,
+        mcp_connected: mcp == PiMcpStatus::RoundtripVerified,
+        backing: input.backing,
+        activity: input.activity,
+        activity_source: input.activity_source,
+        auth_hint: crate::provider::AuthHintStatus::Unknown,
+    }
+}
+
 /// 0.5.39 Slice 1 (tmux-server-death-locate §11.1 B): classify a tmux
 /// transport error string into a diagnose issue id. When the underlying
 /// tmux subprocess stderr contains `server exited unexpectedly`, the
@@ -208,12 +276,45 @@ pub(crate) fn diagnose_runtime_for_workspace(
         &mut issues,
         &mut repairs,
     );
+    append_registry_channel_unbound_issue(workspace, state, &mut issues, &mut repairs);
     append_legacy_snapshot_issue(workspace, state, &mut issues);
     append_coordinator_health_issue(workspace, state, &mut issues, &mut repairs);
     append_runtime_bindings_stale_after_boot_issue(workspace, state, &mut issues, &mut repairs);
     (issues, repairs)
 }
 
+fn append_registry_channel_unbound_issue(
+    workspace: &std::path::Path,
+    state: &Value,
+    issues: &mut Value,
+    repairs: &mut Value,
+) {
+    let team_key = crate::state::projection::team_state_key(state);
+    if team_key.is_empty()
+        || crate::lifecycle::launch::launched_team_receiver_is_attached(workspace, &team_key)
+    {
+        return;
+    }
+    if let Some(items) = issues.as_array_mut() {
+        if !items.iter().any(|item| {
+            item.as_str() == Some("leader_not_attached")
+                || item.get("id").and_then(Value::as_str) == Some("leader_channel_unbound")
+        }) {
+            items.push(json!("leader_not_attached"));
+        }
+    }
+    if let Some(items) = repairs.as_array_mut() {
+        items.push(recovery_hint(
+            state
+                .get("session_name")
+                .and_then(Value::as_str)
+                .unwrap_or(team_key.as_str()),
+            "leader_not_attached",
+            "team-agent claim-leader",
+        ));
+    }
+}
+
 fn append_live_leader_workspace_mismatch_issue(
     workspace: &std::path::Path,
     state: &Value,
@@ -339,6 +440,53 @@ fn live_leader_workspace_mismatch(
     Some((issue, repair))
 }
 
+pub(crate) fn append_registry_channel_unbound_to_report(
+    workspace: &std::path::Path,
+    team: Option<&str>,
+    report: &mut Value,
+) {
+    let team_key = team
+        .filter(|team| !team.is_empty())
+        .map(str::to_string)
+        .or_else(|| {
+            crate::state::persist::load_runtime_state(workspace)
+                .ok()
+                .map(|state| crate::state::projection::team_state_key(&state))
+        })
+        .unwrap_or_default();
+    if team_key.is_empty()
+        || crate::lifecycle::launch::launched_team_receiver_is_attached(workspace, &team_key)
+    {
+        return;
+    }
+    let Some(object) = report.as_object_mut() else {
+        return;
+    };
+    let mut issues = object
+        .get("issues")
+        .and_then(Value::as_array)
+        .cloned()
+        .unwrap_or_default();
+    if !issues.iter().any(|item| {
+        item.as_str() == Some("leader_not_attached")
+            || item.get("id").and_then(Value::as_str) == Some("leader_channel_unbound")
+    }) {
+        issues.push(json!("leader_not_attached"));
+    }
+    object.insert("issues".to_string(), Value::Array(issues));
+    let mut repairs = object
+        .get("suggested_repairs")
+        .and_then(Value::as_array)
+        .cloned()
+        .unwrap_or_default();
+    repairs.push(recovery_hint(
+        &team_key,
+        "leader_not_attached",
+        "team-agent claim-leader",
+    ));
+    object.insert("suggested_repairs".to_string(), Value::Array(repairs));
+}
+
 pub(crate) fn append_selected_live_leader_workspace_mismatch(
     workspace: &std::path::Path,
     team: Option<&str>,
@@ -1344,6 +1492,11 @@ fn fake_agent_started(agent: &Value) -> bool {
 }
 
 fn agent_mcp_ready(agent: &Value) -> bool {
+    if agent.get("provider").and_then(Value::as_str) == Some("pi") {
+        // The generated wrapper proves configured-lazy only. No persisted
+        // objective Pi MCP roundtrip receipt exists on the readiness path yet.
+        return false;
+    }
     agent
         .get("mcp_config")
         .and_then(Value::as_str)
@@ -1485,6 +1638,9 @@ pub(crate) fn provider_doctor_checks() -> Value {
         crate::provider::Provider::ClaudeCode,
         crate::provider::Provider::Codex,
         crate::provider::Provider::GeminiCli,
+        crate::provider::Provider::Grok,
+        crate::provider::Provider::CursorAgent,
+        crate::provider::Provider::Pi,
         crate::provider::Provider::Fake,
     ] {
         let adapter = crate::provider::get_adapter(provider);

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

@@ -45,7 +45,7 @@ fn emit_with_json_order(
 }
 
 ///
-/// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude/copilot passthrough 早返回 →
+/// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude/copilot/grok/cursor passthrough 早返回 →
 /// 解析 argv 到 subcommand → 调对应 handler → 异常落盘 + 信封 + `ExitCode::Error` →
 /// `consume_leader_inbox_summary` → `emit` → `result.ok is False ? Error : Ok`。
 /// **行为入口**:契约可端到端跑 argv→(stdout, exit code)。
@@ -262,9 +262,10 @@ const DISPATCH_COMMANDS: &[&str] = &[
 const SPEC_ONLY_HELP_COMMANDS: &[&str] = &["start"];
 // Command grammar, not provider identity parsing: these are top-level CLI
 // passthrough verbs for starting a leader under a provider executable.
-const LEADER_PASSTHROUGH_COMMANDS: &[&str] = &["codex", "claude", "copilot"];
+const LEADER_PASSTHROUGH_COMMANDS: &[&str] =
+    &["codex", "claude", "copilot", "grok", "cursor", "pi"];
 
-fn is_leader_passthrough_command(command: &str) -> bool {
+pub(crate) fn is_leader_passthrough_command(command: &str) -> bool {
     LEADER_PASSTHROUGH_COMMANDS.contains(&command)
         && matches!(
             command_spec(command).map(|spec| spec.kind),
@@ -285,7 +286,7 @@ fn is_known_subcommand(command: &str) -> bool {
     command_spec(command).is_some_and(|spec| spec.command_help)
 }
 
-fn default_help() -> String {
+pub(crate) fn default_help() -> String {
     let mut out = String::from("usage: team-agent <command> [options]\n");
     append_help_section(
         &mut out,
@@ -310,7 +311,7 @@ fn default_help() -> String {
         "Guided recovery",
         &["claim-leader", "takeover", "attach-leader"],
     );
-    out.push_str("\nProvider launchers:\n  team-agent codex|claude|copilot ...\n");
+    out.push_str("\nProvider launchers:\n  team-agent codex|claude|copilot|grok|cursor|pi ...\n");
     out.push_str("\nRun `team-agent <command> --help` for command flags.");
     out
 }

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

@@ -0,0 +1,299 @@
+//! ---
+//! purpose: 对账 .grok/config.toml 残余共享槽与在役 grok 席，含未首 turn 危险窗
+//! contract:
+//!   provides:
+//!     - name: grok_slot_report
+//!       what: 盘上 ID/OWNER/AUTH、在役 grok、pre_first_turn；读不出为 unjudgeable
+//! boundary:
+//!   - 读不出不报一致
+//!   - 不写盘、不改 overlay
+//! maturity: wired
+//! ---
+
+use serde_json::{json, Value};
+use std::path::Path;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct GrokSlotReport {
+    pub readable: bool,
+    pub consistent: bool,
+    pub disk_team_agent_id: Option<String>,
+    pub disk_owner_team_id: Option<String>,
+    pub disk_auth_mode: Option<String>,
+    pub expected_owner_team_id: Option<String>,
+    pub expected_auth_mode: Option<String>,
+    pub live_seats: Vec<String>,
+    pub pre_first_turn: Vec<String>,
+    pub reason: String,
+}
+
+impl GrokSlotReport {
+    pub(crate) fn to_json(&self) -> Value {
+        json!({
+            "readable": self.readable,
+            "consistent": self.consistent,
+            "disk_team_agent_id": self.disk_team_agent_id,
+            "disk_owner_team_id": self.disk_owner_team_id,
+            "disk_auth_mode": self.disk_auth_mode,
+            "expected_owner_team_id": self.expected_owner_team_id,
+            "expected_auth_mode": self.expected_auth_mode,
+            "live_seats": self.live_seats,
+            "pre_first_turn": self.pre_first_turn,
+            "reason": self.reason,
+        })
+    }
+}
+
+pub(crate) fn grok_slot_report(workspace: &Path, state: &Value) -> GrokSlotReport {
+    if let Some(reason) = unreadable_state_reason(workspace, state) {
+        return unjudgeable(reason, Vec::new(), Vec::new());
+    }
+    let live = live_grok_from_state(state);
+    let pre_first_turn = live
+        .iter()
+        .filter(|seat| seat.pre_first_turn)
+        .map(|seat| seat.id.clone())
+        .collect::<Vec<_>>();
+    let live_ids = live.iter().map(|seat| seat.id.clone()).collect::<Vec<_>>();
+    let expected_owner = expected_owner_team_id(state);
+    let expected_auth = expected_auth_mode(&live);
+
+    let toml_path = workspace.join(".grok").join("config.toml");
+    if toml_path.exists() {
+        match std::fs::read_to_string(&toml_path) {
+            Err(error) => {
+                return unjudgeable(
+                    format!("unjudgeable: cannot read {} ({error})", toml_path.display()),
+                    live_ids,
+                    pre_first_turn,
+                );
+            }
+            Ok(text) => {
+                let disk = parse_disk_slot(&text);
+                return classify(disk, live_ids, pre_first_turn, expected_owner, expected_auth);
+            }
+        }
+    }
+    classify(
+        DiskSlot::default(),
+        live_ids,
+        pre_first_turn,
+        expected_owner,
+        expected_auth,
+    )
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+struct DiskSlot {
+    team_agent_id: Option<String>,
+    owner_team_id: Option<String>,
+    auth_mode: Option<String>,
+    extras: Vec<(String, String)>,
+}
+
+fn parse_disk_slot(text: &str) -> DiskSlot {
+    let keys = crate::lifecycle::launch::per_seat_keys_in_toml(text);
+    DiskSlot {
+        team_agent_id: find_key(&keys, "TEAM_AGENT_ID"),
+        owner_team_id: find_key(&keys, "TEAM_AGENT_OWNER_TEAM_ID"),
+        auth_mode: find_key(&keys, "TEAM_AGENT_AUTH_MODE"),
+        extras: keys
+            .into_iter()
+            .filter(|(key, _)| {
+                key != "TEAM_AGENT_ID"
+                    && key != "TEAM_AGENT_OWNER_TEAM_ID"
+                    && key != "TEAM_AGENT_AUTH_MODE"
+            })
+            .collect(),
+    }
+}
+
+fn find_key(keys: &[(String, String)], want: &str) -> Option<String> {
+    keys.iter()
+        .find(|(key, _)| key == want)
+        .map(|(_, value)| value.clone())
+}
+
+fn unjudgeable(
+    reason: String,
+    live_seats: Vec<String>,
+    pre_first_turn: Vec<String>,
+) -> GrokSlotReport {
+    GrokSlotReport {
+        readable: false,
+        consistent: false,
+        disk_team_agent_id: None,
+        disk_owner_team_id: None,
+        disk_auth_mode: None,
+        expected_owner_team_id: None,
+        expected_auth_mode: None,
+        live_seats,
+        pre_first_turn,
+        reason,
+    }
+}
+
+fn unreadable_state_reason(workspace: &Path, state: &Value) -> Option<String> {
+    let path = workspace.join(".team").join("runtime").join("state.json");
+    if !path.exists() {
+        return None;
+    }
+    match std::fs::read_to_string(&path) {
+        Err(error) => Some(format!(
+            "unjudgeable: cannot read {} ({error})",
+            path.display()
+        )),
+        Ok(text) => match serde_json::from_str::<Value>(&text) {
+            Err(error) => Some(format!(
+                "unjudgeable: cannot parse {} ({error})",
+                path.display()
+            )),
+            Ok(_) if state.is_null() => {
+                Some("unjudgeable: runtime state exists but could not be loaded".to_string())
+            }
+            Ok(_) => None,
+        },
+    }
+}
+
+fn classify(
+    disk: DiskSlot,
+    live_ids: Vec<String>,
+    pre_first_turn: Vec<String>,
+    expected_owner: Option<String>,
+    expected_auth: Option<String>,
+) -> GrokSlotReport {
+    let mut mismatches = Vec::new();
+    if let Some(disk_id) = disk.team_agent_id.as_deref() {
+        mismatches.push(format!("per-seat key TEAM_AGENT_ID={disk_id}"));
+    }
+    if let Some(disk_owner) = disk.owner_team_id.as_deref() {
+        mismatches.push(format!("per-seat key TEAM_AGENT_OWNER_TEAM_ID={disk_owner}"));
+    }
+    if let Some(disk_auth) = disk.auth_mode.as_deref() {
+        mismatches.push(format!("per-seat key TEAM_AGENT_AUTH_MODE={disk_auth}"));
+    }
+    for (key, value) in &disk.extras {
+        mismatches.push(format!("per-seat key {key}={value}"));
+    }
+
+    if mismatches.is_empty() {
+        let reason =
+            "toml carries no per-seat identity keys; identity inherits from pane env".to_string();
+        return GrokSlotReport {
+            readable: true,
+            consistent: true,
+            disk_team_agent_id: disk.team_agent_id,
+            disk_owner_team_id: disk.owner_team_id,
+            disk_auth_mode: disk.auth_mode,
+            expected_owner_team_id: expected_owner,
+            expected_auth_mode: expected_auth,
+            live_seats: live_ids,
+            pre_first_turn,
+            reason,
+        };
+    }
+
+    GrokSlotReport {
+        readable: true,
+        consistent: false,
+        disk_team_agent_id: disk.team_agent_id,
+        disk_owner_team_id: disk.owner_team_id,
+        disk_auth_mode: disk.auth_mode,
+        expected_owner_team_id: expected_owner,
+        expected_auth_mode: expected_auth,
+        live_seats: live_ids,
+        pre_first_turn,
+        reason: format!("grok slot mismatch: {}", mismatches.join("; ")),
+    }
+}
+
+struct LiveGrok {
+    id: String,
+    pre_first_turn: bool,
+    auth_mode: Option<String>,
+}
+
+fn live_grok_from_state(state: &Value) -> Vec<LiveGrok> {
+    let mut out = Vec::new();
+    push_live_from_map(state.get("agents").and_then(Value::as_object), &mut out);
+    if let Some(teams) = state.get("teams").and_then(Value::as_object) {
+        for team in teams.values() {
+            push_live_from_map(team.get("agents").and_then(Value::as_object), &mut out);
+        }
+    }
+    out
+}
+
+fn push_live_from_map(agents: Option<&serde_json::Map<String, Value>>, out: &mut Vec<LiveGrok>) {
+    let Some(agents) = agents else {
+        return;
+    };
+    for (id, agent) in agents {
+        if out.iter().any(|row| row.id == *id) {
+            continue;
+        }
+        let provider = agent.get("provider").and_then(Value::as_str).unwrap_or("");
+        if provider != "grok" {
+            continue;
+        }
+        let status = agent
+            .get("status")
+            .and_then(Value::as_str)
+            .unwrap_or("running");
+        if matches!(
+            status,
+            "stopped" | "stopping" | "removed" | "spawn_failed" | "failed"
+        ) {
+            continue;
+        }
+        let first = agent
+            .get("first_send_at")
+            .and_then(Value::as_str)
+            .filter(|s| !s.is_empty());
+        out.push(LiveGrok {
+            id: id.clone(),
+            pre_first_turn: first.is_none(),
+            auth_mode: agent_auth_mode(agent),
+        });
+    }
+}
+
+fn agent_auth_mode(agent: &Value) -> Option<String> {
+    match agent.get("auth_mode") {
+        Some(Value::String(s)) if !s.trim().is_empty() => Some(s.clone()),
+        Some(other) if !other.is_null() => Some(other.to_string().trim_matches('"').to_string()),
+        _ => None,
+    }
+}
+
+fn expected_owner_team_id(state: &Value) -> Option<String> {
+    for key in ["active_team_key", "team_key", "TEAM_AGENT_OWNER_TEAM_ID"] {
+        if let Some(value) = state
+            .get(key)
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+        {
+            return Some(value.to_string());
+        }
+    }
+    None
+}
+
+fn expected_auth_mode(live: &[LiveGrok]) -> Option<String> {
+    let mut found = None;
+    for seat in live {
+        let Some(auth) = seat.auth_mode.as_deref() else {
+            continue;
+        };
+        match found {
+            None => found = Some(auth.to_string()),
+            Some(ref existing) if existing != auth => return None,
+            Some(_) => {}
+        }
+    }
+    found
+}
+
+

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

@@ -1,5 +1,5 @@
 //!
-//! cli · leader — `codex`/`claude`/`copilot` passthrough(`cmd_leader_passthrough` + `_provider_args` /
+//! cli · leader — `codex`/`claude`/`copilot`/`grok`/`cursor` passthrough(`cmd_leader_passthrough` + `_provider_args` /
 //! `_leader_launcher_args`)+ leader fallback inbox 摘要(`consume_leader_inbox_summary` 及
 //! `_leader_inbox_entries` / `_leader_inbox_summary` / `_leader_inbox_entry_title`)。
 
@@ -96,9 +96,9 @@ fn without_leader_json(values: &[String]) -> Vec<String> {
 }
 
 ///
-/// `codex`/`claude`/`copilot` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
+/// `codex`/`claude`/`copilot`/`grok`/`cursor` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
 /// **不**进 subparser。`-h`/`--help` 打 usage 直接返回 [`CmdResult::none`]。否则解析 attach
-/// 旗标 + `lifecycle_port::start_leader`。`command` ∈ {codex, claude, copilot}。
+/// 旗标 + `lifecycle_port::start_leader`。`command` 必须是闭集动词,禁止 command-text 回落到 ClaudeCode。
 pub fn cmd_leader_passthrough(
     command: &str,
     provider_args: &[String],
@@ -110,14 +110,29 @@ pub fn cmd_leader_passthrough(
     let as_json = leader_launcher_json(provider_args);
     let launcher_args = without_leader_json(provider_args);
     let attach = leader_launcher_args(&launcher_args)?;
-    let provider = leader_passthrough_provider(command);
+    let provider = leader_passthrough_provider(command).ok_or_else(|| {
+        CliError::Usage(format!(
+            "unknown leader passthrough command: {command}"
+        ))
+    })?;
     let value = lifecycle_port::start_leader(provider, &attach.provider_args, cwd, &attach)?;
     Ok(CmdResult::from_json(value, as_json))
 }
 
-pub(crate) fn leader_passthrough_provider(command: &str) -> crate::model::enums::Provider {
-    crate::leader::attribute_command_provider(command)
-        .unwrap_or(crate::model::enums::Provider::ClaudeCode)
+/// Closed-set verb → Provider. `None` = not a passthrough verb (must not become ClaudeCode).
+pub(crate) fn leader_passthrough_provider(
+    command: &str,
+) -> Option<crate::model::enums::Provider> {
+    use crate::model::enums::Provider;
+    match command {
+        "codex" => Some(Provider::Codex),
+        "claude" => Some(Provider::ClaudeCode),
+        "copilot" => Some(Provider::Copilot),
+        "grok" => Some(Provider::Grok),
+        "cursor" => Some(Provider::CursorAgent),
+        "pi" => Some(Provider::Pi),
+        _ => None,
+    }
 }
 
 // =============================================================================