@team-agent/installer 0.3.7 → 0.3.9

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

@@ -1,4 +1,41 @@
 use super::*;
+use serial_test::serial;
+
+struct EnvUnsetGuard {
+    previous: Vec<(&'static str, Option<String>)>,
+}
+
+impl EnvUnsetGuard {
+    fn unset(keys: &[&'static str]) -> Self {
+        let previous = keys
+            .iter()
+            .map(|key| (*key, std::env::var(key).ok()))
+            .collect::<Vec<_>>();
+        for key in keys {
+            std::env::remove_var(key);
+        }
+        Self { previous }
+    }
+}
+
+impl Drop for EnvUnsetGuard {
+    fn drop(&mut self) {
+        for (key, value) in self.previous.drain(..).rev() {
+            match value {
+                Some(value) => std::env::set_var(key, value),
+                None => std::env::remove_var(key),
+            }
+        }
+    }
+}
+
+struct WorkspaceCleanup(std::path::PathBuf);
+
+impl Drop for WorkspaceCleanup {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
 
     // =========================================================================
     // WAVE-2 NON-SUB CHECKPOINT — 9 MISSING CLI subcommands (ABSENT from cli/emit.rs dispatch).
@@ -131,6 +168,36 @@ tasks:
         std::fs::write(ws.join("team.spec.yaml"), spec).unwrap();
     }
 
+    fn seed_collect_runtime_state(ws: &std::path::Path) {
+        crate::state::persist::save_runtime_state(
+            ws,
+            &json!({
+                "active_team_key": "fake-e2e",
+                "team_dir": ws.to_string_lossy().to_string(),
+                "spec_path": ws.join("team.spec.yaml").to_string_lossy().to_string(),
+                "session_name": "team-agent-fake-e2e",
+                "leader": {"id": "leader"},
+                "agents": {
+                    "fake_impl": {
+                        "status": "running",
+                        "provider": "fake",
+                        "role": "implementation_engineer",
+                        "window": "fake_impl",
+                        "owner_team_id": "fake-e2e"
+                    }
+                },
+                "tasks": [{
+                    "id": "task_impl",
+                    "title": "Fake implementation",
+                    "type": "implementation",
+                    "status": "pending",
+                    "assignee": "fake_impl"
+                }]
+            }),
+        )
+        .unwrap();
+    }
+
     // ── sessions ── golden cli/parser.py:230 `cmd_sessions` -> runtime.sessions(ws). EXIT 0.
     // `team-agent sessions --workspace <ws> --json` on an empty ws ->
     //   {"ok":true,"sessions":[],"workspace":"<ws>"}  (--json sort_keys). RED: unrouted -> Error.
@@ -169,9 +236,25 @@ tasks:
     //    "delivered_messages":[],"invalid_results":[],"ok":true,"results":{...},"state_file":"<ws>/team_state.md"}
     // RED: unrouted -> Error.
     #[test]
+    #[serial(env)]
     fn dispatch_routes_collect_with_spec() {
+        let _env = EnvUnsetGuard::unset(&[
+            "TEAM_AGENT_WORKSPACE",
+            "TEAM_AGENT_TEAM_ID",
+            "TEAM_AGENT_OWNER_TEAM_ID",
+            "TEAM_AGENT_ACTIVE_TEAM",
+            "TEAM_AGENT_ID",
+            "TEAM_AGENT_LEADER_PANE_ID",
+            "TEAM_AGENT_LEADER_SESSION_UUID",
+            "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+            "TEAM_AGENT_LEADER_PROVIDER",
+            "TMUX",
+            "TMUX_PANE",
+        ]);
         let ws = tmp_workspace();
+        let _cleanup = WorkspaceCleanup(ws.clone());
         seed_team_spec(&ws);
+        seed_collect_runtime_state(&ws);
         let code = run(&cli_argv(&["collect", "--workspace", &ws.to_string_lossy(), "--json"]), &ws);
         assert_eq!(
             code,
@@ -180,7 +263,6 @@ tasks:
              {{collected,collected_results,coordinator,delivered_messages,invalid_results,ok,results,state_file}}; \
              today -> unknown-subcommand Error"
         );
-        let _ = std::fs::remove_dir_all(&ws);
     }
 
     // ── repair-state ── golden parser.py:303 `cmd_repair_state` -> runtime.repair_state (quick_start.py:285).

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

@@ -94,5 +94,6 @@ mod status_send;
 mod verb_validate;
 mod verb_settle;
 mod verb_profile;
+mod verb_install_skill;
 mod main_preserved;
 mod shutdown_kill_plan;

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

@@ -264,9 +264,13 @@ fn current_uid() -> Option<String> {
             json: true,
         };
         let text = outcome_text(cmd_restart(&args));
+        // RED-2-STILL: entry gate now resolves via canonical_run_workspace; for a no-spec workspace
+        // the "no spec" surfacing may come from either the entry gate ("missing spec for restart")
+        // or, when a stray ancestor .team lets it past, the resolve gate ("active team spec not
+        // found"). Both are the REAL crate::lifecycle error (not a placeholder ok:true).
         assert!(
-            text.contains("missing spec for restart"),
-            "cmd_restart must surface the REAL crate::lifecycle::restart 'missing spec for restart' error \
+            text.contains("missing spec for restart") || text.contains("active team spec not found"),
+            "cmd_restart must surface the REAL crate::lifecycle::restart missing-spec error \
              (not the placeholder's canned ok:true); got {text}"
         );
     }

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

@@ -1,39 +1,104 @@
-//! B5/F1 · `sessions_to_kill_sparing_leader` 纯函数单测(kill 决策下沉后锁定)。
+//! E12 (P0) · `sessions_to_kill` 纯决策单测(kill 决策下沉)。
 //!
-//! 真相源 = `team-agent-leader-` 确定性命名前缀(leader/start.rs LEADER_SESSION_PREFIX);
-//! 集成面由 tests/b5_leader_terminal_kill_red.rs 的真 tmux 契约覆盖,此处锁纯决策。
+//! spare = state 锚 session(anchor_sessions) ∪ `team-agent-leader-` 命名前缀(并集,锚优先)。
+//! 独享 socket(无 spare)才允许整 server 拆;共享/leader 在 → 逐 session kill。
+//! 集成面由 tests/b5_leader_terminal_kill_red.rs 的真 tmux 契约覆盖,此处锁纯决策 + 4 反向 case。
 
-use crate::cli::lifecycle_port::sessions_to_kill_sparing_leader;
+use crate::cli::lifecycle_port::{sessions_to_kill, KillDecision};
 use crate::transport::SessionName;
+use std::collections::BTreeSet;
 
 fn names(raw: &[&str]) -> Vec<SessionName> {
     raw.iter().map(|name| SessionName::new(*name)).collect()
 }
 
+fn anchors(raw: &[&str]) -> BTreeSet<String> {
+    raw.iter().map(|s| s.to_string()).collect()
+}
+
+// RC-4(独享 socket):仅目标 session(无 spare)→ 整 server 拆。
+#[test]
+fn rc4_exclusive_socket_kills_server() {
+    assert_eq!(
+        sessions_to_kill(&names(&["team-x", "team-y"]), &BTreeSet::new()),
+        KillDecision::KillServerExclusive
+    );
+    // 空 session 集 → 逐 kill(no-op),不整 server 拆(没东西可拆)。
+    assert_eq!(
+        sessions_to_kill(&[], &BTreeSet::new()),
+        KillDecision::KillIndividually { to_kill: vec![], spared: vec![] }
+    );
+}
+
+// RC-1(本 P0 复现):in_tmux leader 在用户 session(**无前缀**),靠 state 锚 spare → 用户 session 存活。
 #[test]
-fn no_leader_session_means_whole_server_kill() {
-    assert_eq!(sessions_to_kill_sparing_leader(&names(&["team-x"])), None);
-    assert_eq!(sessions_to_kill_sparing_leader(&[]), None);
+fn rc1_in_tmux_no_prefix_anchor_spares_user_session() {
+    let sessions = names(&["team-coder-team", "team-x"]); // 用户 session 无 leader 前缀
+    let anchor = anchors(&["team-coder-team"]); // state 锚 pane 所在 session
+    let decision = sessions_to_kill(&sessions, &anchor);
+    match decision {
+        KillDecision::KillIndividually { to_kill, spared } => {
+            assert_eq!(to_kill, names(&["team-x"]), "only non-anchor session killed");
+            assert_eq!(spared, names(&["team-coder-team"]), "user/leader session spared by anchor");
+        }
+        other => panic!("anchor session must force per-session kill, not {other:?}"),
+    }
+}
+
+// 前缀判据仍生效(并集):leader 前缀 session spare,即使无 state 锚。
+#[test]
+fn prefix_session_spared_without_anchor() {
+    let sessions = names(&["team-agent-leader-claude-ws-deadbeef", "team-x"]);
+    let decision = sessions_to_kill(&sessions, &BTreeSet::new());
+    match decision {
+        KillDecision::KillIndividually { to_kill, spared } => {
+            assert_eq!(to_kill, names(&["team-x"]));
+            assert_eq!(spared, names(&["team-agent-leader-claude-ws-deadbeef"]));
+        }
+        other => panic!("prefix session must spare, not {other:?}"),
+    }
+}
+
+// RC-2(state 损坏无锚):anchor_sessions 空 → 退命名前缀判据(此处仅前缀 spare;无前缀则全 kill)。
+// (spare_fallback_to_naming event 在 anchor_anchor_sessions 发,本纯函数只验退化后的决策。)
+#[test]
+fn rc2_no_anchor_falls_back_to_naming() {
+    // 无锚 + 有前缀 leader → 前缀 spare。
+    let with_leader = sessions_to_kill(
+        &names(&["team-agent-leader-codex-ws-cafe", "team-x"]),
+        &BTreeSet::new(),
+    );
+    assert!(matches!(with_leader, KillDecision::KillIndividually { .. }));
+    // 无锚 + 无前缀(真损坏且 in_tmux 无前缀)→ 无 spare → 独享拆(退化兜底,与历史一致)。
+    assert_eq!(
+        sessions_to_kill(&names(&["team-x"]), &BTreeSet::new()),
+        KillDecision::KillServerExclusive
+    );
 }
 
+// RC-3(共享 socket):目标 2 session + 用户 1 session(锚)→ 只 kill 目标 2,用户存活,不整 server 拆。
 #[test]
-fn leader_session_present_kills_only_non_leader_sessions() {
-    let sessions = names(&[
-        "team-agent-leader-claude-myws-deadbeef",
-        "team-x",
-        "team-y",
-    ]);
-    let to_kill = sessions_to_kill_sparing_leader(&sessions)
-        .expect("leader present must switch to per-session kills");
-    assert_eq!(to_kill, names(&["team-x", "team-y"]));
+fn rc3_shared_socket_kills_only_target_sessions() {
+    let sessions = names(&["team-a", "team-b", "user-shell"]);
+    let anchor = anchors(&["user-shell"]);
+    let decision = sessions_to_kill(&sessions, &anchor);
+    match decision {
+        KillDecision::KillIndividually { to_kill, spared } => {
+            assert_eq!(to_kill, names(&["team-a", "team-b"]));
+            assert_eq!(spared, names(&["user-shell"]));
+        }
+        other => panic!("shared socket must not whole-server kill, got {other:?}"),
+    }
 }
 
+// 并集语义:同一 session 既前缀又锚 → spare 一次(不重复)。
 #[test]
-fn only_leader_sessions_left_kills_nothing_but_keeps_server() {
-    let sessions = names(&["team-agent-leader-codex-myws-cafe0123"]);
+fn union_prefix_and_anchor_no_double_count() {
+    let sessions = names(&["team-agent-leader-claude-ws-beef"]);
+    let anchor = anchors(&["team-agent-leader-claude-ws-beef"]);
+    let decision = sessions_to_kill(&sessions, &anchor);
     assert_eq!(
-        sessions_to_kill_sparing_leader(&sessions),
-        Some(Vec::new()),
-        "a socket holding only leader sessions must not be torn down"
+        decision,
+        KillDecision::KillIndividually { to_kill: vec![], spared: names(&["team-agent-leader-claude-ws-beef"]) }
     );
 }

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

@@ -0,0 +1,76 @@
+use super::*;
+
+// RED-1 根治:install-skill 必须作为真 CLI 子命令存在(此前 packaging::install_skill 未接进
+// 任何 dispatch=双重死代码,install.mjs 走自己的 JS 拷贝逻辑漏 copilot)。
+// 这里钉:① 子命令路由 ② --target all 默认 ③ --source 必需 ④ 缺 source 显式 Usage 错。
+
+fn skill_source() -> PathBuf {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static CTR: AtomicU64 = AtomicU64::new(0);
+    let dir = std::env::temp_dir().join(format!(
+        "ta-cli-installskill-src-{}-{}",
+        std::process::id(),
+        CTR.fetch_add(1, Ordering::Relaxed)
+    ));
+    std::fs::create_dir_all(dir.join("team-agent")).unwrap();
+    std::fs::write(dir.join("team-agent").join("SKILL.md"), b"---\nname: team-agent\n---\nbody\n").unwrap();
+    dir.join("team-agent")
+}
+
+#[test]
+fn dispatch_routes_install_skill_dry_run_all() {
+    let ws = tmp_workspace();
+    let source = skill_source();
+    // --dry-run 不落地(不碰真实 HOME),只验路由 + exit 0。
+    let code = run(
+        &[
+            "install-skill".to_string(),
+            "--target".to_string(),
+            "all".to_string(),
+            "--source".to_string(),
+            source.to_string_lossy().to_string(),
+            "--dry-run".to_string(),
+            "--json".to_string(),
+        ],
+        &ws,
+    );
+    assert_eq!(code, ExitCode::Ok, "`install-skill --target all --source <dir> --dry-run` must route + exit 0");
+    let _ = std::fs::remove_dir_all(&ws);
+    let _ = std::fs::remove_dir_all(source.parent().unwrap());
+}
+
+#[test]
+fn install_skill_missing_source_is_usage_error() {
+    let ws = tmp_workspace();
+    // 无 --source → Usage 错(exit 2),不静默。
+    let code = run(
+        &[
+            "install-skill".to_string(),
+            "--target".to_string(),
+            "all".to_string(),
+            "--json".to_string(),
+        ],
+        &ws,
+    );
+    assert_eq!(code, ExitCode::Error, "install-skill without --source must error (CliError::Usage -> emit_cli_error exit 1)");
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn install_skill_invalid_target_is_usage_error() {
+    let ws = tmp_workspace();
+    let source = skill_source();
+    let code = run(
+        &[
+            "install-skill".to_string(),
+            "--target".to_string(),
+            "bogus".to_string(),
+            "--source".to_string(),
+            source.to_string_lossy().to_string(),
+        ],
+        &ws,
+    );
+    assert_eq!(code, ExitCode::Error, "install-skill --target bogus must error (CliError::Usage -> emit_cli_error exit 1)");
+    let _ = std::fs::remove_dir_all(&ws);
+    let _ = std::fs::remove_dir_all(source.parent().unwrap());
+}

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

@@ -189,15 +189,29 @@ fn bind_provider_from_env_or_command(command: &str) -> Provider {
     std::env::var("TEAM_AGENT_LEADER_PROVIDER")
         .ok()
         .and_then(|raw| super::helpers::parse_provider(&raw))
-        .unwrap_or_else(|| provider_from_command(command))
+        .or_else(|| provider_from_command(command))
+        // E11 层2:未知命令不再静默默认 codex(会误绑任意 provider + 喂错分类器)。
+        // 无法识别时回落 Codex 仅作最末兜底,且该路径已被 provider_from_command 的显式 None 收窄
+        // (调用方理应只在已知 leader 命令上 bind);保留以不改 fn 签名/上游 panic 面。
+        .unwrap_or(Provider::Codex)
 }
 
-fn provider_from_command(command: &str) -> Provider {
+/// E11 层2 + N39:command 名 → wire 串 → `parse_provider`(**单一映射源**,与
+/// `owner_bind_provider_wire` 共用 [`command_provider_wire`])。未知命令 → `None`
+/// (危险的 `_ => Codex` 默认已删:不静默把任意 provider 误绑成 codex)。
+fn provider_from_command(command: &str) -> Option<Provider> {
+    command_provider_wire(command).and_then(super::helpers::parse_provider)
+}
+
+/// command 名 → provider wire 串(单一真相;copilot/claude/codex/fake)。未知 → `None`。
+/// `claude.exe` 归一为 `claude`。
+fn command_provider_wire(command: &str) -> Option<&'static str> {
     match exact_command_name(command).as_deref() {
-        Some("claude") | Some("claude.exe") => Provider::Claude,
-        Some("codex") => Provider::Codex,
-        Some("fake") => Provider::Fake,
-        _ => Provider::Codex,
+        Some("claude") | Some("claude.exe") => Some("claude"),
+        Some("codex") => Some("codex"),
+        Some("copilot") => Some("copilot"),
+        Some("fake") => Some("fake"),
+        _ => None,
     }
 }
 
@@ -214,21 +228,15 @@ fn exact_command_name(command: &str) -> Option<String> {
 
 pub fn owner_bind_provider_wire(command: &str) -> &'static str {
     if let Ok(raw) = std::env::var("TEAM_AGENT_LEADER_PROVIDER") {
-        return match raw.as_str() {
-            "claude" => "claude",
-            "claude_code" => "claude_code",
-            "codex" => "codex",
-            "gemini_cli" => "gemini_cli",
-            "fake" => "fake",
-            _ => "",
-        };
-    }
-    match exact_command_name(command).as_deref() {
-        Some("claude") | Some("claude.exe") => "claude",
-        Some("codex") => "codex",
-        Some("fake") => "fake",
-        _ => "",
+        // env 显式 provider:经 parse_provider(单一表,知 copilot)校验后透传其 wire 串;
+        // 不识别 → ""(空,与原行为一致:不绑)。
+        return super::helpers::parse_provider(&raw)
+            .map(super::helpers::provider_wire)
+            .unwrap_or("");
     }
+    // E11 层2 + N39:与 provider_from_command 共用 command_provider_wire 单一映射(含 copilot);
+    // 未知命令 → ""(不绑),不再静默当 codex。
+    command_provider_wire(command).unwrap_or("")
 }
 
 fn family_a_identity(
@@ -290,3 +298,34 @@ fn tmux_pane_current_command(workspace: &Path, pane: &str) -> Result<String, Lea
 // NOTE: `derive_leader_session_uuid`(`leader_binding.py:146`)已由
 // `model::ids::LeaderSessionUuid::derive` 字节对齐实现(含 NUL 拒绝 + golden 测试)——
 // 此 lane REUSE 之,不重声明。
+
+#[cfg(test)]
+mod e11_provider_bind_tests {
+    #![allow(clippy::unwrap_used)]
+    use super::*;
+
+    // E11 层2:copilot leader 命令必须绑成 Provider::Copilot(此前缺臂 → _ => Codex 误绑)。
+    #[test]
+    fn copilot_command_binds_copilot_not_codex() {
+        assert_eq!(provider_from_command("copilot --banner -C /ws"), Some(Provider::Copilot));
+        assert_eq!(provider_from_command("/opt/homebrew/bin/copilot"), Some(Provider::Copilot));
+        assert_eq!(owner_bind_provider_wire("copilot --banner"), "copilot");
+    }
+
+    #[test]
+    fn known_commands_map_via_single_source() {
+        assert_eq!(provider_from_command("claude"), Some(Provider::Claude));
+        assert_eq!(provider_from_command("codex"), Some(Provider::Codex));
+        assert_eq!(provider_from_command("fake"), Some(Provider::Fake));
+        assert_eq!(owner_bind_provider_wire("claude"), "claude");
+        assert_eq!(owner_bind_provider_wire("codex"), "codex");
+    }
+
+    // E11 层2:未知命令不再静默默认 codex —— provider_from_command → None,wire → ""。
+    #[test]
+    fn unknown_command_is_none_not_silent_codex() {
+        assert_eq!(provider_from_command("node /some/thing.js"), None);
+        assert_eq!(provider_from_command("totally-unknown"), None);
+        assert_eq!(owner_bind_provider_wire("totally-unknown"), "");
+    }
+}

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

@@ -14,8 +14,8 @@ use super::helpers::{
 };
 use super::owner_bind::leader_identity_context;
 use super::{
-    LeaderError, LeaderLaunchOutcome, LeaderLaunchSocket, LeaderLaunchStatus, LeaderStartMode,
-    LeaderStartPlan,
+    LeaderError, LeaderIdentity, LeaderLaunchOutcome, LeaderLaunchSocket, LeaderLaunchStatus,
+    LeaderStartMode, LeaderStartPlan,
 };
 
 // ── leader::start — leader_start_plan / start_leader / session 名 ──
@@ -72,27 +72,7 @@ pub fn leader_start_plan(
     } else {
         LeaderStartMode::NewTmuxSession
     };
-    let mut leader_env = BTreeMap::new();
-    leader_env.insert(
-        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
-        provider_wire(provider).to_string(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_LEADER_SESSION_UUID".to_string(),
-        identity.leader_session_uuid.as_str().to_string(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
-        identity.machine_fingerprint.clone(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_WORKSPACE".to_string(),
-        identity.workspace_abspath.to_string_lossy().into_owned(),
-    );
-    leader_env.insert(
-        "TEAM_AGENT_TEAM_ID".to_string(),
-        identity.team_id.as_str().to_string(),
-    );
+    let leader_env = leader_env_for_identity(provider, &identity);
     let argv = start_argv(
         mode,
         provider,
@@ -119,6 +99,37 @@ pub fn leader_start_plan(
     })
 }
 
+pub(crate) fn leader_env_for_identity(
+    provider: Provider,
+    identity: &LeaderIdentity,
+) -> BTreeMap<String, String> {
+    let mut leader_env = BTreeMap::new();
+    leader_env.insert(
+        "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+        provider_wire(provider).to_string(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_LEADER_SESSION_UUID".to_string(),
+        identity.leader_session_uuid.as_str().to_string(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_MACHINE_FINGERPRINT".to_string(),
+        identity.machine_fingerprint.clone(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_WORKSPACE".to_string(),
+        identity.workspace_abspath.to_string_lossy().into_owned(),
+    );
+    leader_env.insert(
+        "TEAM_AGENT_TEAM_ID".to_string(),
+        identity.team_id.as_str().to_string(),
+    );
+    if provider == Provider::Copilot {
+        leader_env.insert("COPILOT_DISABLE_TERMINAL_TITLE".to_string(), "1".to_string());
+    }
+    leader_env
+}
+
 /// `start_leader`(card §46;`__init__.py:60`)。计算并执行 leader 启动计划(spawn + 信号处理)。
 /// 进程退出后 `Err`/退出码经 caller 处理(此处返 `Result` 替代 Python 的 `SystemExit`)。
 pub fn start_leader(

package/crates/team-agent/src/leader/tests/identity.rs

@@ -90,6 +90,28 @@ use super::*;
         }
     }
 
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_leader_env_disables_terminal_title_only_for_copilot() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_lsp_copilot_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let identity = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
+
+        let copilot = leader_env_for_identity(Provider::Copilot, &identity);
+        assert_eq!(
+            copilot.get("COPILOT_DISABLE_TERMINAL_TITLE").map(String::as_str),
+            Some("1")
+        );
+
+        for provider in [Provider::Codex, Provider::ClaudeCode] {
+            let leader_env = leader_env_for_identity(provider, &identity);
+            assert!(
+                !leader_env.contains_key("COPILOT_DISABLE_TERMINAL_TITLE"),
+                "{provider:?} leader env must not include copilot title override"
+            );
+        }
+    }
+
     // ═══════════════ P2 FIX-LOOP RED (复绿即对抗 cross-model findings) ═══════════════
     // Lock CORRECT Python v0.2.11 leader-identity behavior the contracts missed.
     // Golden re-probed via /tmp/probe_p2_leader.py vs team-agent-public @ 439bef8

package/crates/team-agent/src/leader/tests/wake_start_owner.rs

@@ -134,6 +134,19 @@ use super::*;
         assert!(got.as_str().starts_with("team-agent-leader-claude_code-proj-"), "got {}", got.as_str());
     }
 
+    #[test]
+    fn leader_session_name_uses_copilot_provider_string() {
+        let base = std::env::temp_dir().join(format!("ta_rs_lsn_copilot_{}", std::process::id()));
+        let dir = base.join("proj");
+        std::fs::create_dir_all(&dir).unwrap();
+        let got = leader_session_name(Provider::Copilot, &dir);
+        assert!(
+            got.as_str().starts_with("team-agent-leader-copilot-proj-"),
+            "got {}",
+            got.as_str()
+        );
+    }
+
     // =====================================================================
     // 6. Family A 正源 owner 绑定 — bind_owner_from_caller_pane(unimplemented → RED)
     // =====================================================================