@team-agent/installer 0.5.109 → 0.5.111

package/crates/team-agent/src/cli/tests/base.rs

@@ -16,8 +16,16 @@ use serde_json::json;
 fn provider_args_cases() {
     // (old case-id, input, Python golden); values[1:] of a lone "--" is empty.
     const CASES: &[(&str, &[&str], &[&str])] = &[
-        ("provider_args_strips_leading_dashdash", &["--", "-x"], &["-x"]),
-        ("provider_args_keeps_when_no_leading_dashdash", &["-x", "-y"], &["-x", "-y"]),
+        (
+            "provider_args_strips_leading_dashdash",
+            &["--", "-x"],
+            &["-x"],
+        ),
+        (
+            "provider_args_keeps_when_no_leading_dashdash",
+            &["-x", "-y"],
+            &["-x", "-y"],
+        ),
         ("provider_args_empty_is_empty", &[], &[]),
         ("provider_args_lone_dashdash_yields_empty", &["--"], &[]),
     ];
@@ -36,41 +44,73 @@ fn provider_args_cases() {
 fn leader_launcher_args_success_cases() {
     // (old case-id, argv, complete expected structure), including default false flags.
     let cases: &[(&str, &[&str], LeaderLauncherArgs)] = &[
-        ("leader_launcher_args_empty_all_default", &[], LeaderLauncherArgs::default()),
-        ("leader_launcher_args_attach_and_confirm", &["--attach", "--confirm"], LeaderLauncherArgs {
-            attach_existing: true,
-            confirm_attach: true,
-            ..Default::default()
-        }),
+        (
+            "leader_launcher_args_empty_all_default",
+            &[],
+            LeaderLauncherArgs::default(),
+        ),
+        (
+            "leader_launcher_args_attach_and_confirm",
+            &["--attach", "--confirm"],
+            LeaderLauncherArgs {
+                attach_existing: true,
+                confirm_attach: true,
+                ..Default::default()
+            },
+        ),
         // --attach-existing is an alias of --attach.
-        ("leader_launcher_args_attach_existing_alias", &["--attach-existing"], LeaderLauncherArgs {
-            attach_existing: true,
-            ..Default::default()
-        }),
-        ("leader_launcher_args_external_leader_opt_out", &["--external-leader", "--", "--model", "opus"], LeaderLauncherArgs {
-            provider_args: vec!["--model".to_string(), "opus".to_string()],
-            external_leader: true,
-            ..Default::default()
-        }),
-        ("leader_launcher_args_attach_session_spaced", &["--attach-session", "mysess"], LeaderLauncherArgs {
-            attach_session: Some("mysess".to_string()),
-            ..Default::default()
-        }),
-        ("leader_launcher_args_attach_session_equals", &["--attach-session=mysess"], LeaderLauncherArgs {
-            attach_session: Some("mysess".to_string()),
-            ..Default::default()
-        }),
+        (
+            "leader_launcher_args_attach_existing_alias",
+            &["--attach-existing"],
+            LeaderLauncherArgs {
+                attach_existing: true,
+                ..Default::default()
+            },
+        ),
+        (
+            "leader_launcher_args_external_leader_opt_out",
+            &["--external-leader", "--", "--model", "opus"],
+            LeaderLauncherArgs {
+                provider_args: vec!["--model".to_string(), "opus".to_string()],
+                external_leader: true,
+                ..Default::default()
+            },
+        ),
+        (
+            "leader_launcher_args_attach_session_spaced",
+            &["--attach-session", "mysess"],
+            LeaderLauncherArgs {
+                attach_session: Some("mysess".to_string()),
+                ..Default::default()
+            },
+        ),
+        (
+            "leader_launcher_args_attach_session_equals",
+            &["--attach-session=mysess"],
+            LeaderLauncherArgs {
+                attach_session: Some("mysess".to_string()),
+                ..Default::default()
+            },
+        ),
         // Known Team Agent launcher flags after `--` are rejected by the error table.
-        ("leader_launcher_args_dashdash_passthrough_strips_separator", &["--attach", "--", "-x", "--provider-confirm"], LeaderLauncherArgs {
-            provider_args: vec!["-x".to_string(), "--provider-confirm".to_string()],
-            attach_existing: true,
-            ..Default::default()
-        }),
-        ("leader_launcher_args_unknown_tokens_collect_as_provider_args", &["foo", "--attach", "bar"], LeaderLauncherArgs {
-            provider_args: vec!["foo".to_string(), "bar".to_string()],
-            attach_existing: true,
-            ..Default::default()
-        }),
+        (
+            "leader_launcher_args_dashdash_passthrough_strips_separator",
+            &["--attach", "--", "-x", "--provider-confirm"],
+            LeaderLauncherArgs {
+                provider_args: vec!["-x".to_string(), "--provider-confirm".to_string()],
+                attach_existing: true,
+                ..Default::default()
+            },
+        ),
+        (
+            "leader_launcher_args_unknown_tokens_collect_as_provider_args",
+            &["foo", "--attach", "bar"],
+            LeaderLauncherArgs {
+                provider_args: vec!["foo".to_string(), "bar".to_string()],
+                attach_existing: true,
+                ..Default::default()
+            },
+        ),
     ];
     for (id, input, expected) in cases {
         let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
@@ -97,7 +137,10 @@ fn leader_launcher_args_error_cases() {
     for (id, input, expected) in CASES {
         let argv: Vec<String> = input.iter().map(|arg| (*arg).to_string()).collect();
         let err = leader_launcher_args(&argv).expect_err(id);
-        assert!(err.to_string().contains(*expected), "{id}: unexpected error: {err}");
+        assert!(
+            err.to_string().contains(*expected),
+            "{id}: unexpected error: {err}"
+        );
     }
 }
 
@@ -110,14 +153,31 @@ fn send_target_cases() {
     // (old case-id, targets, target, complete expected enum).
     let cases: &[(&str, Option<&str>, Option<&str>, MessageTarget)] = &[
         (
-            "send_target_fanout_strips_and_filters_empty", Some("a, b ,,c"), None,
+            "send_target_fanout_strips_and_filters_empty",
+            Some("a, b ,,c"),
+            None,
             MessageTarget::Fanout(vec!["a".to_string(), "b".to_string(), "c".to_string()]),
         ),
-        ("send_target_single_target", None, Some("agent_x"), MessageTarget::Single("agent_x".to_string())),
+        (
+            "send_target_single_target",
+            None,
+            Some("agent_x"),
+            MessageTarget::Single("agent_x".to_string()),
+        ),
         // A bare "*" means broadcast to the whole team.
-        ("send_target_broadcast_star", None, Some("*"), MessageTarget::Broadcast),
+        (
+            "send_target_broadcast_star",
+            None,
+            Some("*"),
+            MessageTarget::Broadcast,
+        ),
         // targets="" is falsy in Python, so it falls through to args.target.
-        ("send_target_empty_targets_falls_through_to_target", Some(""), Some("fallback"), MessageTarget::Single("fallback".to_string())),
+        (
+            "send_target_empty_targets_falls_through_to_target",
+            Some(""),
+            Some("fallback"),
+            MessageTarget::Single("fallback".to_string()),
+        ),
     ];
     for (id, targets, target, expected) in cases {
         assert_eq!(send_target(*targets, *target), *expected, "{id}");
@@ -133,18 +193,52 @@ fn send_target_cases() {
 fn classify_agent_bucket_cases() {
     // (old case-id, all original (raw, health) inputs, expected bucket).
     const CASES: &[(&str, &[(&str, &str)], SummaryBucket)] = &[
-        ("classify_failed_takes_priority", &[("failed", ""), ("error", ""), ("running", "error")], SummaryBucket::Failed),
-        ("classify_stopped", &[("stopped", ""), ("done", ""), ("running", "done")], SummaryBucket::Stopped),
-        ("classify_busy", &[("busy", ""), ("", "running"), ("", "working")], SummaryBucket::Busy),
+        (
+            "classify_failed_takes_priority",
+            &[("failed", ""), ("error", ""), ("running", "error")],
+            SummaryBucket::Failed,
+        ),
+        (
+            "classify_stopped",
+            &[("stopped", ""), ("done", ""), ("running", "done")],
+            SummaryBucket::Stopped,
+        ),
+        (
+            "classify_busy",
+            &[("busy", ""), ("", "running"), ("", "working")],
+            SummaryBucket::Busy,
+        ),
         // hstatus==idle precedes the raw==running branch.
-        ("classify_hstatus_idle_beats_raw_running", &[("running", "idle")], SummaryBucket::Idle),
-        ("classify_pure_running", &[("running", "")], SummaryBucket::Running),
+        (
+            "classify_hstatus_idle_beats_raw_running",
+            &[("running", "idle")],
+            SummaryBucket::Idle,
+        ),
+        (
+            "classify_pure_running",
+            &[("running", "")],
+            SummaryBucket::Running,
+        ),
         // bug-071/077/085: unmatched and blocked/stuck/missing are Unknown, NEVER idle.
-        ("classify_blocked_and_unmatched_are_unknown_never_idle", &[("blocked", ""), ("stuck", ""), ("", "missing"), ("weird_value", ""), ("", "")], SummaryBucket::Unknown),
+        (
+            "classify_blocked_and_unmatched_are_unknown_never_idle",
+            &[
+                ("blocked", ""),
+                ("stuck", ""),
+                ("", "missing"),
+                ("weird_value", ""),
+                ("", ""),
+            ],
+            SummaryBucket::Unknown,
+        ),
     ];
     for (id, inputs, expected) in CASES {
         for &(raw, health) in inputs.iter() {
-            assert_eq!(classify_agent_bucket(raw, health), *expected, "{id}: raw={raw:?}, health={health:?}");
+            assert_eq!(
+                classify_agent_bucket(raw, health),
+                *expected,
+                "{id}: raw={raw:?}, health={health:?}"
+            );
         }
     }
 }
@@ -395,7 +489,7 @@ fn cli_error_payload_plain_runtime() {
     assert_eq!(payload.error, "some other error");
     assert_eq!(
         payload.action,
-        "run `team-agent doctor` or inspect the log path shown here"
+        "先运行 team-agent doctor --workspace . 检查所选队伍，或查看此处列出的错误日志。"
     );
     assert_eq!(payload.log, "/tmp/y.log");
     assert_eq!(payload.reason, None);
@@ -417,19 +511,14 @@ fn cli_error_payload_tmux_conflict_quick_start_enrichment() {
     // context reset is only through restart --allow-fresh with explicit consent.
     assert_eq!(
             payload.action,
-            "tmux session `my-team` already exists. It may be your own existing team. \
-To resume it use `team-agent restart`. \
-If recovery is impossible, use `team-agent restart --allow-fresh` only after explicit context-loss consent. \
-Only if you want a separate team, change `name:` in TEAM.md and run quick-start again. \
-Never terminate existing tmux sessions from quick-start."
-        );
-    assert_eq!(
-            payload.next_actions,
-            Some(vec![
-                "If this is your existing team, resume it with `team-agent restart`.".to_string(),
-                "If you want a separate team, change `name:` in TEAM.md and run `team-agent quick-start` again.".to_string(),
-            ])
+            "终端会话 `my-team` 已存在，可能是你的已有队伍。恢复用 team-agent restart；只有明确同意丢弃旧对话才用 --allow-fresh。另建队伍请修改 TEAM.md 的 name 后再 quick-start；不要关闭已有队伍凑成功。"
         );
+    let next = payload.next_actions.as_ref().unwrap();
+    assert_eq!(next.len(), 2);
+    assert!(next[0].contains("team-agent restart"));
+    assert!(
+        next[1].contains("TEAM.md") && next[1].contains("name") && next[1].contains("quick-start")
+    );
 }
 
 #[test]
@@ -440,16 +529,11 @@ fn cli_error_payload_tmux_conflict_non_quick_start_enrichment() {
     assert_eq!(payload.session_name.as_deref(), Some("my-team"));
     assert_eq!(
         payload.action,
-        "tmux session `my-team` already exists. It may be an active team. \
-Do not terminate existing tmux sessions from startup; \
-use a different team name or runtime.session_name and start again."
-    );
-    assert_eq!(
-        payload.next_actions,
-        Some(vec![
-            "Use a different team name or runtime.session_name before starting again.".to_string()
-        ])
+        "终端会话 `my-team` 已存在，可能属于运行中的队伍。不要关闭它；请使用另一个队伍名称后再启动。"
     );
+    let next = payload.next_actions.as_ref().unwrap();
+    assert_eq!(next.len(), 1);
+    assert!(next[0].contains("队伍") && next[0].contains("名称"));
 }
 
 #[test]
@@ -641,19 +725,42 @@ fn cmd_status_summary_with_agent_rejected() {
 // =========================================================================
 
 #[test]
-fn cmd_leader_passthrough_help_returns_none() {
-    // parser.py:516: provider_args in (["-h"],["--help"]) -> print usage, return (no emit).
-    let r = cmd_leader_passthrough("codex", &["-h".into()], Path::new(".")).unwrap();
-    assert_eq!(r.output, CmdOutput::None);
-    assert_eq!(r.exit, ExitCode::Ok);
-    let r2 = cmd_leader_passthrough("claude", &["--help".into()], Path::new(".")).unwrap();
-    assert_eq!(r2.output, CmdOutput::None);
-    let r3 = cmd_leader_passthrough("copilot", &["--help".into()], Path::new(".")).unwrap();
-    assert_eq!(r3.output, CmdOutput::None);
-    let r4 = cmd_leader_passthrough("grok", &["-h".into()], Path::new(".")).unwrap();
-    assert_eq!(r4.output, CmdOutput::None);
-    let r5 = cmd_leader_passthrough("cursor", &["--help".into()], Path::new(".")).unwrap();
-    assert_eq!(r5.output, CmdOutput::None);
+#[serial_test::serial(env)]
+fn cmd_leader_passthrough_help_is_pure_human_guidance() {
+    let env = crate::cli::hermetic_test_support::HermeticTestEnv::enter("launcher-help-unit");
+    let cwd = env.workspace("empty");
+    let tools = [
+        "pi", "codex", "claude", "copilot", "grok", "agent", "cursor",
+    ];
+    let bin = env.root().join("canaries");
+    std::fs::create_dir(&bin).unwrap();
+    #[cfg(unix)]
+    let _path = {
+        use std::os::unix::fs::PermissionsExt;
+        for tool in tools {
+            let path = bin.join(tool);
+            std::fs::write(&path, "#!/bin/sh\nprintf called > \"$0.called\"\nexit 0\n").unwrap();
+            std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).unwrap();
+        }
+        env.with_env("PATH", &bin.to_string_lossy())
+    };
+    for provider in ["pi", "codex", "claude", "copilot", "grok", "cursor"] {
+        for alias in ["-h", "--help"] {
+            let result = cmd_leader_passthrough(provider, &[alias.into()], &cwd).unwrap();
+            assert_eq!(result.exit, ExitCode::Ok);
+            assert!(
+                matches!(&result.output, CmdOutput::Human(text) if text.contains(provider) && text.contains("用法") && text.contains("Examples") && text.contains("下一步"))
+            );
+        }
+    }
+    assert_eq!(std::fs::read_dir(&cwd).unwrap().count(), 0);
+    assert!(env.registry_entries().is_empty());
+    for tool in tools {
+        assert!(
+            !bin.join(format!("{tool}.called")).exists(),
+            "native tool invoked"
+        );
+    }
 }
 
 #[test]

package/crates/team-agent/src/cli/tests/lane_c.rs

@@ -257,8 +257,7 @@ fn inbox_excludes_leader_stage_result_notifications() {
 // the deterministic check sub-shapes (run_id is a random uuid; not value-locked). ────────────────
 #[test]
 fn comms_selftest_golden_boundary_scope_and_check_shapes() {
-    let boundary = "validates live pane binding consistency and zero-token comms contracts. \
-                        Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
+    let boundary = "这里只检查终端连接是否一致，不实际发送消息，也不证明队友已回复。";
     let ws = tmp_workspace();
     let v = diagnose_port::comms_selftest(&ws, None, None).expect("comms_selftest");
     let obj = v.as_object().expect("comms dict");

package/crates/team-agent/src/cli/tests/named_address.rs

@@ -248,12 +248,9 @@ fn resolve_qualified_name_prefers_unique_state_pane_over_same_window_idle_pane()
         pane("team-a", "qa", "%idle"),
     ]);
 
-    let resolved = resolve_name_with_transport(
-        &ws,
-        &format!("{}::team-a/qa", ws.display()),
-        &transport,
-    )
-    .expect("a qualified worker address should use its unique state pane");
+    let resolved =
+        resolve_name_with_transport(&ws, &format!("{}::team-a/qa", ws.display()), &transport)
+            .expect("a qualified worker address should use its unique state pane");
     assert_eq!(resolved.pane_id, "%worker");
     assert_eq!(resolved.state_pane_id.as_deref(), Some("%worker"));
     assert!(!resolved.state_pane_stale);
@@ -271,11 +268,17 @@ fn resolve_qualified_name_state_pane_must_uniquely_match_scoped_candidates() {
                     .as_object_mut()
                     .unwrap()
                     .remove("pane_id");
-                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+                vec![
+                    pane("team-a", "qa", "%worker"),
+                    pane("team-a", "qa", "%idle"),
+                ]
             }
             "stale" => {
                 team["agents"]["qa"]["pane_id"] = json!("%stale");
-                vec![pane("team-a", "qa", "%worker"), pane("team-a", "qa", "%idle")]
+                vec![
+                    pane("team-a", "qa", "%worker"),
+                    pane("team-a", "qa", "%idle"),
+                ]
             }
             "cross-session" => vec![
                 pane("old-team-a", "qa", "%worker"),
@@ -293,12 +296,9 @@ fn resolve_qualified_name_state_pane_must_uniquely_match_scoped_candidates() {
         };
         seed_state(&ws, state_with_teams(json!({"team-a": team})));
         let transport = OfflineTransport::new().with_targets(targets);
-        let err = resolve_name_with_transport(
-            &ws,
-            &format!("{}::team-a/qa", ws.display()),
-            &transport,
-        )
-        .expect_err("non-unique state pane evidence must remain fail-closed");
+        let err =
+            resolve_name_with_transport(&ws, &format!("{}::team-a/qa", ws.display()), &transport)
+                .expect_err("non-unique state pane evidence must remain fail-closed");
         assert_eq!(err.kind, NamedAddressErrorKind::NameAmbiguous, "{scenario}");
         let _ = std::fs::remove_dir_all(&ws);
     }
@@ -313,11 +313,8 @@ fn resolve_qualified_name_canonicalizes_legacy_session_alias() {
             "teamdir": worker_team("team-displayname", "qa", "%1", "qa")
         })),
     );
-    let transport = OfflineTransport::new().with_targets(vec![pane(
-        "team-displayname",
-        "qa",
-        "%1",
-    )]);
+    let transport =
+        OfflineTransport::new().with_targets(vec![pane("team-displayname", "qa", "%1")]);
 
     let resolved = resolve_name_with_transport(&ws, "displayname/qa", &transport)
         .expect("qualified legacy alias must resolve through the canonical selector");
@@ -380,21 +377,21 @@ fn send_to_name_mutual_exclusion() {
     let args = named_send_args(&cwd, Some("team-a/qa"), Some("%1"), None, &["hello"]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message.contains("--to-name and --pane/TARGET/--to are mutually exclusive")),
+        matches!(err, CliError::Usage(ref message) if message.contains("--to-name/--pane/--to") && message.contains("不能同时")),
         "expected --to-name mutual exclusion, got {err:?}"
     );
 
     let args = named_send_args(&cwd, Some("team-a/qa"), None, Some("worker"), &["hello"]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message.contains("--to-name and --pane/TARGET/--to are mutually exclusive")),
+        matches!(err, CliError::Usage(ref message) if message.contains("--to-name/--pane/--to") && message.contains("不能同时")),
         "expected --to-name/--to mutual exclusion, got {err:?}"
     );
 
     let args = named_send_args(&cwd, Some("team-a/qa"), None, None, &[]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message == "--to-name requires a non-empty message"),
+        matches!(err, CliError::Usage(ref message) if message == "请填写任务内容；--to-name 不能发送空消息"),
         "expected empty-message usage error, got {err:?}"
     );
     let _ = std::fs::remove_dir_all(&cwd);

package/crates/team-agent/src/cli/tests/status_send.rs

@@ -645,7 +645,7 @@ fn cmd_send_joins_message_with_single_space() {
                 );
                 assert_eq!(
                     v.get("reminder").and_then(|reminder| reminder.as_str()),
-                    Some("Message queued; coordinator will notify when the worker receives it. Do not poll the worker terminal with capture-pane.")
+                    Some("任务已收下，但还未确认送到队友对话。查看 team-agent status/doctor，等真实回复，不反复重发。")
                 );
             }
         }
@@ -654,22 +654,27 @@ fn cmd_send_joins_message_with_single_space() {
 }
 
 #[test]
-fn cmd_send_default_human_output_is_one_line_without_false_delivered() {
+fn cmd_send_default_human_output_is_brief_without_false_delivered() {
     let r = cmd_send(&queued_send_args_fixture(false)).expect("cmd_send returns CmdResult");
     assert!(!r.as_json);
     let text = emit(&r.output, r.as_json).expect("send should render human text");
     let lines: Vec<_> = text.lines().collect();
     assert_eq!(
         lines.len(),
-        1,
-        "default send output must be one line: {text}"
+        2,
+        "send must separate outcome and next action: {text}"
     );
     assert!(
-        lines[0].contains("ok:")
-            && lines[0].contains("status:")
-            && lines[0].contains("message_id:")
-            && lines[0].contains("target:"),
-        "default send output must keep only the core fields; got {text}"
+        lines[0].contains("任务已收下") && lines[0].contains("还未送到队友的对话"),
+        "queued send must report its true pending outcome: {text}"
+    );
+    assert!(
+        lines[1].contains("下一步")
+            && lines[1].contains("team-agent status")
+            && lines[1].contains("doctor")
+            && lines[1].contains("等真实回复")
+            && lines[1].contains("不反复重发"),
+        "queued send must give honest next steps: {text}"
     );
     assert!(
         !text.contains("delivered"),
@@ -946,7 +951,7 @@ fn cmd_send_unknown_task_surfaces_golden_error_envelope_not_silent() {
     );
     assert_eq!(
         payload.action,
-        "run `team-agent doctor` or inspect the log path shown here"
+        "先运行 team-agent doctor --workspace . 检查所选队伍，或查看此处列出的错误日志。"
     );
     let _ = std::fs::remove_dir_all(&ws);
 }

package/crates/team-agent/src/cli/tests/verb_install_skill.rs

@@ -62,8 +62,8 @@ fn install_skill_missing_source_is_usage_error() {
     );
     assert_eq!(
         code,
-        ExitCode::Error,
-        "install-skill without --source must error (CliError::Usage -> emit_cli_error exit 1)"
+        ExitCode::Usage,
+        "known missing --source must give pure Usage2 guidance"
     );
     let _ = std::fs::remove_dir_all(&ws);
 }

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

@@ -41,6 +41,13 @@ pub enum CliError {
     /// `peek` 缺 `--allow-raw-screen`)。对应 Python 抛 `TeamAgentError` 或 parser.error。
     #[error("usage error: {0}")]
     Usage(String),
+    /// Preserve the original refusal for audit while carrying safe human guidance.
+    #[error("usage error: {audit}")]
+    AddressRefusal {
+        audit: String,
+        error: String,
+        action: String,
+    },
     /// state 解析失败(歧义/未找到 team 等)。透传 step 5。
     #[error("{0}")]
     State(#[from] crate::state::StateError),
@@ -76,7 +83,12 @@ impl CliError {
         let mut payload = CliErrorPayload {
             ok: false,
             error: error.clone(),
-            action: "run `team-agent doctor` or inspect the log path shown here".to_string(),
+            action: if super::spec::command_spec(command).is_some() {
+                "先运行 team-agent doctor --workspace . 检查所选队伍，或查看此处列出的错误日志。"
+            } else {
+                "run `team-agent doctor` or inspect the log path shown here"
+            }
+            .to_string(),
             log: log_path.to_string_lossy().to_string(),
             reason: None,
             session_name: None,
@@ -87,30 +99,27 @@ impl CliError {
             payload.session_name = Some(session.clone());
             if command == "quick-start" {
                 payload.action = format!(
-                    "tmux session `{session}` already exists. It may be your own existing team. To resume it use `team-agent restart`. If recovery is impossible, use `team-agent restart --allow-fresh` only after explicit context-loss consent. Only if you want a separate team, change `name:` in TEAM.md and run quick-start again. Never terminate existing tmux sessions from quick-start."
+                    "终端会话 `{session}` 已存在，可能是你的已有队伍。恢复用 team-agent restart；只有明确同意丢弃旧对话才用 --allow-fresh。另建队伍请修改 TEAM.md 的 name 后再 quick-start；不要关闭已有队伍凑成功。"
                 );
                 payload.next_actions = Some(vec![
-                    "If this is your existing team, resume it with `team-agent restart`.".to_string(),
-                    "If you want a separate team, change `name:` in TEAM.md and run `team-agent quick-start` again.".to_string(),
+                    "如果是自己的已有队伍，使用 team-agent restart 恢复。".to_string(),
+                    "如要另建队伍，修改 TEAM.md 的 name 后再运行 team-agent quick-start。"
+                        .to_string(),
                 ]);
             } else {
                 payload.action = format!(
-                    "tmux session `{session}` already exists. It may be an active team. Do not terminate existing tmux sessions from startup; use a different team name or runtime.session_name and start again."
+                    "终端会话 `{session}` 已存在，可能属于运行中的队伍。不要关闭它；请使用另一个队伍名称后再启动。"
                 );
-                payload.next_actions = Some(vec![
-                    "Use a different team name or runtime.session_name before starting again."
-                        .to_string(),
-                ]);
+                payload.next_actions = Some(vec!["请使用另一个队伍名称后再启动。".to_string()]);
             }
         } else if error.contains("Team Agent launcher flag")
             && error.contains("must appear before --")
         {
-            payload.action = String::from(
-                "move the Team Agent launcher flag before `--`; only provider flags belong after `--`",
-            );
+            payload.action =
+                String::from("将主控启动选项放在 -- 前面；-- 后面只能是工具自己的参数。");
         } else if error.contains("managed launcher refuses a different ambient tmux server") {
             payload.action = String::from(
-                "leave the current tmux client and retry, or pass `--allow-nested-attach` before `--` to opt in to a nested managed attach",
+                "先退出当前 tmux 客户端再重试；只有明确需要嵌套连接时才在 -- 前加 --allow-nested-attach。",
             );
         }
         payload

package/crates/team-agent/src/leader/registry.rs

@@ -816,7 +816,7 @@ mod tests {
     }
 
     #[test]
-    #[serial]
+    #[serial(env)]
     fn prune_removes_team_proven_terminal() {
         let (_home_guard, _home, workspace) = test_home("terminal");
         write_state(
@@ -834,7 +834,7 @@ mod tests {
     }
 
     #[test]
-    #[serial]
+    #[serial(env)]
     fn prune_removes_missing_key_only_from_valid_teams_map() {
         let (_home_guard, _home, workspace) = test_home("missing-key");
         write_state(&workspace, json!({"teams": {"other": {"status": "alive"}}}));
@@ -850,7 +850,7 @@ mod tests {
     }
 
     #[test]
-    #[serial]
+    #[serial(env)]
     fn prune_keeps_null_nonobject_and_legacy_teams_shapes() {
         for (label, state) in [
             ("null", json!({"teams": null})),

package/crates/team-agent/src/leader/start.rs

@@ -291,7 +291,7 @@ fn leader_start_plan_with_ambient_authority(
         ),
         _ => None,
     };
-    let provider_argv = if provider == Provider::Pi && mode != LeaderStartMode::AttachExisting {
+    let mut provider_argv = if provider == Provider::Pi && mode != LeaderStartMode::AttachExisting {
         let parsed = crate::lifecycle::launch::pi_mcp::parse_pi_leader_args(provider_args)
             .map_err(|error| LeaderError::Start(error.to_string()))?;
         let mcp_config = adapter
@@ -329,6 +329,10 @@ fn leader_start_plan_with_ambient_authority(
     } else {
         provider_command_argv(provider, provider_args)
     };
+    if mode != LeaderStartMode::AttachExisting {
+        crate::provider::argv_route::apply(provider, &mut provider_argv)
+            .map_err(|error| LeaderError::Start(error.to_string()))?;
+    }
     let argv = start_argv(
         mode,
         provider,

package/crates/team-agent/src/lifecycle/launch/spawn.rs

@@ -330,6 +330,8 @@ pub(super) fn spawn_agents(
             ensure_grok_login_and_folder_trust(workspace)?;
             apply_grok_mcp_overlay(workspace, &mcp_config)?;
         }
+        crate::provider::argv_route::apply(provider, &mut plan.argv)
+            .map_err(|error| LifecycleError::Provider(error.to_string()))?;
         let spawn_epoch = u64::try_from(started.len()).unwrap_or(u64::MAX);
         let spawned_at = spawn_timestamp_for_agent(u32::try_from(spawn_epoch).unwrap_or(u32::MAX));
         // E6 层1 实证3 + 诊断留痕:落最终 worker argv(spawn 前的真实形态)。