@team-agent/installer 0.5.107 → 0.5.109

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.107"
+version = "0.5.109"
 dependencies = [
  "anyhow",
  "chrono",

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.107"
+version = "0.5.109"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -218,7 +218,7 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
         }
     }
     // Status brief is deliberately independent of the legacy RuntimeSnapshot:
-    // it performs one native tmux/process sample and exposes exactly seven
+    // it performs one native tmux/process sample and exposes exactly nine
     // fields. `--summary` and `--detail` remain parser-compatible but do not
     // re-enable history, runtime diagnostics, or reminder text.
     if args.json {

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

@@ -290,7 +290,7 @@ pub(crate) fn default_help() -> String {
         &["claim-leader", "takeover", "attach-leader"],
     );
     out.push_str("\nWorkflow: `team-agent models --provider pi`, then quick-start/add-agent/start-agent, then `team-agent send AGENT MESSAGE`.\n");
-    out.push_str("Model catalogs: pi, cursor_agent, codex, claude, claude_code.\n");
+    out.push_str("Model catalogs: pi, cursor_agent, codex, claude, claude_code, grok.\n");
     out.push_str("Provider launchers:\n  team-agent codex|claude|copilot|grok|cursor|pi ...\n");
     out.push_str("\nRun `team-agent <command> --help` for command flags.");
     out
@@ -340,8 +340,8 @@ fn command_help(command: Option<&str>) -> String {
         )
         .to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
-        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出九字段：name/provider/model/effort/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。model/effort 为已接受启动配置，未设置为 null，不猜 provider 默认值。缺少可靠定位或原生 tmux/process 采样时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
-        Some("models") => "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code] [QUERY|--search TEXT] [--json]\n\nLists exact provider model ids with case-insensitive multi-word search across provider, vendor, id, display name, and source aliases. Uses each provider's native catalog; Codex uses `codex debug models` and Claude uses SDK stream-json initialize.".to_string(),
+        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出九字段：name/provider/model/effort/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影字段（多节点人读紧凑显示 tmux_command）。--json 始终保留每节点完整可复制的 tmux_command；人读单节点保留完整旧格式，多节点按(socket, tmux session)显示每组一次共享 attach 模板，ATTACH列为<group>:<window>.<pane>，模板中的 <target> 替换为其 window.pane 部分。model/effort 为已接受启动配置，未设置为 null，不猜 provider 默认值；缺少可靠定位或原生 tmux/process 采样时显示 unknown，不推导attach信息。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
+        Some("models") => "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code|grok] [QUERY|--search TEXT] [--json]\n\nLists exact provider model ids with case-insensitive multi-word search across provider, vendor, id, display name, and source aliases. Uses each provider's native catalog; Cursor uses `agent --list-models`, Codex uses `codex debug models`, Claude uses SDK stream-json initialize, and Grok uses the PATH-first `grok models` command.".to_string(),
         Some("leaders") => "usage: team-agent leaders [QUERY|--search TEXT] [--all|--stale] [--json] | --prune [--dry-run] [--json]\n\nLists LIVE leaders by default. Use --all to include retained STALE entries, --stale to inspect only STALE entries, QUERY or --search TEXT to match workspace/team/name fields, and --prune to remove only entries proven terminal by canonical state. --dry-run is valid only with --prune.".to_string(),
         Some("shutdown") => "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
         Some("restart") => "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json] [--detail]".to_string(),

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

@@ -1358,6 +1358,13 @@ pub mod lifecycle_port {
             .map(|path| json!({ "path": path }))
             .collect::<Vec<_>>();
         deadline.check("process_residuals")?;
+        // Let already-protected-filtered shutdown roots converge before the final
+        // snapshot, so a transient OS reaping window is not reported as a residue.
+        wait_for_processes_gone(
+            &root_pids,
+            std::time::Duration::from_millis(500).min(deadline.remaining()),
+        );
+        deadline.check("process_residuals")?;
         // C-①: the post-verify gets ONE fresh verification snapshot (reaps changed
         // the world; #248 post-verify facts must be current, not the entry view).
         let verify_table =
@@ -1936,6 +1943,10 @@ pub mod lifecycle_port {
             }
             Ok(())
         }
+
+        fn remaining(&self) -> std::time::Duration {
+            self.timeout.saturating_sub(self.start.elapsed())
+        }
     }
 
     fn shutdown_state_for_team(workspace: &Path, team: Option<&str>) -> Result<Value, CliError> {
@@ -2239,9 +2250,70 @@ pub mod lifecycle_port {
         }
     }
 
+    #[cfg(test)]
+    #[derive(Clone, Copy)]
+    struct ShutdownTestProbes {
+        process_table: Option<fn() -> Result<Vec<String>, String>>,
+        pid_is_alive: Option<fn(u32) -> bool>,
+    }
+
+    #[cfg(test)]
+    std::thread_local! {
+        static SHUTDOWN_TEST_PROBES: std::cell::Cell<ShutdownTestProbes> = const {
+            std::cell::Cell::new(ShutdownTestProbes { process_table: None, pid_is_alive: None })
+        };
+    }
+
+    #[cfg(test)]
+    struct ShutdownTestProbeRestore(ShutdownTestProbes);
+
+    #[cfg(test)]
+    impl Drop for ShutdownTestProbeRestore {
+        fn drop(&mut self) {
+            SHUTDOWN_TEST_PROBES.with(|probes| probes.set(self.0));
+        }
+    }
+
+    #[cfg(test)]
+    pub(super) fn with_process_table_test_probe<T>(
+        probe: fn() -> Result<Vec<String>, String>,
+        run: impl FnOnce() -> T,
+    ) -> T {
+        let previous = SHUTDOWN_TEST_PROBES.with(|probes| {
+            let previous = probes.get();
+            probes.set(ShutdownTestProbes { process_table: Some(probe), ..previous });
+            previous
+        });
+        let _restore = ShutdownTestProbeRestore(previous);
+        run()
+    }
+
+    #[cfg(test)]
+    pub(super) fn with_pid_liveness_test_probe<T>(
+        probe: fn(u32) -> bool,
+        run: impl FnOnce() -> T,
+    ) -> T {
+        let previous = SHUTDOWN_TEST_PROBES.with(|probes| {
+            let previous = probes.get();
+            probes.set(ShutdownTestProbes { pid_is_alive: Some(probe), ..previous });
+            previous
+        });
+        let _restore = ShutdownTestProbeRestore(previous);
+        run()
+    }
+
     /// swallow batch 1: the raw ps probe with an explicit error channel — a failed
     /// probe must never masquerade as "no processes" (CLAUDE.md §5).
     fn probed_process_table() -> Result<Vec<ProcessInfo>, String> {
+        #[cfg(test)]
+        if let Some(probe) = SHUTDOWN_TEST_PROBES.with(|probes| probes.get().process_table) {
+            return probe().map(|lines| {
+                lines
+                    .iter()
+                    .filter_map(|line| parse_process_info(line))
+                    .collect()
+            });
+        }
         match crate::os_probe::bounded_command_output_with_probe(
             std::process::Command::new("ps").args(["-axo", "pid=,ppid=,pgid=,sess=,command="]),
             "ps_table",
@@ -2696,20 +2768,31 @@ pub mod lifecycle_port {
     // 1:1 to SIGTERM/SIGKILL, ProcessLiveness::Live == the previous
     // `kill(pid, 0) == 0 || EPERM` branch).
 
+    fn shutdown_pid_is_alive(pid: u32) -> bool {
+        #[cfg(test)]
+        if let Some(probe) = SHUTDOWN_TEST_PROBES.with(|probes| probes.get().pid_is_alive) {
+            return probe(pid);
+        }
+        crate::platform::process::pid_is_alive(pid)
+    }
+
     fn wait_for_processes_gone(pids: &[u32], timeout: std::time::Duration) {
         let start = std::time::Instant::now();
         loop {
             for pid in pids {
                 crate::platform::process::reap_child_if_possible(*pid);
             }
+            let elapsed = start.elapsed();
             if !pids
                 .iter()
-                .any(|pid| crate::platform::process::pid_is_alive(*pid))
-                || start.elapsed() >= timeout
+                .any(|pid| shutdown_pid_is_alive(*pid))
+                || elapsed >= timeout
             {
                 return;
             }
-            std::thread::sleep(std::time::Duration::from_millis(25));
+            std::thread::sleep(
+                std::time::Duration::from_millis(25).min(timeout.saturating_sub(elapsed)),
+            );
         }
     }
 
@@ -2730,7 +2813,7 @@ pub mod lifecycle_port {
             .collect::<std::collections::BTreeSet<_>>();
         for pid in root_pids {
             if !protected.contains_pid(*pid)
-                && crate::platform::process::pid_is_alive(*pid)
+                && shutdown_pid_is_alive(*pid)
                 && seen.insert(*pid)
             {
                 residuals.push(ProcessInfo {

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

@@ -357,8 +357,192 @@ mod tests {
         cleanup_fixture(&path);
     }
 
+    #[cfg(unix)]
+    #[test]
+    fn cursor_native_tip_fixture_works_through_public_cli_once() {
+        let agent = native_cli_fixture(
+            "agent",
+            include_bytes!("../provider/testdata/cursor-list-models-native.stdout"),
+        );
+        let output = run_public_models_cli(
+            &agent.program,
+            agent.response.as_deref(),
+            &["models", "--provider", "cursor_agent", "--json"],
+        );
+        let text = public_cli_text(&output);
+        let calls = std::fs::read_to_string(agent.program.with_extension("count")).unwrap_or_default();
+        drop(agent);
+        assert!(output.status.success(), "{text}");
+        assert_eq!(calls, "1:--list-models\n");
+        let value: Value = serde_json::from_str(text.trim()).unwrap();
+        assert_eq!(value["schema_version"], "models.v1");
+        assert_eq!(value["provider"], "cursor_agent");
+        let models = value["models"].as_array().unwrap();
+        for exact in ["gpt-5.6-luna-low", "gpt-5.6-luna-xhigh"] {
+            assert!(models.iter().any(|model| model["model_id"] == exact));
+        }
+        assert_eq!(models[0]["model_id"], "auto");
+        assert_eq!(models[0]["default"], true);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn grok_public_cli_uses_native_catalog_and_keeps_shared_projection() {
+        let grok = native_cli_fixture(
+            "grok",
+            include_bytes!("../provider/testdata/grok-models-authenticated.stdout"),
+        );
+        let json = run_public_models_cli(
+            &grok.program,
+            grok.response.as_deref(),
+            &["models", "--provider", "grok", "--json"],
+        );
+        let human = run_public_models_cli(
+            &grok.program,
+            grok.response.as_deref(),
+            &["models", "--provider", "grok", "--search", "BUILD FAST"],
+        );
+        let no_match = run_public_models_cli(
+            &grok.program,
+            grok.response.as_deref(),
+            &["models", "--provider", "grok", "--search", "definitely-absent"],
+        );
+        let json_text = public_cli_text(&json);
+        let human_text = public_cli_text(&human);
+        let no_match_text = public_cli_text(&no_match);
+        let calls = std::fs::read_to_string(grok.program.with_extension("count")).unwrap_or_default();
+        drop(grok);
+        assert!(json.status.success(), "{json_text}");
+        assert!(human.status.success(), "{human_text}");
+        assert!(no_match.status.success(), "{no_match_text}");
+        assert_eq!(calls, "1:models\n".repeat(3));
+        let value: Value = serde_json::from_str(json_text.trim()).unwrap();
+        assert_eq!(value["schema_version"], "models.v1");
+        assert_eq!(value["provider"], "grok");
+        assert_eq!(value["auth_basis"], "catalog_visibility");
+        let models = value["models"].as_array().unwrap();
+        assert_eq!(
+            models.iter().map(|model| model["model_id"].as_str().unwrap()).collect::<Vec<_>>(),
+            vec!["grok-4.7", "grok-4.7-build-fast", "grok-4.5", "grok-4.6"]
+        );
+        assert!(models.iter().all(|model| model["provider"] == "grok" && model["vendor"] == "xai" && model["aliases"] == json!([])));
+        assert_eq!(models[0]["default"], false);
+        assert_eq!(models[3]["default"], true);
+        assert!(human_text.contains("grok-4.7-build-fast"));
+        assert!(no_match_text.contains("No models matched --search"));
+        assert!(no_match_text.contains("auth: ok (catalog_visibility)"));
+
+        let grok = native_cli_fixture(
+            "grok",
+            include_bytes!("../provider/testdata/grok-models-unauthenticated.stdout"),
+        );
+        let changed_default = run_public_models_cli(
+            &grok.program,
+            grok.response.as_deref(),
+            &["models", "--provider", "grok", "--json"],
+        );
+        let changed_text = public_cli_text(&changed_default);
+        drop(grok);
+        assert!(changed_default.status.success(), "{changed_text}");
+        let changed: Value = serde_json::from_str(changed_text.trim()).unwrap();
+        assert_eq!(changed["models"][0]["model_id"], "grok-4.7");
+        assert_eq!(changed["models"][0]["default"], true);
+        assert_eq!(changed["models"][1]["default"], false);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn grok_invalid_native_catalogs_fail_closed_without_fallback() {
+        let cases: [(&str, Vec<u8>); 7] = [
+            ("unknown row", b"You are logged in with grok.com.\n\nDefault model: grok-4.6\n\nAvailable models:\n  - grok-4.6\n  ? grok-4.5\n".to_vec()),
+            ("duplicate", b"You are logged in with grok.com.\n\nDefault model: grok-4.6\n\nAvailable models:\n  - grok-4.6\n  - grok-4.6\n".to_vec()),
+            ("invalid id", b"You are logged in with grok.com.\n\nDefault model: grok-4.6\n\nAvailable models:\n  * grok bad (default)\n".to_vec()),
+            ("control id", b"You are logged in with grok.com.\n\nDefault model: grok-4.6\n\nAvailable models:\n  * grok-\x01evil (default)\n".to_vec()),
+            ("empty", b"You are not authenticated.\n\nDefault model: grok-4.6\n\nAvailable models:\n".to_vec()),
+            ("contradictory default", b"You are not authenticated.\n\nDefault model: grok-4.6\n\nAvailable models:\n  * grok-4.7 (default)\n  - grok-4.6\n".to_vec()),
+            ("invalid utf8", vec![b'Y', b'o', b'u', 0xff]),
+        ];
+        let mut outcomes = Vec::new();
+        for (name, bytes) in cases {
+            let grok = native_cli_fixture("grok", &bytes);
+            let output = run_public_models_cli(
+                &grok.program,
+                grok.response.as_deref(),
+                &["models", "--provider", "grok", "--json"],
+            );
+            let text = public_cli_text(&output);
+            let calls = std::fs::read_to_string(grok.program.with_extension("count")).unwrap_or_default();
+            outcomes.push((name, output.status.success(), text, calls));
+        }
+        for (name, success, text, calls) in outcomes {
+            assert!(!success, "{name} catalog unexpectedly accepted: {text}");
+            assert_eq!(calls, "1:models\n", "{name}");
+            let value: Value = serde_json::from_str(text.trim()).unwrap();
+            assert_eq!(value["schema_version"], "models.v1", "{name}");
+            assert_eq!(value["ok"], false, "{name}");
+            assert_eq!(value["models"], json!([]), "{name}");
+            assert!(!value["error"].as_str().unwrap().to_ascii_lowercase().contains("unsupported model provider"), "{name}: {text}");
+        }
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn grok_nonzero_native_command_is_not_a_successful_empty_catalog() {
+        let grok = CliFixture::new(fixture_program("grok", "printf 'private diagnostic' >&2\nexit 7"));
+        let output = run_public_models_cli(
+            &grok.program,
+            None,
+            &["models", "--provider", "grok", "--json"],
+        );
+        let text = public_cli_text(&output);
+        let calls = std::fs::read_to_string(grok.program.with_extension("count")).unwrap_or_default();
+        drop(grok);
+        assert!(!output.status.success(), "{text}");
+        assert_eq!(calls, "1:models\n");
+        assert!(!text.contains("private diagnostic"));
+        let value: Value = serde_json::from_str(text.trim()).unwrap();
+        assert_eq!(value["ok"], false);
+        assert_eq!(value["models"], json!([]));
+        assert!(value["error"].as_str().unwrap().to_ascii_lowercase().contains("grok"), "{text}");
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn grok_failure_help_and_unsupported_action_are_publicly_diagnostic() {
+        let missing = CliFixture::new(fixture_program("not-grok", "exit 0"));
+        let output = run_public_models_cli(
+            &missing.program,
+            None,
+            &["models", "--provider", "grok", "--json"],
+        );
+        let text = public_cli_text(&output);
+        let value: Value = serde_json::from_str(text.trim()).unwrap();
+        assert_eq!(value["ok"], false);
+        assert!(value["error"].as_str().unwrap().to_ascii_lowercase().contains("grok"), "{text}");
+        assert!(value["action"].as_str().unwrap().contains("grok"), "{text}");
+        assert!(crate::cli::emit::default_help().contains("grok"));
+        assert!(crate::cli::spec::command_spec("models").unwrap().usage.contains("grok"));
+
+        let unsupported = run_public_models_cli(
+            &missing.program,
+            None,
+            &["models", "--provider", "cloud", "--json"],
+        );
+        let unsupported_text = public_cli_text(&unsupported);
+        let unsupported_value: Value = serde_json::from_str(unsupported_text.trim()).unwrap();
+        drop(missing);
+        assert!(!output.status.success());
+        assert!(!unsupported.status.success());
+        assert!(unsupported_value["action"].as_str().unwrap().contains("grok"), "{unsupported_text}");
+    }
+
     #[cfg(unix)]
     fn fixture(body: &str) -> std::path::PathBuf {
+        fixture_program("pi", body)
+    }
+
+    #[cfg(unix)]
+    fn fixture_program(program: &str, body: &str) -> std::path::PathBuf {
         use std::os::unix::fs::PermissionsExt;
         let sequence = FIXTURE_SEQUENCE.fetch_add(1, Ordering::Relaxed);
         let root = std::env::current_exe()
@@ -366,7 +550,7 @@ mod tests {
             .parent()
             .unwrap()
             .join(format!(
-                "team-agent-pi-fixture-{}-{}-{sequence}",
+                "team-agent-{program}-fixture-{}-{}-{sequence}",
                 std::process::id(),
                 std::time::SystemTime::now()
                     .duration_since(std::time::UNIX_EPOCH)
@@ -374,7 +558,7 @@ mod tests {
                     .as_nanos()
             ));
         std::fs::create_dir(&root).unwrap();
-        let path = root.join("pi");
+        let path = root.join(program);
         std::fs::write(
             &path,
             format!("#!/bin/sh\nprintf '%s\\n' \"$#:$1\" >> \"$0.count\"\n{body}\n"),
@@ -386,6 +570,71 @@ mod tests {
         path
     }
 
+    #[cfg(unix)]
+    struct CliFixture {
+        program: std::path::PathBuf,
+        response: Option<std::path::PathBuf>,
+    }
+
+    #[cfg(unix)]
+    impl CliFixture {
+        fn new(program: std::path::PathBuf) -> Self {
+            Self { program, response: None }
+        }
+    }
+
+    #[cfg(unix)]
+    impl Drop for CliFixture {
+        fn drop(&mut self) {
+            cleanup_fixture(&self.program);
+        }
+    }
+
+    #[cfg(unix)]
+    fn native_cli_fixture(program: &str, bytes: &[u8]) -> CliFixture {
+        let program = fixture_program(program, "exec /bin/cat \"$TEAM_AGENT_MODELS_FIXTURE\"");
+        let mut fixture = CliFixture::new(program);
+        let response = fixture.program.with_extension("stdout");
+        std::fs::write(&response, bytes).unwrap();
+        fixture.response = Some(response);
+        fixture
+    }
+
+    #[cfg(unix)]
+    fn run_public_models_cli(
+        path: &Path,
+        response: Option<&Path>,
+        args: &[&str],
+    ) -> std::process::Output {
+        let mut command = std::process::Command::new(std::env::current_exe().unwrap());
+        command
+            .args([
+                "--exact",
+                "cli::models::tests::real_dispatcher_child_helper",
+                "--nocapture",
+            ])
+            .env("TEAM_AGENT_MODELS_CHILD", "1")
+            .env("TEAM_AGENT_MODELS_ARGS", serde_json::to_string(args).unwrap())
+            .env("PATH", path.parent().unwrap())
+            .env_remove("PI_PROVIDER")
+            .env_remove("PI_MODEL")
+            .env_remove("TEAM_AGENT_MODELS_FIXTURE");
+        if let Some(response) = response {
+            command.env("TEAM_AGENT_MODELS_FIXTURE", response);
+        }
+        command.output().unwrap()
+    }
+
+    #[cfg(unix)]
+    fn public_cli_text(output: &std::process::Output) -> String {
+        String::from_utf8(output.stdout.clone())
+            .unwrap()
+            .split("__TEAM_AGENT_MODELS_CLI_OUTPUT_v1__\n")
+            .nth(1)
+            .expect("public CLI child output marker")
+            .to_string()
+    }
+
     #[cfg(unix)]
     fn fixture_with_sidecars(body: &str) -> std::path::PathBuf {
         let path = fixture(body);
@@ -968,7 +1217,7 @@ mod tests {
         );
         assert_eq!(
             crate::cli::spec::command_spec("models").unwrap().usage,
-            "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code] [QUERY|--search TEXT] [--json]"
+            "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code|grok] [QUERY|--search TEXT] [--json]"
         );
     }
 

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

@@ -147,7 +147,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "start or attach a team from TEAM.md", usage: "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--backend tmux|conpty] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
     CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for an in-team short name or fully-qualified logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--mailbox] [--json]\nTO forms are co-equal: an in-team short name (for example `team-agent send reviewer \"Review\"`) or `<workspace>::<team>/<agent>`.", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
-    CommandSpec { name: "models", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "list exact provider model ids", usage: "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code] [QUERY|--search TEXT] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
+    CommandSpec { name: "models", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "list exact provider model ids", usage: "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code|grok] [QUERY|--search TEXT] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "wait", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Wait), summary: "block until a task result is stored", usage: "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },