@team-agent/installer 0.5.113 → 0.5.114

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

@@ -66,6 +66,7 @@ pub mod leaders;
 pub mod models;
 pub mod named_address;
 pub mod profile;
+pub(crate) mod leader_prompt;
 pub(crate) mod route;
 pub mod send;
 pub(crate) mod spec;
@@ -172,12 +173,18 @@ pub mod lifecycle_port {
             Err(crate::leader::start::PrepareLeaderStartError::PaneAuthorityRefused(refusal)) => {
                 return Ok(pane_authority_refusal_value(provider, attach, &refusal));
             }
+            Err(crate::leader::start::PrepareLeaderStartError::Leader(
+                crate::leader::LeaderError::Prompt(error),
+            )) => return Ok(error.report()),
             Err(crate::leader::start::PrepareLeaderStartError::Leader(error)) => {
                 return Err(CliError::Runtime(error.to_string()));
             }
         };
-        let outcome = crate::leader::start::execute_prepared_leader_start(&prepared, cwd)
-            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let outcome = match crate::leader::start::execute_prepared_leader_start(&prepared, cwd) {
+            Ok(outcome) => outcome,
+            Err(crate::leader::LeaderError::Prompt(error)) => return Ok(error.report()),
+            Err(error) => return Err(CliError::Runtime(error.to_string())),
+        };
         let plan = prepared.plan();
         let ok = match outcome.status {
             crate::leader::LeaderLaunchStatus::Exited => outcome.exit_code == Some(0),
@@ -1297,6 +1304,16 @@ pub mod lifecycle_port {
             Some(state) => state,
             None => shutdown_state_for_team(&run_workspace, team)?,
         };
+        #[cfg(unix)]
+        if crate::contract_runtime::framework::has_contract(&state) {
+            crate::contract_runtime::framework::stop_selected(&run_workspace, &state).map_err(
+                |error| {
+                    CliError::Runtime(format!(
+                        "native shutdown failed; owned resources preserved: {error}"
+                    ))
+                },
+            )?;
+        }
         deadline.check("refresh_provider_sessions")?;
         let captured_missing_sessions =
             crate::lifecycle::restart::refresh_missing_provider_sessions(&mut state)
@@ -3108,6 +3125,10 @@ pub mod lifecycle_port {
         team: Option<&str>,
         session_converge_deadline_ms: Option<u64>,
     ) -> Result<Value, CliError> {
+        #[cfg(unix)]
+        crate::contract_runtime::framework::require_legacy_lifecycle(
+            workspace, team, None, "restart",
+        )?;
         match crate::lifecycle::restart_with_session_convergence_deadline(
             workspace,
             allow_fresh,
@@ -3128,6 +3149,19 @@ pub mod lifecycle_port {
         team: Option<&str>,
         role_config: &crate::lifecycle::role_config::RoleConfigPatch,
     ) -> Result<Value, CliError> {
+        #[cfg(unix)]
+        {
+            crate::contract_runtime::framework::require_legacy_lifecycle(
+                workspace,
+                team,
+                Some(agent),
+                "start-agent",
+            )?;
+            crate::contract_runtime::framework::require_legacy_role(
+                None,
+                role_config.provider.as_deref(),
+            )?;
+        }
         let _ = force; // Never grants authority to stop an already-running seat.
         let agent_id = crate::model::ids::AgentId::new(agent);
         match crate::lifecycle::role_config::start_agent_from_role(
@@ -3195,6 +3229,13 @@ pub mod lifecycle_port {
         team: Option<&str>,
     ) -> Result<Value, CliError> {
         let agent_id = crate::model::ids::AgentId::new(agent);
+        #[cfg(unix)]
+        crate::contract_runtime::framework::require_legacy_lifecycle(
+            workspace,
+            team,
+            Some(agent),
+            "stop-agent",
+        )?;
         match crate::lifecycle::stop_agent(workspace, &agent_id, team) {
             Ok(report) => Ok(json!({"ok": true, "agent_id": agent, "stopped": report.stopped})),
             Err(e) => Ok(error_value(e)),
@@ -3209,6 +3250,13 @@ pub mod lifecycle_port {
         team: Option<&str>,
     ) -> Result<Value, CliError> {
         let agent_id = crate::model::ids::AgentId::new(agent);
+        #[cfg(unix)]
+        crate::contract_runtime::framework::require_legacy_lifecycle(
+            workspace,
+            team,
+            Some(agent),
+            "reset-agent",
+        )?;
         match crate::lifecycle::reset_agent(workspace, &agent_id, discard_session, true, team) {
             Ok(crate::lifecycle::ResetAgentOutcome::Reset {
                 env,
@@ -3256,6 +3304,19 @@ pub mod lifecycle_port {
     ) -> Result<Value, CliError> {
         let agent_id = crate::model::ids::AgentId::new(agent);
         let source = (!role_file.is_empty()).then(|| Path::new(role_file));
+        #[cfg(unix)]
+        {
+            crate::contract_runtime::framework::require_legacy_lifecycle(
+                workspace,
+                team,
+                Some(agent),
+                "add-agent",
+            )?;
+            crate::contract_runtime::framework::require_legacy_role(
+                source,
+                role_config.provider.as_deref(),
+            )?;
+        }
         match crate::lifecycle::role_config::add_agent_from_role(
             workspace,
             &agent_id,
@@ -3308,6 +3369,13 @@ pub mod lifecycle_port {
     ) -> Result<Value, CliError> {
         let source = crate::model::ids::AgentId::new(source_agent);
         let dest = crate::model::ids::AgentId::new(as_agent_id);
+        #[cfg(unix)]
+        crate::contract_runtime::framework::require_legacy_lifecycle(
+            workspace,
+            team,
+            Some(source_agent),
+            "fork-agent",
+        )?;
         match crate::lifecycle::fork_agent(workspace, &source, &dest, label, true, team) {
             Ok(report) => {
                 let mut value = json!({
@@ -3345,6 +3413,13 @@ pub mod lifecycle_port {
     ) -> Result<Value, CliError> {
         let source = crate::model::ids::AgentId::new(source_agent);
         let dest = crate::model::ids::AgentId::new(as_agent_id);
+        #[cfg(unix)]
+        crate::contract_runtime::framework::require_legacy_lifecycle(
+            workspace,
+            team,
+            Some(source_agent),
+            "clone-agent",
+        )?;
         match crate::lifecycle::clone_agent(workspace, &source, &dest, label, true, team) {
             Ok(report) => Ok(json!({
                 "ok": true,
@@ -3370,6 +3445,13 @@ pub mod lifecycle_port {
         team: Option<&str>,
     ) -> Result<Value, CliError> {
         let agent_id = crate::model::ids::AgentId::new(agent);
+        #[cfg(unix)]
+        crate::contract_runtime::framework::require_legacy_lifecycle(
+            workspace,
+            team,
+            Some(agent),
+            "remove-agent",
+        )?;
         match crate::lifecycle::remove_agent_flag_requirements(workspace, &agent_id, team) {
             Ok(requirements) => {
                 if !remove_agent_missing_flags(from_spec, confirm, force, &requirements).is_empty()
@@ -3712,7 +3794,13 @@ pub mod lifecycle_port {
                 // tool-set load has not been confirmed yet (PendingToolLoad).
                 let incomplete_session_capture_agents =
                     launch.session_capture_incomplete_agents.clone();
-                let all_spawned = !launch.started.is_empty();
+                let agent_ids: Vec<_> = launch
+                    .started
+                    .iter()
+                    .map(|agent| agent.agent_id.as_str())
+                    .chain(launch.contract_started.iter().map(|id| id.as_str()))
+                    .collect();
+                let all_spawned = !agent_ids.is_empty();
                 let leader_receiver_attached = launch.leader_receiver_attached;
                 let all_resumable_have_session = incomplete_session_capture_agents.is_empty();
                 let all_workers_spawned = all_spawned;
@@ -3840,7 +3928,7 @@ pub mod lifecycle_port {
                     "ready": readiness_json.get("ready").cloned().unwrap_or(Value::Bool(false)),
                     "session_name": session_name.as_str(),
                     "team": team,
-                    "agent_ids": launch.started.iter().map(|agent| agent.agent_id.as_str()).collect::<Vec<_>>(),
+                    "agent_ids": agent_ids,
                     "dry_run": launch.dry_run,
                     "next_actions": next_actions,
                     "attach_commands": attach_commands,
@@ -3961,9 +4049,8 @@ pub mod lifecycle_port {
                 .is_some());
         }
 
-        #[test]
-        fn pending_tool_load_success_output_explains_bound_send_without_doctor() {
-            let value = quick_start_value(crate::lifecycle::QuickStartReport::Ready {
+        fn pending_tool_load_report() -> crate::lifecycle::QuickStartReport {
+            crate::lifecycle::QuickStartReport::Ready {
                 session_name: crate::transport::SessionName::new("team-demo"),
                 launch: Box::new(crate::lifecycle::LaunchReport {
                     session_name: crate::transport::SessionName::new("team-demo"),
@@ -3979,6 +4066,7 @@ pub mod lifecycle_port {
                         provider_projects_root: None,
                         managed_mcp_config: false,
                     }],
+                    contract_started: Vec::new(),
                     dry_run: false,
                     tmux_endpoint: None,
                     routes: Vec::new(),
@@ -3991,7 +4079,63 @@ pub mod lifecycle_port {
                 attach_commands: Vec::new(),
                 worker_readiness: crate::lifecycle::QuickStartReadiness::PendingToolLoad,
                 team: "team-demo".to_string(),
-            });
+            }
+        }
+
+        #[test]
+        fn contract_start_receipts_join_summary_without_bypassing_leader_binding() {
+            for (legacy, contract) in [(false, true), (true, true), (true, false), (false, false)] {
+                for bound in [false, true] {
+                    let mut report = pending_tool_load_report();
+                    let crate::lifecycle::QuickStartReport::Ready { launch, .. } = &mut report else {
+                        panic!("ready fixture required");
+                    };
+                    if !legacy {
+                        launch.started.clear();
+                    }
+                    if contract {
+                        launch
+                            .contract_started
+                            .push(crate::model::ids::AgentId::new("kiro-worker"));
+                    }
+                    launch.leader_receiver_attached = bound;
+                    launch.leader_bind_stage = (!bound).then(|| "caller_pane".into());
+                    launch.leader_bind_reason = (!bound).then(|| "caller_pane_missing".into());
+                    assert_eq!(launch.started.len(), usize::from(legacy));
+                    let expected: Vec<_> = [(legacy, "worker"), (contract, "kiro-worker")]
+                        .into_iter()
+                        .filter_map(|(started, id)| started.then_some(id))
+                        .collect();
+                    let value = quick_start_value(report);
+                    assert_eq!(value["agent_ids"], json!(expected));
+                    assert_eq!(
+                        value["readiness"]["all_workers_spawned"],
+                        json!(legacy || contract)
+                    );
+                    assert_eq!(value["readiness"]["all_spawned"], json!(legacy || contract));
+                    assert_eq!(value["readiness"]["leader_receiver_attached"], json!(bound));
+                    assert_eq!(value["ok"], json!((legacy || contract) && bound));
+                    assert_eq!(value["ready"], json!((legacy || contract) && bound));
+                    if !bound {
+                        assert_eq!(value["status"], "leader_binding_incomplete");
+                        assert_eq!(value["reason"], "caller_pane_missing");
+                    } else {
+                        assert_eq!(value["status"], "pending_tool_load");
+                    }
+                    let mut compact = value.clone();
+                    compact_quick_start_value(&mut compact);
+                    assert_eq!(
+                        compact["worker_readiness"]["all_workers_spawned"],
+                        json!(legacy || contract)
+                    );
+                    assert_eq!(compact["ready"], value["ready"]);
+                }
+            }
+        }
+
+        #[test]
+        fn pending_tool_load_success_output_explains_bound_send_without_doctor() {
+            let value = quick_start_value(pending_tool_load_report());
             assert_eq!(
                 value.get("summary").and_then(Value::as_str),
                 Some("team started; leader bound; send a task next (worker tool load unverified): team-demo")

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 }
     }
@@ -1271,10 +1322,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_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_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 },