@team-agent/installer 0.5.113 → 0.5.115

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

@@ -22,6 +22,10 @@ enum CatalogFormat {
 }
 
 pub fn cmd_models(args: &ModelsArgs) -> Result<CmdResult, CliError> {
+    #[cfg(unix)]
+    if crate::contract_runtime::registry::descriptor(&args.provider).is_some() {
+        return crate::contract_runtime::discovery::models(args);
+    }
     let records = match crate::provider::model_catalog::discover_model_catalog(&args.provider) {
         Ok(records) => records,
         Err(error) => {
@@ -36,7 +40,12 @@ pub fn cmd_models(args: &ModelsArgs) -> Result<CmdResult, CliError> {
 fn render_catalog(args: &ModelsArgs, all: Vec<ModelRecord>) -> Result<CmdResult, CliError> {
     let visible = args.search.as_deref().map_or_else(
         || all.clone(),
-        |search| all.iter().filter(|model| crate::provider::model_catalog::model_matches(model, search)).cloned().collect(),
+        |search| {
+            all.iter()
+                .filter(|model| crate::provider::model_catalog::model_matches(model, search))
+                .cloned()
+                .collect()
+        },
     );
     let current = if args.provider == "pi" {
         current_role_model(&all.iter().map(|model| model.id.clone()).collect::<Vec<_>>())
@@ -66,14 +75,31 @@ fn render_catalog(args: &ModelsArgs, all: Vec<ModelRecord>) -> Result<CmdResult,
             preserve_json_order: true,
         })
     } else {
-        let mut lines = vec![format!("models.v1 | {provider} models (copyable model_id):")];
+        let mut lines = vec![format!(
+            "models.v1 | {provider} models (copyable model_id):"
+        )];
         lines.push("PROVIDER VENDOR MODEL_ID DISPLAY_NAME CURRENT DEFAULT".to_string());
-        lines.extend(visible.iter().map(|model| format!(
-            "{} {} {} {} {} {}", model.provider, model.vendor, model.id, model.display_name,
-            if args.provider == "pi" { (current.as_deref() == Some(model.id.as_str())).to_string() } else { "—".to_string() },
-            model.default.map_or_else(|| "—".to_string(), |value| value.to_string()),
-        )));
-        lines.push(format!("auth: ok (catalog_visibility); {} model(s)", visible.len()));
+        lines.extend(visible.iter().map(|model| {
+            format!(
+                "{} {} {} {} {} {}",
+                model.provider,
+                model.vendor,
+                model.id,
+                model.display_name,
+                if args.provider == "pi" {
+                    (current.as_deref() == Some(model.id.as_str())).to_string()
+                } else {
+                    "—".to_string()
+                },
+                model
+                    .default
+                    .map_or_else(|| "—".to_string(), |value| value.to_string()),
+            )
+        }));
+        lines.push(format!(
+            "auth: ok (catalog_visibility); {} model(s)",
+            visible.len()
+        ));
         if visible.is_empty() {
             lines.push("No models matched --search/query; rerun without a search to list the full catalog.".to_string());
         }
@@ -83,12 +109,23 @@ fn render_catalog(args: &ModelsArgs, all: Vec<ModelRecord>) -> Result<CmdResult,
 
 /// Existing injectable Pi boundary retained for deterministic command/timeout tests.
 #[cfg(test)]
-fn cmd_models_with(args: &ModelsArgs, program: &Path, timeout: Duration, max_bytes: u64) -> Result<CmdResult, CliError> {
+fn cmd_models_with(
+    args: &ModelsArgs,
+    program: &Path,
+    timeout: Duration,
+    max_bytes: u64,
+) -> Result<CmdResult, CliError> {
     cmd_models_with_format(args, program, CatalogFormat::Pi, timeout, max_bytes)
 }
 
 #[cfg(test)]
-fn cmd_models_with_format(args: &ModelsArgs, program: &Path, format: CatalogFormat, timeout: Duration, max_bytes: u64) -> Result<CmdResult, CliError> {
+fn cmd_models_with_format(
+    args: &ModelsArgs,
+    program: &Path,
+    format: CatalogFormat,
+    timeout: Duration,
+    max_bytes: u64,
+) -> Result<CmdResult, CliError> {
     let bytes = match run_catalog(program, timeout, max_bytes) {
         Ok(bytes) => bytes,
         Err(message) => return Ok(failure(args, &message)),
@@ -102,7 +139,10 @@ fn cmd_models_with_format(args: &ModelsArgs, program: &Path, format: CatalogForm
 
 #[cfg(test)]
 fn parse_catalog(bytes: &[u8], format: CatalogFormat) -> Result<Vec<ModelRecord>, String> {
-    let provider = match format { CatalogFormat::Pi => "pi", CatalogFormat::CursorAgent => "cursor_agent" };
+    let provider = match format {
+        CatalogFormat::Pi => "pi",
+        CatalogFormat::CursorAgent => "cursor_agent",
+    };
     let result = match format {
         CatalogFormat::Pi => crate::provider::model_catalog::parse_pi_catalog(bytes),
         CatalogFormat::CursorAgent => crate::provider::model_catalog::parse_cursor_catalog(bytes),
@@ -124,7 +164,12 @@ fn model_matches(model: &ModelRecord, search: &str) -> bool {
 #[cfg(test)]
 fn current_model_for(format: CatalogFormat, models: &[ModelRecord]) -> Option<String> {
     match format {
-        CatalogFormat::Pi => current_role_model(&models.iter().map(|model| model.id.clone()).collect::<Vec<_>>()),
+        CatalogFormat::Pi => current_role_model(
+            &models
+                .iter()
+                .map(|model| model.id.clone())
+                .collect::<Vec<_>>(),
+        ),
         CatalogFormat::CursorAgent => None,
     }
 }
@@ -148,8 +193,14 @@ fn failure(args: &ModelsArgs, message: &str) -> CmdResult {
 fn failure_with_action(args: &ModelsArgs, message: &str, action: &str) -> CmdResult {
     let value = json!({ "schema_version": "models.v1", "ok": false, "provider": args.provider, "auth": "not_ready", "auth_basis": "catalog_visibility", "models": Value::Array(Vec::new()), "current_role_model": Value::Null, "error": message, "action": action });
     if args.json {
-        let text = serde_json::to_string_pretty(&value).unwrap_or_else(|_| "{\"schema_version\":\"models.v1\",\"ok\":false}".to_string());
-        CmdResult { output: CmdOutput::Human(text), exit: ExitCode::Error, as_json: false, preserve_json_order: true }
+        let text = serde_json::to_string_pretty(&value)
+            .unwrap_or_else(|_| "{\"schema_version\":\"models.v1\",\"ok\":false}".to_string());
+        CmdResult {
+            output: CmdOutput::Human(text),
+            exit: ExitCode::Error,
+            as_json: false,
+            preserve_json_order: true,
+        }
     } else {
         CmdResult { output: CmdOutput::Human(format!("models.v1 | error: {message}\naction: {action}\nauth: not_ready (catalog_visibility)")), exit: ExitCode::Error, as_json: false, preserve_json_order: false }
     }
@@ -387,6 +438,57 @@ mod tests {
         assert_eq!(models[0]["default"], true);
     }
 
+    #[cfg(unix)]
+    #[test]
+    fn cursor_contract_catalog_uses_public_launcher_metadata_then_exact_ids() {
+        let program = fixture_program("cursor-agent", r#"
+test "$#" = 1 || exit 9
+case "$1" in
+  --version) printf '%s\n' '2026.10.01-a1b2c3' ;;
+  --list-models) exec /bin/cat "$TEAM_AGENT_MODELS_FIXTURE" ;;
+  *) exit 9 ;;
+esac"#);
+        let mut cursor = CliFixture::new(program);
+        let response = cursor.program.with_extension("stdout");
+        std::fs::write(&response, include_bytes!("../provider/testdata/cursor-list-models-native.stdout")).unwrap();
+        cursor.response = Some(response);
+        let output = run_public_models_cli(&cursor.program, cursor.response.as_deref(),
+            &["models", "--provider", "cursor", "--search", "gpt-5.6-luna-xhigh", "--json"]);
+        let text = public_cli_text(&output);
+        let calls = std::fs::read_to_string(cursor.program.with_extension("count")).unwrap();
+        assert!(output.status.success(), "{text}");
+        assert_eq!(calls, "1:--version\n1:--list-models\n");
+        let value: Value = serde_json::from_str(text.trim()).unwrap();
+        assert_eq!(value["provider"], "cursor");
+        assert_eq!(value["auth"], "unknown");
+        assert_eq!(value["source"]["schema"], "cursor-list-models-text-v1");
+        assert_eq!(value["source"]["identity_scope"], "catalog_only");
+        assert!(value["models"].as_array().unwrap().iter().any(|row| row["model_id"] == "gpt-5.6-luna-xhigh"));
+        assert!(value["models"].as_array().unwrap().iter().all(|row| row["role_model"] == row["model_id"]));
+        assert!(value["current_role_model"].is_null());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn cursor_contract_bad_version_has_no_legacy_entrypoint_fallback() {
+        use std::os::unix::fs::PermissionsExt;
+        let cursor = CliFixture::new(fixture_program("cursor-agent", "printf '%s\\n' 'Cursor release unknown'"));
+        let legacy = cursor.program.parent().unwrap().join("agent");
+        std::fs::write(&legacy, "#!/bin/sh\nprintf 'called' > \"$0.called\"\nexit 9\n").unwrap();
+        std::fs::set_permissions(&legacy, std::fs::Permissions::from_mode(0o700)).unwrap();
+        let output = run_public_models_cli(&cursor.program, None,
+            &["models", "--provider", "cursor", "--json"]);
+        let text = public_cli_text(&output);
+        assert!(!output.status.success(), "{text}");
+        assert_eq!(std::fs::read_to_string(cursor.program.with_extension("count")).unwrap(), "1:--version\n");
+        assert!(!legacy.with_extension("called").exists());
+        let value: Value = serde_json::from_str(text.trim()).unwrap();
+        assert_eq!(value["provider"], "cursor");
+        assert_eq!(value["ok"], false);
+        assert_eq!(value["models"], json!([]));
+        assert!(value["error"].as_str().unwrap().contains("Cursor release unknown"));
+    }
+
     #[cfg(unix)]
     #[test]
     fn grok_public_cli_uses_native_catalog_and_keeps_shared_projection() {
@@ -1271,10 +1373,9 @@ mod tests {
             ),
             ExitCode::Error
         );
-        assert_eq!(
-            crate::cli::spec::command_spec("models").unwrap().usage,
-            "team-agent models [--provider pi|cursor_agent|codex|claude|claude_code|grok] [QUERY|--search TEXT] [--json]"
-        );
+        let usage = "team-agent models [--provider pi|cursor|cursor_agent|codex|claude|claude_code|grok|kiro] [QUERY|--search TEXT] [--json]";
+        assert_eq!(crate::cli::spec::command_spec("models").unwrap().usage, usage);
+        assert!(crate::cli::emit::command_help(Some("models")).contains(usage));
     }
 
     #[test]

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

@@ -36,6 +36,7 @@ pub(crate) enum DispatchKind {
     Send,
     Status,
     Models,
+    KiroLeader,
     Inbox,
     Restart,
     Shutdown,
@@ -50,6 +51,7 @@ pub(crate) enum DispatchKind {
     Doctor,
     Approvals,
     Route,
+    LeaderPrompt,
     Profile,
     InstallSkill,
     ClaimLeader,
@@ -61,6 +63,7 @@ pub(crate) const ALL_DISPATCH_KINDS: &[DispatchKind] = &[
     DispatchKind::Send,
     DispatchKind::Status,
     DispatchKind::Models,
+    DispatchKind::KiroLeader,
     DispatchKind::Inbox,
     DispatchKind::Restart,
     DispatchKind::Shutdown,
@@ -75,6 +78,7 @@ pub(crate) const ALL_DISPATCH_KINDS: &[DispatchKind] = &[
     DispatchKind::Doctor,
     DispatchKind::Approvals,
     DispatchKind::Route,
+    DispatchKind::LeaderPrompt,
     DispatchKind::Profile,
     DispatchKind::InstallSkill,
     DispatchKind::ClaimLeader,
@@ -109,7 +113,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "Create a team from role files; use restart for an initialized team", usage: "team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--team TEAM] [--name NAME] [--team-id TEAM] [--yes] [--backend tmux|conpty] [--json] [--detail]", 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::Start, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "Send a task to a specified agent", usage: "team-agent send <agent> MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--mailbox] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: Some("a future compatibility release"), action: Some("Use team-agent send <agent> 'task message'; select scope with --workspace and --team"), governance: None },
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "Check agent status without reading conversation content", usage: "team-agent status [<agent>] [--workspace WORKSPACE] [--team TEAM] [--json] [--summary|--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::Start, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "Discover model names supported by the native provider", 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: "models", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "Discover model names supported by the native provider", usage: "team-agent models [--provider pi|cursor|cursor_agent|codex|claude|claude_code|grok|kiro] [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: "inbox", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::Inbox), summary: "Read agent replies", usage: "team-agent inbox <agent> [-n N|--limit N] [--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: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "Restart an existing team using saved sessions when available", usage: "team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
     CommandSpec { name: "shutdown", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Shutdown), summary: "Shut down the selected team and report residual resources", usage: "team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
@@ -124,11 +128,13 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "doctor", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Doctor), summary: "Diagnose a team and suggest recovery; read-only by default", usage: "team-agent doctor [SPEC] [--workspace WORKSPACE] [--team TEAM] [--comms] [--gate orphans|comms] [--fix] [--fix-schema] [--cleanup-orphans] [--confirm] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "approvals", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Approvals), summary: "List pending agent approvals", usage: "team-agent approvals [<agent>] [--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: "route", tier: CommandTier::Core, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Route), summary: "Configure additional provider launch arguments", usage: "team-agent route [status|enable|disable|show [TOOL]|set TOOL -- ARG...|add TOOL -- ARG...|clear TOOL] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
+    CommandSpec { name: "leader-prompt", tier: CommandTier::Core, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::LeaderPrompt), summary: "Persist supplemental instructions for new Leaders only", usage: "team-agent leader-prompt [show|set|append|clear] [--json] [--file PATH | -- TEXT]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "profile", tier: CommandTier::Core, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Profile), summary: "Manage authentication and proxy profiles", usage: "team-agent profile init|doctor|show NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--proxy-mode direct|inherit] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "install-skill", tier: CommandTier::Core, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::InstallSkill), summary: "Optionally install an existing public operation skill", usage: "team-agent install-skill (--source DIR|--uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "claim-leader", tier: CommandTier::Guided, category: CommandCategory::GuidedRecovery, kind: CommandKind::Dispatch(DispatchKind::ClaimLeader), summary: "Register the current terminal as leader only when diagnosis recommends it", usage: "team-agent claim-leader [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "takeover", tier: CommandTier::Guided, category: CommandCategory::GuidedRecovery, kind: CommandKind::Dispatch(DispatchKind::Takeover), summary: "Take over an existing team only after diagnosis and confirmation", usage: "team-agent takeover [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "attach-leader", tier: CommandTier::Guided, category: CommandCategory::GuidedRecovery, kind: CommandKind::Dispatch(DispatchKind::AttachLeader), summary: "Attach a verified leader terminal only when diagnosis recommends it", usage: "team-agent attach-leader [--workspace WORKSPACE] [--team TEAM] --pane PANE --provider TOOL [--confirm] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
+    CommandSpec { name: "kiro", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::KiroLeader), summary: "Check Kiro leader launch admission (currently refused)", usage: "team-agent kiro [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "pi", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "pi" }, summary: "Open a leader session with Pi", usage: "team-agent pi [--attach-existing] [--confirm] [--attach-session SESSION] [--external-leader] [--allow-nested-attach] [--json] [-- TOOL_ARGS...]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
     CommandSpec { name: "codex", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "codex" }, summary: "Open a leader session with Codex", usage: "team-agent codex [--attach-existing] [--confirm] [--attach-session SESSION] [--external-leader] [--allow-nested-attach] [--json] [-- TOOL_ARGS...]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
     CommandSpec { name: "claude", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "claude" }, summary: "Open a leader session with Claude Code", usage: "team-agent claude [--attach-existing] [--confirm] [--attach-session SESSION] [--external-leader] [--allow-nested-attach] [--json] [-- TOOL_ARGS...]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },