@team-agent/installer 0.3.7 → 0.3.9

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.7"
+version = "0.3.9"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.7"
+version = "0.3.9"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -133,13 +133,33 @@ pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
         }
         Ok(result)
     } else {
-        Ok(CmdResult::human(
-            value
-                .get("summary")
-                .and_then(Value::as_str)
-                .unwrap_or("quick-start complete"),
-        ))
+        // E13:happy 人类路径必须带 attach_commands(json 路径 cli/mod.rs:1775 已有)。
+        Ok(CmdResult::human(&quickstart_human(&value)))
+    }
+}
+
+/// E13:quick-start "team 起了" 人类输出 = summary + attach 块。所有成功出口共用(别每分支手拷)。
+/// attach_commands 缺/空 → 只 summary(向后兼容)。
+fn quickstart_human(value: &Value) -> String {
+    let summary = value
+        .get("summary")
+        .and_then(Value::as_str)
+        .unwrap_or("quick-start complete");
+    let attach: Vec<&str> = value
+        .get("attach_commands")
+        .and_then(Value::as_array)
+        .map(|items| items.iter().filter_map(Value::as_str).collect())
+        .unwrap_or_default();
+    if attach.is_empty() {
+        return summary.to_string();
+    }
+    let mut out = String::from(summary);
+    out.push_str("\n\nattach:");
+    for cmd in attach {
+        out.push_str("\n  ");
+        out.push_str(cmd);
     }
+    out
 }
 
 /// `cmd_compile`(`commands.py:42`)。
@@ -1522,9 +1542,34 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
 mod tests {
     #![allow(clippy::unwrap_used)]
 
-    use super::agent_pane_id;
+    use super::{agent_pane_id, quickstart_human};
     use serde_json::json;
 
+    // E13:happy 人类输出必须带 attach 块(此前 else 分支只打 summary 丢 attach_commands)。
+    #[test]
+    fn e13_quickstart_human_includes_attach_commands() {
+        let value = json!({
+            "summary": "team started",
+            "attach_commands": [
+                "tmux -S /tmp/ta-x attach -t team-y:w1",
+                "tmux -S /tmp/ta-x attach -t team-y:w2",
+            ],
+        });
+        let out = quickstart_human(&value);
+        assert!(out.contains("team started"), "must keep summary; got {out}");
+        assert!(out.contains("attach:"), "must render attach block; got {out}");
+        assert!(out.contains("team-y:w1") && out.contains("team-y:w2"), "must list each attach cmd; got {out}");
+    }
+
+    #[test]
+    fn e13_quickstart_human_summary_only_when_no_attach() {
+        let value = json!({"summary": "quick-start complete"});
+        assert_eq!(quickstart_human(&value), "quick-start complete");
+        // 空数组也只 summary。
+        let value2 = json!({"summary": "s", "attach_commands": []});
+        assert_eq!(quickstart_human(&value2), "s");
+    }
+
     #[test]
     fn agent_pane_id_resolves_session_window_even_with_recorded_pane_id() {
         let state = json!({

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

@@ -23,7 +23,7 @@ pub fn emit(output: &CmdOutput, as_json: bool) -> Option<String> {
     }
 }
 
-/// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude passthrough 早返回 →
+/// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude/copilot passthrough 早返回 →
 /// 解析 argv 到 subcommand → 调对应 handler → 异常落盘 + 信封 + `ExitCode::Error` →
 /// `consume_leader_inbox_summary` → `emit` → `result.ok is False ? Error : Ok`。
 /// **行为入口**:契约可端到端跑 argv→(stdout, exit code)。
@@ -31,7 +31,7 @@ pub fn run(argv: &[String], cwd: &Path) -> ExitCode {
     let Some(command) = argv.first().map(String::as_str) else {
         return emit_missing_subcommand_usage();
     };
-    if command == "codex" || command == "claude" {
+    if command == "codex" || command == "claude" || command == "copilot" {
         return cmd_leader_passthrough(command, &argv[1..], cwd)
             .map(emit_result)
             .unwrap_or(ExitCode::Error);
@@ -108,6 +108,7 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "watch" => cmd_watch(&watch_args(args, cwd)).map(emit_result),
         "sessions" => cmd_sessions(&sessions_args(args, cwd)).map(emit_result),
         "validate" => cmd_validate(&validate_args(args, cwd)).map(emit_result),
+        "install-skill" => cmd_install_skill(&install_skill_args(args)?).map(emit_result),
         "profile" => cmd_profile(&profile_args(args, cwd)?).map(emit_result),
         "validate-result" if has_arg(args, "--result") => {
             eprintln!("team-agent: error: unrecognized arguments: --result");
@@ -160,6 +161,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "watch",
     "sessions",
     "validate",
+    "install-skill",
     "profile",
     "validate-result",
     "collect",
@@ -191,7 +193,7 @@ fn is_known_subcommand(command: &str) -> bool {
 fn command_help(command: Option<&str>) -> String {
     match command {
         None => {
-            let mut commands = vec!["codex", "claude"];
+            let mut commands = vec!["codex", "claude", "copilot"];
             commands.extend_from_slice(DISPATCH_COMMANDS);
             commands.extend_from_slice(SPEC_ONLY_HELP_COMMANDS);
             format!(
@@ -230,6 +232,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("watch") => "usage: team-agent watch [--workspace WORKSPACE] [--team TEAM]".to_string(),
         Some("sessions") => "usage: team-agent sessions [--workspace WORKSPACE] [--json]".to_string(),
         Some("validate") => "usage: team-agent validate [SPEC] [--json]".to_string(),
+        Some("install-skill") => "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]".to_string(),
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]".to_string(),
         Some("validate-result") => "usage: team-agent validate-result [ENVELOPE] [--file FILE|--result JSON] [--json]".to_string(),
         Some("collect") => "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]".to_string(),
@@ -258,7 +261,7 @@ fn emit_unknown_subcommand_usage(command: &str) -> ExitCode {
 
 /// 在已知子命令里找与 `input` 最接近的一个(Levenshtein ≤ 阈值)。无足够接近者 → None。
 fn nearest_subcommand(input: &str) -> Option<&'static str> {
-    let mut candidates: Vec<&'static str> = vec!["codex", "claude"];
+    let mut candidates: Vec<&'static str> = vec!["codex", "claude", "copilot"];
     candidates.extend_from_slice(DISPATCH_COMMANDS);
     candidates.extend_from_slice(SPEC_ONLY_HELP_COMMANDS);
     // 阈值随长度放宽,但短词收紧,避免 'x' 误配任何东西。
@@ -298,6 +301,115 @@ fn emit_usage_error(message: &str) {
 }
 
 /// `cmd_validate` delegates to runtime validate_file.
+/// `install-skill` 参数(RED-1 根治:把 skill 安装单源收敛到二进制,install.mjs 调它)。
+struct InstallSkillArgs {
+    target: crate::packaging::SkillTarget,
+    dest: Option<PathBuf>,
+    dry_run: bool,
+    /// `--uninstall`:删 target 的 skill 目标目录(单源,走同一 SkillTarget 表),不需 --source。
+    uninstall: bool,
+    source: Option<PathBuf>,
+    json: bool,
+}
+
+fn install_skill_args(args: &[String]) -> Result<InstallSkillArgs, CliError> {
+    let parsed = parse_args(args);
+    // `--target` 复用 parse_args.targets(codex|claude|copilot|all,默认 all)。
+    let target = match parsed.targets.as_deref() {
+        None | Some("all") => crate::packaging::SkillTarget::All,
+        Some("codex") => crate::packaging::SkillTarget::Codex,
+        Some("claude") => crate::packaging::SkillTarget::Claude,
+        Some("copilot") => crate::packaging::SkillTarget::Copilot,
+        Some(other) => {
+            return Err(CliError::Usage(format!(
+                "invalid --target: {other} (choose from codex, claude, copilot, all)"
+            )))
+        }
+    };
+    let uninstall = args.iter().any(|a| a == "--uninstall");
+    // `--source <dir>` 安装时必需(npm 包的 skills/team-agent;运行期无 CARGO_MANIFEST_DIR);
+    // 卸载不需要。
+    let source = flag_value(args, "--source").map(PathBuf::from);
+    if !uninstall && source.is_none() {
+        return Err(CliError::Usage("missing --source <skill dir>".to_string()));
+    }
+    let dest = flag_value(args, "--dest").map(PathBuf::from);
+    let dry_run = args.iter().any(|a| a == "--dry-run");
+    Ok(InstallSkillArgs {
+        target,
+        dest,
+        dry_run,
+        uninstall,
+        source,
+        json: parsed.json,
+    })
+}
+
+/// 取 `--flag <value>` 的值(用于 install-skill 的 --source/--dest,parse_args 不覆盖的旗标)。
+fn flag_value(args: &[String], flag: &str) -> Option<String> {
+    args.iter().position(|a| a == flag).and_then(|i| args.get(i + 1).cloned())
+}
+
+/// `team-agent install-skill`(RED-1 单源):repo `skills/team-agent` → `~/.codex|.claude|.copilot`。
+/// install.mjs 删 JS 拷贝逻辑、改调本命令(`--target all --source <pkg>/skills/team-agent`)。
+fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
+    // 卸载分支(单源:走同一 SkillTarget 表的 dest_dir;all → SINGLE_TARGETS 全集)。
+    if args.uninstall {
+        let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("."));
+        let targets: Vec<crate::packaging::SkillTarget> = match args.target {
+            crate::packaging::SkillTarget::All => {
+                crate::packaging::SkillTarget::SINGLE_TARGETS.to_vec()
+            }
+            t => vec![t],
+        };
+        let mut removed: Vec<serde_json::Value> = Vec::new();
+        for t in targets {
+            if let Some(dest) = t.dest_dir(&home) {
+                let existed = dest.0.exists();
+                if existed && !args.dry_run {
+                    std::fs::remove_dir_all(&dest.0).map_err(|e| CliError::Runtime(e.to_string()))?;
+                }
+                removed.push(serde_json::json!({
+                    "target": t,
+                    "dest": dest.0.to_string_lossy(),
+                    "removed": existed,
+                    "dry_run": args.dry_run,
+                }));
+            }
+        }
+        return Ok(CmdResult::from_json(
+            serde_json::json!({"ok": true, "uninstalled": removed}),
+            args.json,
+        ));
+    }
+    let source = args
+        .source
+        .clone()
+        .ok_or_else(|| CliError::Usage("missing --source <skill dir>".to_string()))?;
+    let outcomes = crate::packaging::install::install_skill(&crate::packaging::SkillInstallOptions {
+        target: args.target,
+        dest: args.dest.clone(),
+        dry_run: args.dry_run,
+        source,
+    })
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let installed: Vec<serde_json::Value> = outcomes
+        .iter()
+        .map(|o| {
+            serde_json::json!({
+                "target": o.target,
+                "dest": o.dest.0.to_string_lossy(),
+                "dry_run": o.dry_run,
+                "removed_stale": o.removed_stale.len(),
+            })
+        })
+        .collect();
+    Ok(CmdResult::from_json(
+        serde_json::json!({"ok": true, "installed": installed}),
+        args.json,
+    ))
+}
+
 pub fn cmd_validate(args: &ValidateArgs) -> Result<CmdResult, CliError> {
     let spec = resolve_path(&args.spec);
     let value = if spec.is_dir() {
@@ -1306,6 +1418,22 @@ mod tests {
                 "top-level --help is missing spec-only help command `{command}`"
             );
         }
+        assert!(
+            top_help.contains("copilot"),
+            "top-level leader passthrough help must list copilot"
+        );
+    }
+
+    #[test]
+    fn copilot_is_listed_as_leader_passthrough_candidate() {
+        assert!(command_help(None).contains("copilot"));
+        assert_eq!(nearest_subcommand("copliot"), Some("copilot"));
+    }
+
+    #[test]
+    fn copilot_help_dispatches_as_leader_passthrough() {
+        let cwd = tmp_workspace();
+        assert_eq!(run(&cli_argv(&["copilot", "--help"]), &cwd), ExitCode::Ok);
     }
 
     #[test]

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

@@ -1,4 +1,4 @@
-//! cli · leader — `codex`/`claude` passthrough(`cmd_leader_passthrough` + `_provider_args` /
+//! cli · leader — `codex`/`claude`/`copilot` passthrough(`cmd_leader_passthrough` + `_provider_args` /
 //! `_leader_launcher_args`)+ leader fallback inbox 摘要(`consume_leader_inbox_summary` 及
 //! `_leader_inbox_entries` / `_leader_inbox_summary` / `_leader_inbox_entry_title`)。
 
@@ -68,9 +68,9 @@ fn without_leader_json(values: &[String]) -> Vec<String> {
     out
 }
 
-/// `codex`/`claude` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
+/// `codex`/`claude`/`copilot` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
 /// **不**进 subparser。`-h`/`--help` 打 usage 直接返回 [`CmdResult::none`]。否则解析 attach
-/// 旗标 + `lifecycle_port::start_leader`。`command` ∈ {codex, claude}。
+/// 旗标 + `lifecycle_port::start_leader`。`command` ∈ {codex, claude, copilot}。
 pub fn cmd_leader_passthrough(
     command: &str,
     provider_args: &[String],
@@ -82,15 +82,19 @@ pub fn cmd_leader_passthrough(
     let as_json = leader_launcher_json(provider_args);
     let launcher_args = without_leader_json(provider_args);
     let attach = leader_launcher_args(&launcher_args)?;
-    let provider = if command == "codex" {
-        crate::model::enums::Provider::Codex
-    } else {
-        crate::model::enums::Provider::ClaudeCode
-    };
+    let provider = leader_passthrough_provider(command);
     let value = lifecycle_port::start_leader(provider, &attach.provider_args, cwd, &attach)?;
     Ok(CmdResult::from_json(value, as_json))
 }
 
+pub(crate) fn leader_passthrough_provider(command: &str) -> crate::model::enums::Provider {
+    match command {
+        "codex" => crate::model::enums::Provider::Codex,
+        "copilot" => crate::model::enums::Provider::Copilot,
+        _ => crate::model::enums::Provider::ClaudeCode,
+    }
+}
+
 // =============================================================================
 // leader fallback inbox 摘要(helpers.py `consume_leader_inbox_summary`)
 // =============================================================================

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

@@ -168,6 +168,7 @@ pub mod lifecycle_port {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let state = shutdown_state_for_team(&run_ws, team)?;
+        let state_for_kill = state.clone();
         let transport = if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
             crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
         } else {
@@ -176,17 +177,33 @@ pub mod lifecycle_port {
         let result =
             shutdown_with_transport_and_state(workspace, keep_logs, team, &transport, Some(state));
         if team.is_none() {
-            // B5/F1: the leader terminal (`team-agent claude`) lives on this same
-            // workspace socket by design (leader/start.rs); a bare shutdown must not
-            // `kill-server` it away. Spare `team-agent-leader-*` sessions and clear the
-            // remaining non-leader sessions individually; only an empty-of-leader socket
-            // gets the whole-server teardown (the original leak-cleanup intent).
+            // E12 (P0): the leader terminal lives on this socket by design. A bare shutdown must
+            // NOT `kill-server` it away. spare = state-anchor sessions ∪ `team-agent-leader-*`
+            // prefix sessions (union; cr E12 ①). kill_server only when the socket is exclusively
+            // ours (no spare + no foreign session); shared socket → kill our sessions individually
+            // (cr E12 ②). All spare derivation comes from ONE snapshot (list_targets + the state
+            // already loaded) — no independent ps/tmux re-derivation (N39).
             let transport_dyn: &dyn crate::transport::Transport = &transport;
+            let pane_targets = transport_dyn.list_targets().unwrap_or_default();
             let sessions = socket_session_names(transport_dyn);
-            match sessions_to_kill_sparing_leader(&sessions) {
-                None => transport.kill_server(),
-                Some(non_leader_sessions) => {
-                    for session in &non_leader_sessions {
+            let event_log = crate::event_log::EventLog::new(&run_ws);
+            let anchor_sessions =
+                anchor_sessions_from_state(&state_for_kill, &pane_targets, &event_log);
+            let decision = sessions_to_kill(&sessions, &anchor_sessions);
+            match decision {
+                KillDecision::KillServerExclusive => transport.kill_server(),
+                KillDecision::KillIndividually { to_kill, spared } => {
+                    if !spared.is_empty() || to_kill.len() != sessions.len() {
+                        // shared socket / leader spared → never whole-server teardown.
+                        let _ = event_log.write(
+                            "shutdown.kill_server_skipped_shared_socket",
+                            json!({
+                                "spared_sessions": spared.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                                "killed_sessions": to_kill.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
+                            }),
+                        );
+                    }
+                    for session in &to_kill {
                         let _ = transport_dyn.kill_session(session);
                     }
                 }
@@ -195,6 +212,29 @@ pub mod lifecycle_port {
         result
     }
 
+    /// E12 ①:从 state 锚 pane_id(leader_receiver/team_owner,top+teams)映射到其所在 session
+    /// (经同一帧 list_targets pane→session)。state 无任何锚 → 退命名判据 + spare_fallback event。
+    fn anchor_sessions_from_state(
+        state: &Value,
+        pane_targets: &[crate::transport::PaneInfo],
+        event_log: &crate::event_log::EventLog,
+    ) -> std::collections::BTreeSet<String> {
+        let anchor_pane_ids = collect_state_leader_anchor_pane_ids(state);
+        if anchor_pane_ids.is_empty() {
+            // 无锚(state 损坏/未记)→ 退纯命名前缀判据(下游 sessions_to_kill 仍 spare 前缀)。
+            let _ = event_log.write(
+                "shutdown.spare_fallback_to_naming",
+                json!({"reason": "no leader_receiver/team_owner pane anchor in state"}),
+            );
+            return std::collections::BTreeSet::new();
+        }
+        pane_targets
+            .iter()
+            .filter(|pane| anchor_pane_ids.contains(pane.pane_id.as_str()))
+            .map(|pane| pane.session.as_str().to_string())
+            .collect()
+    }
+
     fn socket_session_names(
         transport: &dyn crate::transport::Transport,
     ) -> Vec<crate::transport::SessionName> {
@@ -208,26 +248,37 @@ pub mod lifecycle_port {
             .collect()
     }
 
-    /// B5/F1 pure kill decision for the bare-shutdown socket teardown.
-    /// `None` => no `team-agent-leader-*` session on the socket → safe to kill the whole
-    /// server. `Some(rest)` => leader present → kill only the non-leader sessions.
-    pub(crate) fn sessions_to_kill_sparing_leader(
+    /// E12 下沉纯函数:bare-shutdown socket 拆除决策。
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub(crate) enum KillDecision {
+        /// socket 独享(无 spare、无外来 session)→ 可整 server 拆除。
+        KillServerExclusive,
+        /// 有 spare(leader 锚/前缀)或非独享 → 逐 session kill,绝不 kill-server。
+        KillIndividually {
+            to_kill: Vec<crate::transport::SessionName>,
+            spared: Vec<crate::transport::SessionName>,
+        },
+    }
+
+    /// E12 纯决策(单测下沉):spare = `anchor_sessions` ∪ `team-agent-leader-*` 前缀(并集,锚优先)。
+    /// 全部 session 都不 spare 且非空 → `KillServerExclusive`(独享 socket 兜底);否则逐 session
+    /// kill 非 spare 的(共享 socket / leader 在 → 绝不整 server 拆)。空 session 集 → 逐 kill(no-op)。
+    pub(crate) fn sessions_to_kill(
         sessions: &[crate::transport::SessionName],
-    ) -> Option<Vec<crate::transport::SessionName>> {
-        let leader_present = sessions
-            .iter()
-            .any(|session| session.as_str().starts_with(crate::leader::LEADER_SESSION_PREFIX));
-        leader_present.then(|| {
-            sessions
-                .iter()
-                .filter(|session| {
-                    !session
-                        .as_str()
-                        .starts_with(crate::leader::LEADER_SESSION_PREFIX)
-                })
-                .cloned()
-                .collect()
-        })
+        anchor_sessions: &std::collections::BTreeSet<String>,
+    ) -> KillDecision {
+        let is_spared = |s: &crate::transport::SessionName| {
+            s.as_str().starts_with(crate::leader::LEADER_SESSION_PREFIX)
+                || anchor_sessions.contains(s.as_str())
+        };
+        let spared: Vec<_> = sessions.iter().filter(|s| is_spared(s)).cloned().collect();
+        let to_kill: Vec<_> = sessions.iter().filter(|s| !is_spared(s)).cloned().collect();
+        // 独享 = 非空 + 无 spare(socket 上每个 session 都是要 kill 的我方 session)。
+        if spared.is_empty() && !sessions.is_empty() {
+            KillDecision::KillServerExclusive
+        } else {
+            KillDecision::KillIndividually { to_kill, spared }
+        }
     }
 
     pub fn shutdown_with_transport(
@@ -1782,6 +1833,7 @@ pub mod lifecycle_port {
                 session_name,
                 state_path,
                 next_actions,
+                attach_commands,
             } => json!({
                 "ok": false,
                 "summary": "existing runtime",
@@ -1789,20 +1841,61 @@ pub mod lifecycle_port {
                 "session_name": session_name.map(|s| s.as_str().to_string()),
                 "state_path": state_path.map(|p| p.to_string_lossy().to_string()),
                 "next_actions": next_actions,
+                "attach_commands": attach_commands,
             }),
             crate::lifecycle::QuickStartReport::PreflightBlocked {
                 summary,
                 blockers,
                 next_actions,
+                attach_commands,
             } => json!({
                 "ok": false,
                 "summary": summary,
                 "blockers": blockers,
                 "next_actions": next_actions,
+                "attach_commands": attach_commands,
             }),
         }
     }
 
+    #[cfg(test)]
+    mod quick_start_value_tests {
+        use super::*;
+
+        #[test]
+        fn existing_runtime_json_includes_attach_commands() {
+            let value = quick_start_value(crate::lifecycle::QuickStartReport::ExistingRuntime {
+                team: Some("teamA".to_string()),
+                session_name: Some(crate::transport::SessionName::new("team-teamA")),
+                state_path: Some(PathBuf::from("/tmp/state.json")),
+                next_actions: vec!["restart".to_string()],
+                attach_commands: vec![
+                    "tmux -S /tmp/tmux-501/ta-test attach -t team-teamA:worker".to_string(),
+                ],
+            });
+            assert_eq!(
+                value.pointer("/attach_commands/0").and_then(Value::as_str),
+                Some("tmux -S /tmp/tmux-501/ta-test attach -t team-teamA:worker"),
+                "B-2: ExistingRuntime JSON must preserve attach_commands instead of only next_actions; value={value}"
+            );
+        }
+
+        #[test]
+        fn preflight_blocked_json_includes_empty_attach_commands() {
+            let value = quick_start_value(crate::lifecycle::QuickStartReport::PreflightBlocked {
+                summary: "blocked".to_string(),
+                blockers: vec!["missing TEAM.md".to_string()],
+                next_actions: vec!["fix preflight blockers".to_string()],
+                attach_commands: Vec::new(),
+            });
+            assert_eq!(
+                value.get("attach_commands").and_then(Value::as_array).map(Vec::len),
+                Some(0),
+                "B-2: PreflightBlocked JSON must include attach_commands: [] for schema parity with Ready/Restart; value={value}"
+            );
+        }
+    }
+
     fn restart_value(report: crate::lifecycle::RestartReport) -> Value {
         match report {
             crate::lifecycle::RestartReport::Restarted {

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

@@ -617,5 +617,19 @@ Truncated: more fallback entries available; run team-agent inbox leader";
         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);
     }
 
+    #[test]
+    fn cmd_leader_passthrough_maps_copilot_provider() {
+        assert_eq!(leader_passthrough_provider("codex"), crate::model::enums::Provider::Codex);
+        assert_eq!(
+            leader_passthrough_provider("claude"),
+            crate::model::enums::Provider::ClaudeCode
+        );
+        assert_eq!(
+            leader_passthrough_provider("copilot"),
+            crate::model::enums::Provider::Copilot
+        );
+    }