@team-agent/installer 0.5.112 → 0.5.114

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

@@ -49,12 +49,12 @@ use crate::messaging::{self, MessageTarget, SendOptions, TrustedSender};
 use crate::model::ids::{TaskId, TeamKey};
 
 pub(crate) const COMMS_BOUNDARY_TEXT: &str =
-    "这里只检查终端连接是否一致，不实际发送消息，也不证明队友已回复。";
-pub(crate) const QUICK_START_REMINDER: &str = "下一步：向队友派发任务；用 team-agent status 看状态，用 team-agent inbox leader -n 3 看回复，不读取队友终端内容。";
+    "This checks terminal connection consistency only; it does not send a message or prove that a worker replied.";
+pub(crate) const QUICK_START_REMINDER: &str = "Next: send a task. Use team-agent status for status and team-agent inbox leader -n 3 for replies; do not inspect worker terminal content.";
 pub(crate) const SEND_REMINDER: &str =
-    "等队友真正回复，用 team-agent inbox leader -n 3 查看；不要读取队友终端内容。";
+    "Wait for an actual reply; use team-agent inbox leader -n 3. Do not inspect worker terminal content.";
 pub(crate) const STATUS_REMINDER: &str =
-    "下一步：用 team-agent inbox leader -n 3 查看回复；状态不是任务完成证明，不读取队友终端内容。";
+    "Next: use team-agent inbox leader -n 3 for replies. Status is not proof of task completion; do not inspect worker terminal content.";
 
 pub mod adapters;
 pub mod attach_app_server_leader;
@@ -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")
@@ -4176,7 +4320,7 @@ pub mod lifecycle_port {
                     "team-agent".to_string(),
                     "send".to_string(),
                     "implementer".to_string(),
-                    "请完成任务并把答案回复给 leader。".to_string(),
+                    "Complete the task and reply to the leader.".to_string(),
                     "--workspace".to_string(),
                     team_dir.to_string_lossy().into_owned(),
                     "--team".to_string(),
@@ -4213,7 +4357,7 @@ pub mod lifecycle_port {
                     "team-agent".to_string(),
                     "send".to_string(),
                     "implementer".to_string(),
-                    "请完成任务并把答案回复给 leader。".to_string(),
+                    "Complete the task and reply to the leader.".to_string(),
                     "--workspace".to_string(),
                     team_dir.to_string_lossy().into_owned(),
                     "--team".to_string(),

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/named_address.rs

@@ -78,16 +78,16 @@ pub(crate) struct NamedAddressError {
 
 pub(crate) fn human_address_reason(reason: &str) -> Option<&'static str> {
     Some(match reason {
-        "name_invalid" => "收信队友名不正确；请使用队友列表中的名称。",
-        "workspace_not_found" => "所选项目目录不存在；请核对项目路径。",
+        "name_invalid" => "Invalid recipient name; use a name from the agent list.",
+        "workspace_not_found" => "The selected workspace directory does not exist; verify the path.",
         "state_not_found" | "workspace_no_state" => {
-            "所选项目还没有可用队伍；首次起队用 quick-start，已有队伍恢复用 restart。"
+            "No usable team exists in the selected workspace; use quick-start for initial creation or restart for an initialized team."
         }
-        "team_key_not_found" => "所选项目没有这支队伍；请核对 --workspace 和 --team。",
-        "leader_not_attached" => "主控还没有连接到这支队伍；请先体检，按提示恢复连接。",
-        "name_not_resolvable" => "当前队伍没有这个队友；请先查看队友列表。",
-        "name_not_live" => "该队友当前未运行或连接已失效；请查看状态再恢复。",
-        "name_ambiguous" => "有多个同名对象；请明确选择项目和队伍，不猜对象。",
+        "team_key_not_found" => "The selected workspace has no such team; verify --workspace and --team.",
+        "leader_not_attached" => "No leader is attached to this team; diagnose it and follow the recovery action.",
+        "name_not_resolvable" => "This team has no such agent; check the agent list.",
+        "name_not_live" => "The agent is not running or its channel is stale; check status before recovery.",
+        "name_ambiguous" => "Multiple targets share this name; select an explicit workspace and team.",
         _ => return None,
     })
 }
@@ -121,23 +121,24 @@ impl NamedAddressError {
     pub(crate) fn human_guidance(&self, requested: &str) -> (String, String) {
         let workspace = self.human_scope.as_deref();
         let mut message = format!(
-            "{}\n你刚才填写的是 {requested:?}。",
-            human_address_reason(self.kind.as_str()).unwrap_or("未能找到可用的收信队友。")
+            "{}\nRequested recipient: {requested:?}\nReason: {}",
+            human_address_reason(self.kind.as_str()).unwrap_or("No usable recipient could be resolved."),
+            self.message
         );
         if let Some(workspace) = workspace {
-            message.push_str(&format!("\n所选项目：{:?}。", workspace.to_string_lossy()));
+            message.push_str(&format!("\nSelected workspace: {:?}", workspace.to_string_lossy()));
         }
         if let Some(team) = self.human_team.as_deref() {
-            message.push_str(&format!("\n所选队伍：{team:?}。"));
+            message.push_str(&format!("\nSelected team: {team:?}"));
         }
-        let mut action = "没有可靠的拼写建议；请先核对项目和队伍，不猜对象。".to_string();
+        let mut action = "No reliable spelling suggestion is available; verify the workspace and team before choosing a target.".to_string();
         for candidate in &self.candidates {
             if let (Some(agent), Some(team)) = (
                 candidate.get("agent_id").and_then(Value::as_str),
                 candidate.get("team_key").and_then(Value::as_str),
             ) {
                 message.push_str(&format!(
-                    "\n候选队伍 {team:?}，队友 {agent:?}；请确认是否是你要找的对象。"
+                    "\nCandidate team {team:?}, agent {agent:?}; confirm the intended target."
                 ));
             }
         }
@@ -162,7 +163,7 @@ impl NamedAddressError {
                     if let Some(command) =
                         super::adapters::send_command(agent, workspace, Some(team))
                     {
-                        action = format!("你是否想发给 {agent:?}、队伍 {team:?}？确认后将任务内容替换到这个例子；本次没有发送：\n{command}");
+                        action = format!("Did you mean agent {agent:?} in team {team:?}? After confirmation, replace the example message below. Nothing was sent:\n{command}");
                     }
                 }
             }
@@ -171,7 +172,7 @@ impl NamedAddressError {
             workspace.filter(|path| !path.to_string_lossy().chars().any(char::is_control))
         {
             action.push_str(&format!(
-                "\n也可查看可用队友列表：\nteam-agent status --workspace {}",
+                "\nList available agents with:\nteam-agent status --workspace {}",
                 super::adapters::shell_quote(&workspace.to_string_lossy())
             ));
         }

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

@@ -5,7 +5,7 @@ use crate::provider::argv_route::{self, Config, Mutation, Override, RouteError};
 use crate::provider::Provider;
 use serde_json::{json, Value};
 
-pub(crate) const HELP: &str = "做什么：\n设置工具启动时额外使用的命令行参数，默认关闭。\n用法：team-agent route [status|enable|disable|show [TOOL]|set TOOL -- ARG...|add TOOL -- ARG...|clear TOOL] [--json]\n\n怎么用：\nstatus 看开关；enable 开启；disable 关闭；show 看全部或指定工具的参数。\nset 替换参数；add 追加参数；clear 清除指定工具的参数；--json 给程序读取。\nTOOL 是已支持的工具名称，如 pi/codex/claude/copilot/grok/cursor_agent。\n第一个 -- 后全是工具的字面参数，包含 --help/--json 也不会被这里解析。\n配置保存在 ~/.team-agent/argv-routing.json；影响全机，不按项目或队伍隔离。\nTEAM_AGENT_CLI_ARGV_ROUTING 环境变量优先于保存的开关。\nExamples（可复制）：\nteam-agent route status\nteam-agent route set pi -- --mode text\nteam-agent route enable\n\n下一步（Next Action）：\n用 route show pi 核对参数；仅影响下一次启动，不改变正在运行的对话。\n没有开启或没有配置时，工具仍按原参数启动；不了解参数用途时保持关闭。";
+pub(crate) const HELP: &str = "Purpose:\nConfigure additional provider launch arguments. Disabled by default.\nUsage: team-agent route [status|enable|disable|show [TOOL]|set TOOL -- ARG...|add TOOL -- ARG...|clear TOOL] [--json]\n\nOptions:\nstatus reports the switch; enable/disable change it; show lists all or one provider's arguments.\nset replaces arguments; add appends; clear removes a provider's arguments. Use --json for structured output.\nTOOL is a supported provider name, such as pi/codex/claude/copilot/grok/cursor_agent.\nEverything after the first -- is a literal provider argument, including --help and --json.\nConfiguration: ~/.team-agent/argv-routing.json. This is host-global, not isolated by workspace or team.\nTEAM_AGENT_CLI_ARGV_ROUTING overrides the persisted switch.\nExamples:\nteam-agent route status\nteam-agent route set pi -- --mode text\nteam-agent route enable\n\nNext Action:\nVerify arguments with route show pi. Changes apply to the next launch, not an existing session.\nWithout an enabled configuration, providers retain their original arguments. Leave routing disabled unless the arguments are understood.";
 
 struct Request {
     operation: String,
@@ -16,9 +16,9 @@ struct Request {
 
 fn usage() -> RouteError {
     RouteError {
-        error: "参数不完整或不正确；set/add 需要工具名、-- 和至少一个工具参数".to_string(),
+        error: "Invalid or incomplete arguments; set/add require a provider name, -- and at least one provider argument".to_string(),
         reason: "argv_route_usage",
-        action: "请按 team-agent route --help 的 Examples 填写；例如 team-agent route set pi -- --mode text".to_string(),
+        action: "Follow the Examples in team-agent route --help, such as team-agent route set pi -- --mode text".to_string(),
         config_path: None,
     }
 }
@@ -118,7 +118,7 @@ fn execute(request: &Request) -> Result<Value, RouteError> {
     }
     if override_state != Override::Unset {
         value["notice"] = json!(format!(
-            "当前开关由环境变量 {} 决定（{}）",
+            "Switch overridden by environment variable {} ({})",
             argv_route::ENV_NAME,
             override_state.status()
         ));