@team-agent/installer 0.3.7 → 0.3.8

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/lifecycle/launch.rs

@@ -768,28 +768,165 @@ fn env_nonempty(key: &str) -> bool {
 ///   action : `unset TEAM_AGENT_LEADER_PANE_ID, or set it to a live tmux pane id`
 ///   log    : `TEAM_AGENT_LEADER_PANE_ID=%<id>`
 /// env 未设(或空)→ Ok(())。
-/// env 设了但 transport.liveness(pane) 报 Dead → Err(RequirementUnmet)。
-/// liveness 返 Unknown 不挡(被动路径降级):本主动路径只对【显式 Dead】fail-fast,
+/// env 设了但 pane 可判定为 Dead/Absent → Err(RequirementUnmet)。
+/// 真实 tmux 后端跨所有现存 tmux socket server 探测:TEAM_AGENT_LEADER_PANE_ID 是用户
+/// override 指针,不归属当前 team socket。
+/// probe 返 Unknown 不挡(被动路径降级):本主动路径只对【显式 Dead/Absent】fail-fast,
 /// MUST-17 不过度设计 / unset 走 pass-through(b7_unset_leader_pane_env_passes_through 守)。
 pub(crate) fn validate_active_leader_pane_env(
     transport: &dyn Transport,
+) -> Result<(), LifecycleError> {
+    validate_active_leader_pane_env_with_workspaces(transport, &[])
+}
+
+pub(crate) fn validate_active_leader_pane_env_with_workspace(
+    transport: &dyn Transport,
+    workspace: Option<&Path>,
+) -> Result<(), LifecycleError> {
+    let workspaces = workspace.into_iter().collect::<Vec<_>>();
+    validate_active_leader_pane_env_with_workspaces(transport, &workspaces)
+}
+
+pub(crate) fn validate_active_leader_pane_env_with_workspaces(
+    transport: &dyn Transport,
+    workspaces: &[&Path],
 ) -> Result<(), LifecycleError> {
     let pane_id_raw = match std::env::var("TEAM_AGENT_LEADER_PANE_ID") {
         Ok(v) if !v.is_empty() => v,
         _ => return Ok(()),
     };
-    let probe = transport.liveness(&crate::transport::PaneId::new(&pane_id_raw));
-    let dead = matches!(probe, Ok(crate::transport::PaneLiveness::Dead));
-    if !dead {
+    let pane = crate::transport::PaneId::new(&pane_id_raw);
+    if !is_tmux_pane_id_format(&pane) {
+        write_invalid_leader_pane_env_warning(workspaces, &pane_id_raw);
         return Ok(());
     }
+    let failure = match leader_pane_env_state_for_validation(transport, &pane) {
+        LeaderPaneEnvState::Dead => Some("dead"),
+        LeaderPaneEnvState::Absent => Some("absent"),
+        LeaderPaneEnvState::Live | LeaderPaneEnvState::Unknown => None,
+    };
+    let Some(reason) = failure else {
+        return Ok(());
+    };
     Err(LifecycleError::RequirementUnmet(format!(
-        "TEAM_AGENT_LEADER_PANE_ID points at a dead/absent pane: {pane_id_raw}\n\
+        "TEAM_AGENT_LEADER_PANE_ID points at a {reason} pane: {pane_id_raw}\n\
          action: unset TEAM_AGENT_LEADER_PANE_ID, or set it to a live tmux pane id\n\
          log: TEAM_AGENT_LEADER_PANE_ID={pane_id_raw}"
     )))
 }
 
+fn write_invalid_leader_pane_env_warning(workspaces: &[&Path], pane_id_raw: &str) {
+    let message = "invalid pane id format, skipping validation";
+    let mut wrote = false;
+    let mut errors = Vec::new();
+    let mut seen = BTreeSet::new();
+    for workspace in workspaces {
+        let key = workspace.to_string_lossy().to_string();
+        if !seen.insert(key.clone()) {
+            continue;
+        }
+        match crate::event_log::EventLog::new(workspace).write(
+            "leader_pane_env.validation_warning",
+            serde_json::json!({
+                "env": "TEAM_AGENT_LEADER_PANE_ID",
+                "value": pane_id_raw,
+                "warning": message,
+            }),
+        ) {
+            Ok(_) => wrote = true,
+            Err(err) => errors.push(format!("{key}: {err}")),
+        }
+    }
+    if !wrote {
+        eprintln!("TEAM_AGENT_LEADER_PANE_ID={pane_id_raw}: {message}");
+        if !errors.is_empty() {
+            eprintln!(
+                "TEAM_AGENT_LEADER_PANE_ID warning event write failed: {}",
+                errors.join("; ")
+            );
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum LeaderPaneEnvState {
+    Live,
+    Dead,
+    Absent,
+    Unknown,
+}
+
+fn leader_pane_env_state_for_validation(
+    transport: &dyn Transport,
+    pane: &crate::transport::PaneId,
+) -> LeaderPaneEnvState {
+    if !is_tmux_pane_id_format(pane) {
+        return LeaderPaneEnvState::Unknown;
+    }
+    if transport.probes_real_tmux_socket_roots() {
+        return active_leader_pane_state_across_tmux_sockets(pane);
+    }
+    active_leader_pane_state(transport, pane)
+}
+
+fn is_tmux_pane_id_format(pane: &crate::transport::PaneId) -> bool {
+    let pane = pane.as_str();
+    pane.len() > 1 && pane.starts_with('%') && pane[1..].chars().all(|ch| ch.is_ascii_digit())
+}
+
+fn active_leader_pane_state_across_tmux_sockets(
+    pane: &crate::transport::PaneId,
+) -> LeaderPaneEnvState {
+    let endpoints = crate::tmux_backend::tmux_socket_endpoints();
+    let transports = endpoints
+        .iter()
+        .map(|endpoint| crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint))
+        .collect::<Vec<_>>();
+    active_leader_pane_state_across_transports(
+        transports.iter().map(|transport| transport as &dyn Transport),
+        pane,
+    )
+}
+
+pub(crate) fn active_leader_pane_state_across_transports<'a>(
+    transports: impl IntoIterator<Item = &'a dyn Transport>,
+    pane: &crate::transport::PaneId,
+) -> LeaderPaneEnvState {
+    let mut found_absent = false;
+    let mut found_dead = false;
+    for transport in transports {
+        match active_leader_pane_state(transport, pane) {
+            LeaderPaneEnvState::Live => return LeaderPaneEnvState::Live,
+            LeaderPaneEnvState::Dead => found_dead = true,
+            LeaderPaneEnvState::Absent => found_absent = true,
+            LeaderPaneEnvState::Unknown => {}
+        }
+    }
+    if found_dead {
+        LeaderPaneEnvState::Dead
+    } else if found_absent {
+        LeaderPaneEnvState::Absent
+    } else {
+        LeaderPaneEnvState::Unknown
+    }
+}
+
+fn active_leader_pane_state(
+    transport: &dyn Transport,
+    pane: &crate::transport::PaneId,
+) -> LeaderPaneEnvState {
+    match transport.has_pane(pane) {
+        Ok(Some(true)) => return LeaderPaneEnvState::Live,
+        Ok(Some(false)) => return LeaderPaneEnvState::Absent,
+        Ok(None) | Err(_) => {}
+    }
+    match transport.liveness(pane) {
+        Ok(crate::transport::PaneLiveness::Live) => LeaderPaneEnvState::Live,
+        Ok(crate::transport::PaneLiveness::Dead) => LeaderPaneEnvState::Dead,
+        Ok(crate::transport::PaneLiveness::Unknown) | Err(_) => LeaderPaneEnvState::Unknown,
+    }
+}
+
 fn seed_unbound_launched_owner(launched: &mut serde_json::Value, launched_key: &str) {
     let Some(owner) = unbound_launched_owner(launched, launched_key) else {
         return;
@@ -1884,7 +2021,9 @@ pub fn quick_start_with_transport_in_workspace(
     // owner_bind / lease / display 任一消费点。被动路径(display/seed 等)各自走
     // 降级+event,不在这里挡。错误三行式:error(含 pane id 字面)/action(unset
     // 或修 env)/log(env var 名)。
-    validate_active_leader_pane_env(transport)?;
+    let team_workspace = team_workspace(agents_dir);
+    let warning_workspaces = [workspace, team_workspace.as_path()];
+    validate_active_leader_pane_env_with_workspaces(transport, &warning_workspaces)?;
     if !agents_dir.exists() {
         return Err(LifecycleError::Compile(format!(
             "agents dir not found: {}",
@@ -1920,18 +2059,40 @@ pub fn quick_start_with_transport_in_workspace(
                 .as_deref()
                 .is_none_or(|team| runtime_state_has_quick_start_team(&state, team))
             {
+                let session_name = state
+                    .get("session_name")
+                    .and_then(serde_json::Value::as_str)
+                    .filter(|s| !s.is_empty())
+                    .map(SessionName::new);
+                let attach_commands = session_name
+                    .as_ref()
+                    .map(|session| {
+                        let windows = quick_start_attach_window_names(&state);
+                        crate::tmux_backend::attach_commands_for_windows(
+                            &workspace,
+                            session,
+                            windows.iter().map(String::as_str),
+                        )
+                    })
+                    .unwrap_or_default();
+                let mut next_actions = vec![
+                    "run restart to resume the existing team or pass --fresh to replace it"
+                        .to_string(),
+                ];
+                if session_name.is_some() {
+                    if crate::tmux_backend::socket_probe_missing_for_workspace(&workspace) {
+                        next_actions.push(crate::tmux_backend::socket_missing_hint_for_workspace(
+                            &workspace,
+                        ));
+                    }
+                    next_actions.extend(attach_commands.iter().cloned());
+                }
                 return Ok(QuickStartReport::ExistingRuntime {
                     team: requested_team.clone(),
-                    session_name: state
-                        .get("session_name")
-                        .and_then(serde_json::Value::as_str)
-                        .filter(|s| !s.is_empty())
-                        .map(SessionName::new),
+                    session_name,
                     state_path: Some(state_path),
-                    next_actions: vec![
-                        "run restart to resume the existing team or pass --fresh to replace it"
-                            .to_string(),
-                    ],
+                    next_actions,
+                    attach_commands,
                 });
             }
         }
@@ -2008,6 +2169,9 @@ pub fn quick_start_with_transport_in_workspace(
     let mut next_actions = vec![format!(
         "team compiled; real spawn is behind the transport/provider boundary; {coordinator_action}"
     )];
+    if crate::tmux_backend::socket_probe_missing_for_workspace(&workspace) {
+        next_actions.push(crate::tmux_backend::socket_missing_hint_for_workspace(&workspace));
+    }
     next_actions.extend(attach_commands.iter().cloned());
     let display_backend = state
         .get("display_backend")
@@ -2024,6 +2188,29 @@ pub fn quick_start_with_transport_in_workspace(
     })
 }
 
+fn quick_start_attach_window_names(state: &serde_json::Value) -> Vec<String> {
+    let mut windows = state
+        .get("agents")
+        .and_then(serde_json::Value::as_object)
+        .map(|agents| {
+            agents
+                .iter()
+                .filter_map(|(agent_id, agent)| {
+                    agent
+                        .get("window")
+                        .and_then(serde_json::Value::as_str)
+                        .filter(|window| !window.is_empty())
+                        .map(str::to_string)
+                        .or_else(|| Some(agent_id.clone()))
+                })
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    windows.sort();
+    windows.dedup();
+    windows
+}
+
 /// BUG-7 helper: derive a [`QuickStartReadiness`] verdict from the just-written
 /// runtime state. Reads `agents[*].status`; any non-`running` agent flips the
 /// verdict to `Degraded { unhealthy_agents }` (sorted, deduped); otherwise

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -83,22 +83,28 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             workspace.join("team.spec.yaml").display()
         )));
     }
-    let run_candidate = crate::model::paths::canonical_run_workspace(workspace)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    if !workspace.join("team.spec.yaml").exists()
-        && !crate::state::persist::runtime_state_path(&run_candidate).exists()
-    {
-        return Err(LifecycleError::TeamSelect(format!(
-            "missing spec for restart: {}",
-            workspace.join("team.spec.yaml").display()
-        )));
-    }
+    // RED-2(P0)修:存在性门下移到 resolve 之后,用 selected.spec_path(读序 B:runtime 优先、
+    // legacy 用户目录回落)判,而非 resolve 前自拼 workspace/team.spec.yaml(spec-demote 后 spec
+    // 不在用户目录 → 旧门误报缺)。resolve_active_team(RequireSpec) 内部已按 spec_path 校验存在性,
+    // 故直接交给它;失败信息(含真实 expected runtime spec 路径)即正确的 N38。
     let selected = crate::state::selector::resolve_active_team(
         workspace,
         team,
         crate::state::selector::SelectorMode::RequireSpec,
     )
     .map_err(|e| LifecycleError::TeamSelect(e.to_string()))?;
+    // 显式存在性门(下移后):selected.spec_path 经读序 B 已定位 runtime/legacy spec。
+    // 缺(空目录 restart 等)→ 报真实期望路径,不误导去用户目录找。
+    if !selected.spec_path.as_ref().is_some_and(|p| p.exists()) {
+        let expected = selected
+            .spec_path
+            .clone()
+            .unwrap_or_else(|| crate::model::paths::runtime_spec_path(&selected.run_workspace, &selected.team_key));
+        return Err(LifecycleError::TeamSelect(format!(
+            "missing spec for restart: {} (run `team-agent quick-start <teamdir>` first, or restore the team's role docs)",
+            expected.display()
+        )));
+    }
     let mut state = selected.state;
     crate::lifecycle::launch::ensure_owner_allowed_for_state(&state, None)?;
     // E5 task#3 / RC-A6a + E4(leader 裁定:每次 restart 都从角色定义重建 runtime spec,覆盖):