@team-agent/installer 0.5.113 → 0.5.115

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

@@ -0,0 +1,261 @@
+//! Early, host-global command dispatch: never select or initialize a workspace.
+use super::ExitCode;
+use crate::leader::prompt::{self, Mutation, PromptError};
+use serde_json::json;
+use std::io::{self, Write};
+use std::path::PathBuf;
+
+pub(crate) const HELP: &str = "Purpose:\nPersist supplemental system instructions for future Team Agent Leader launches only.\nUsage: team-agent leader-prompt [show|set|append|clear] [--json] [--file PATH | -- TEXT]\n\nOptions:\nshow (default) prints the exact text; set replaces it; append joins old and new text with two newlines; clear removes it.\nset/append require exactly one TEXT token after --, or --file PATH containing UTF-8 text. No implicit stdin.\nEverything after -- is literal text, including --json and --help. Empty text and NUL are rejected.\nConfiguration: ~/.team-agent/leader-prompt.txt, independent of the workspace. Mutations do not echo the text.\nOnly new Pi, Claude, Codex and Grok Leaders apply it; Worker launches never read it. Cursor/Copilot are refused when configured.\nCodex merges explicit argv developer_instructions, but overrides that user/profile configuration slot; migrate its existing text here.\nNative core prompts and unrelated launch arguments remain unchanged. Attach does not update an existing session.\nExamples:\nteam-agent leader-prompt show\nteam-agent leader-prompt set -- 'Keep replies concise.'\nteam-agent leader-prompt clear\n\nNext Action:\nUse show to inspect the text, then start a new Leader with team-agent pi (or claude/codex/grok).\nset/append/clear affect the next new process, not running Leaders or their conversation history.";
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Operation {
+    Show,
+    Set,
+    Append,
+    Clear,
+}
+impl Operation {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Show => "show",
+            Self::Set => "set",
+            Self::Append => "append",
+            Self::Clear => "clear",
+        }
+    }
+}
+#[derive(Debug, Eq, PartialEq)]
+enum Input {
+    Text(String),
+    File(PathBuf),
+}
+#[derive(Debug)]
+struct Request {
+    operation: Operation,
+    input: Option<Input>,
+    json: bool,
+    help: bool,
+}
+fn usage() -> PromptError {
+    PromptError::new(
+        "leader_prompt_invalid_input",
+        "Invalid or incomplete leader-prompt arguments; use one input for set/append",
+        None,
+    )
+}
+fn parse(args: &[String]) -> Result<Request, PromptError> {
+    let end = args
+        .iter()
+        .position(|arg| arg == "--")
+        .unwrap_or(args.len());
+    let mut json = false;
+    let mut help = false;
+    let mut file = None;
+    let mut positional = None;
+    let mut i = 0;
+    while i < end {
+        match args[i].as_str() {
+            "--json" if !json => json = true,
+            "--help" | "-h" if !help => help = true,
+            "--stdin" => {
+                return Err(PromptError::new(
+                    "leader_prompt_invalid_input",
+                    "--stdin is not supported for leader-prompt; use -- TEXT or --file PATH instead",
+                    None,
+                ));
+            }
+            "--file" if file.is_none() && i + 1 < end => {
+                i += 1;
+                if matches!(args[i].as_str(), "--json" | "--help" | "-h" | "--file") {
+                    return Err(usage());
+                }
+                file = Some(PathBuf::from(&args[i]));
+            }
+            token if !token.starts_with('-') && positional.is_none() => positional = Some(token),
+            _ => return Err(usage()),
+        }
+        i += 1;
+    }
+    let operation = match positional.unwrap_or("show") {
+        "show" => Operation::Show,
+        "set" => Operation::Set,
+        "append" => Operation::Append,
+        "clear" => Operation::Clear,
+        _ => return Err(usage()),
+    };
+    let text = if end < args.len() {
+        if args.len() != end + 2 {
+            return Err(usage());
+        }
+        Some(args[end + 1].clone())
+    } else {
+        None
+    };
+    if (file.is_some() && text.is_some()) || (help && (file.is_some() || text.is_some())) {
+        return Err(usage());
+    }
+    let input = file.map(Input::File).or_else(|| text.map(Input::Text));
+    if !help && (matches!(operation, Operation::Set | Operation::Append) != input.is_some()) {
+        return Err(usage());
+    }
+    Ok(Request {
+        operation,
+        input,
+        json,
+        help,
+    })
+}
+fn execute(request: Request) -> Result<(), PromptError> {
+    let path = prompt::config_path()?;
+    if request.operation == Operation::Show {
+        let text = prompt::read(&path)?.unwrap_or_default();
+        if request.json {
+            println!(
+                "{}",
+                json!({"configured": !text.is_empty(), "config_path": path, "prompt": text})
+            );
+        } else {
+            // Unlike mutation diagnostics, explicit show must preserve every byte.
+            io::stdout()
+                .write_all(text.as_bytes())
+                .and_then(|_| io::stdout().flush())
+                .map_err(|error| PromptError::io("leader_prompt_write_failed", &path, error))?;
+        }
+        return Ok(());
+    }
+    let mutation = match request.operation {
+        Operation::Clear => Mutation::Clear,
+        _ => {
+            let text = match request.input {
+                Some(Input::Text(text)) => text,
+                Some(Input::File(input)) => std::fs::read_to_string(&input).map_err(|error| {
+                    PromptError::io("leader_prompt_unreadable", &input, error).at_config(&path)
+                })?,
+                None => return Err(usage()),
+            };
+            if request.operation == Operation::Set {
+                Mutation::Set(text)
+            } else {
+                Mutation::Append(text)
+            }
+        }
+    };
+    let configured = prompt::mutate(&path, mutation)?;
+    if request.json {
+        println!(
+            "{}",
+            json!({"operation": request.operation.name(), "configured": configured, "config_path": path})
+        );
+    } else {
+        println!(
+            "Leader prompt {}: configured={configured}; config={}",
+            request.operation.name(),
+            path.display()
+        );
+    }
+    Ok(())
+}
+pub(crate) fn run(args: &[String]) -> ExitCode {
+    let end = args
+        .iter()
+        .position(|arg| arg == "--")
+        .unwrap_or(args.len());
+    let as_json = args[..end].iter().any(|arg| arg == "--json");
+    let result = match parse(args) {
+        Ok(request) if request.help => {
+            println!("{HELP}");
+            return ExitCode::Ok;
+        }
+        Ok(request) => execute(request),
+        Err(error) => Err(error),
+    };
+    match result {
+        Ok(()) => ExitCode::Ok,
+        Err(error) => {
+            if as_json {
+                println!("{}", error.report());
+            } else {
+                eprintln!("{error}");
+            }
+            if error.reason == "leader_prompt_invalid_input" {
+                ExitCode::Usage
+            } else {
+                ExitCode::Error
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod tests {
+    use super::*;
+    fn args(tokens: &[&str]) -> Vec<String> {
+        tokens.iter().map(|text| text.to_string()).collect()
+    }
+    #[test]
+    fn leader_prompt_controls_stop_at_delimiter() {
+        for text in ["--json", "--help", "--file", "--stdin", "multi\nline🙂", ""] {
+            let request = parse(&args(&["set", "--", text])).unwrap();
+            assert!(!request.json && !request.help);
+            assert_eq!(request.input, Some(Input::Text(text.into())));
+        }
+        assert!(parse(&args(&[])).unwrap().operation == Operation::Show);
+        let request = parse(&args(&["--json", "append", "--file", "path with 中文"])).unwrap();
+        assert_eq!(
+            request.input,
+            Some(Input::File(PathBuf::from("path with 中文")))
+        );
+        assert!(request.json);
+    }
+    #[test]
+    fn leader_prompt_stdin_control_reports_unsupported_input_with_usage_exit() {
+        for tokens in [
+            vec!["set", "--stdin"],
+            vec!["set", "--json", "--stdin"],
+            vec!["append", "--json", "--stdin"],
+        ] {
+            let tokens = args(&tokens);
+            let error = parse(&tokens).unwrap_err();
+            assert_eq!(error.reason, "leader_prompt_invalid_input");
+            assert_eq!(
+                error.error,
+                "--stdin is not supported for leader-prompt; use -- TEXT or --file PATH instead"
+            );
+            assert!(error.config_path.is_none());
+            assert_eq!(error.report()["reason"], "leader_prompt_invalid_input");
+            assert_eq!(error.report()["error"], error.error);
+            assert!(error.to_string().contains("--stdin is not supported"));
+            assert_eq!(run(&tokens).code(), 2);
+        }
+    }
+    #[test]
+    fn leader_prompt_stdin_file_value_is_not_reclassified_as_a_control() {
+        for operation in ["set", "append"] {
+            let request = parse(&args(&[operation, "--file", "--stdin"])).unwrap();
+            assert_eq!(request.input, Some(Input::File(PathBuf::from("--stdin"))));
+        }
+    }
+    #[test]
+    fn leader_prompt_rejects_duplicate_missing_unknown_or_extra_controls() {
+        for tokens in [
+            vec!["set"],
+            vec!["append", "--"],
+            vec!["set", "--", "one", "two"],
+            vec!["set", "--file"],
+            vec!["set", "--file", "input", "--", "text"],
+            vec!["show", "--", "text"],
+            vec!["clear", "--file", "input"],
+            vec!["show", "--json", "--json"],
+            vec!["set", "--file", "one", "--file", "two"],
+            vec!["show", "--unknown"],
+            vec!["show", "clear"],
+            vec!["unknown", "--help"],
+        ] {
+            assert_eq!(
+                parse(&args(&tokens)).unwrap_err().reason,
+                "leader_prompt_invalid_input"
+            );
+        }
+    }
+}

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)]
+        if let Some(receipt) = crate::contract_runtime::commands::restart(workspace, team)? {
+            return Ok(receipt);
+        }
         match crate::lifecycle::restart_with_session_convergence_deadline(
             workspace,
             allow_fresh,
@@ -3128,6 +3149,23 @@ pub mod lifecycle_port {
         team: Option<&str>,
         role_config: &crate::lifecycle::role_config::RoleConfigPatch,
     ) -> Result<Value, CliError> {
+        #[cfg(unix)]
+        if let Some(receipt) = crate::contract_runtime::commands::start_agent(workspace, team, agent, role_config)? {
+            return Ok(receipt);
+        }
+        #[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(
@@ -3194,7 +3232,15 @@ pub mod lifecycle_port {
         agent: &str,
         team: Option<&str>,
     ) -> Result<Value, CliError> {
+        #[cfg(unix)]
+        if let Some(receipt) = crate::contract_runtime::commands::stop_agent(workspace, team, agent)? {
+            return Ok(receipt);
+        }
         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 +3255,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 +3309,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 +3374,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 +3418,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 +3450,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 +3799,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 +3933,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 +4054,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 +4071,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 +4084,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")