@team-agent/installer 0.3.6 → 0.3.7

package/crates/team-agent/src/packaging/tests.rs

@@ -57,6 +57,44 @@ fn dest_dir_claude_resolves_to_dot_claude() {
     );
 }
 
+#[test]
+fn skill_target_copilot_maps_to_provider_copilot() {
+    // E9: copilot → Provider::Copilot (0.3.x 新增 provider,不归到 codex/claude).
+    assert_eq!(SkillTarget::Copilot.provider(), Some(Provider::Copilot));
+}
+
+#[test]
+fn dest_dir_copilot_resolves_to_dot_copilot() {
+    // E9 实证 (.team/artifacts/copilot-probe/):copilot skill 源 = ~/.copilot/skills,
+    // configDir 默认 ~/.copilot → ~/.copilot/skills/team-agent.
+    let home = Path::new("/home/testuser");
+    let got = SkillTarget::Copilot.dest_dir(home);
+    assert_eq!(
+        got,
+        Some(SkillDestDir(PathBuf::from(
+            "/home/testuser/.copilot/skills/team-agent"
+        )))
+    );
+}
+
+#[test]
+fn dest_dir_three_providers_distinct_locations() {
+    // E9: 三 provider 各自独立位置 (.codex / .claude / .copilot),互不踩.
+    let home = Path::new("/home/testuser");
+    let dirs: Vec<PathBuf> = SkillTarget::SINGLE_TARGETS
+        .iter()
+        .map(|t| t.dest_dir(home).expect("single target has dest").0)
+        .collect();
+    assert_eq!(
+        dirs,
+        vec![
+            PathBuf::from("/home/testuser/.codex/skills/team-agent"),
+            PathBuf::from("/home/testuser/.claude/skills/team-agent"),
+            PathBuf::from("/home/testuser/.copilot/skills/team-agent"),
+        ]
+    );
+}
+
 #[test]
 fn dest_dir_all_is_none_not_single_dir() {
     // `All` 应 fan-out 到两者 → 非单 dir → None (skeleton:116).
@@ -520,14 +558,15 @@ fn install_skill_dry_run_single_target_reports_plan_no_side_effects() {
 }
 
 #[test]
-fn install_skill_dry_run_target_all_fans_out_to_two() {
-    // commands.py:458-463 — target all → 两个 outcome (codex + claude),顺序固定.
+fn install_skill_dry_run_target_all_fans_out_to_all_providers() {
+    // E9: target all → 表驱动 fan-out 全 provider (codex + claude + copilot),顺序固定.
     let opts = skill_opts(SkillTarget::All, None, true);
     let outcomes = install_skill(&opts).expect("dry-run install-skill all");
-    assert_eq!(outcomes.len(), 2, "all → fan-out codex+claude");
-    // KEY ORDER:commands.py:460-461 codex first, claude second.
+    assert_eq!(outcomes.len(), 3, "all → fan-out codex+claude+copilot");
+    // KEY ORDER:SINGLE_TARGETS 顺序 codex, claude, copilot.
     assert_eq!(outcomes[0].target, SkillTarget::Codex);
     assert_eq!(outcomes[1].target, SkillTarget::Claude);
+    assert_eq!(outcomes[2].target, SkillTarget::Copilot);
     assert!(outcomes.iter().all(|o| o.dry_run));
 }
 
@@ -791,6 +830,43 @@ impl Drop for HomeGuard {
     }
 }
 
+// E9 — install-skill --target all (real copy) must land team-agent SKILL.md in ALL THREE
+// provider locations (~/.codex|.claude|.copilot/skills/team-agent) and the copied bytes must
+// equal the source. This is the "三 provider 位置断言(install 后文件存在且=源)" gate.
+#[test]
+#[serial_test::serial(env)]
+fn install_skill_all_real_copies_to_three_provider_locations() {
+    let _g = ENV_LOCK_PKG.lock().unwrap_or_else(|p| p.into_inner());
+    let base = std::env::temp_dir().join(format!("ta-e9-skill-all-{}", std::process::id()));
+    let home = base.join("home");
+    std::fs::create_dir_all(&home).unwrap();
+    // Build a real skill source tree with a recognizable SKILL.md.
+    let source = base.join("src-skill");
+    std::fs::create_dir_all(&source).unwrap();
+    let body = b"---\nname: team-agent\n---\nE9 source marker\n";
+    std::fs::write(source.join("SKILL.md"), body).unwrap();
+    let _h = HomeGuard::set(&home);
+
+    let opts = SkillInstallOptions {
+        target: SkillTarget::All,
+        dest: None,
+        dry_run: false,
+        source: source.clone(),
+    };
+    let outcomes = install_skill(&opts).expect("real install-skill all");
+    assert_eq!(outcomes.len(), 3, "all → codex+claude+copilot");
+
+    for sub in [".codex", ".claude", ".copilot"] {
+        let dest = home.join(sub).join("skills").join("team-agent").join("SKILL.md");
+        assert!(dest.exists(), "{sub}: SKILL.md must exist after install");
+        assert_eq!(
+            std::fs::read(&dest).unwrap(),
+            body,
+            "{sub}: installed SKILL.md bytes must equal source"
+        );
+    }
+}
+
 // P1 — update() must perform a REAL atomic replace (rename dest→.previous), not fabricate
 // a Replaced outcome whose backup file never exists (install.mjs:60-66; bug-084).
 #[test]
@@ -819,21 +895,21 @@ fn p2_update_creates_real_atomic_replace_backup() {
     );
 }
 
-// P1 — uninstall() must remove BOTH ~/.codex/skills/team-agent and ~/.claude/skills/team-agent
-// and record them (install.mjs:115-122). Current returns removed_skill_dirs empty and leaves
-// the dirs on disk.
+// P1 — uninstall() must remove ALL provider skill dirs (~/.codex|.claude|.copilot/skills/team-agent)
+// and record them (install.mjs:115-122 + E9 copilot). Table-driven over SkillTarget::SINGLE_TARGETS.
 #[test]
 #[serial_test::serial(env)]
-fn p2_uninstall_removes_both_skill_dirs() {
+fn p2_uninstall_removes_all_provider_skill_dirs() {
     let _g = ENV_LOCK_PKG.lock().unwrap_or_else(|p| p.into_inner());
     let base = std::env::temp_dir().join(format!("ta-p2-uninst-{}", std::process::id()));
     let home = base.join("home");
     let codex = home.join(".codex").join("skills").join("team-agent");
     let claude = home.join(".claude").join("skills").join("team-agent");
-    std::fs::create_dir_all(&codex).unwrap();
-    std::fs::create_dir_all(&claude).unwrap();
-    std::fs::write(codex.join("SKILL.md"), b"x").unwrap();
-    std::fs::write(claude.join("SKILL.md"), b"x").unwrap();
+    let copilot = home.join(".copilot").join("skills").join("team-agent");
+    for d in [&codex, &claude, &copilot] {
+        std::fs::create_dir_all(d).unwrap();
+        std::fs::write(d.join("SKILL.md"), b"x").unwrap();
+    }
     let _h = HomeGuard::set(&home);
 
     let opts = UninstallOptions {
@@ -844,9 +920,10 @@ fn p2_uninstall_removes_both_skill_dirs() {
     let out = uninstall(&opts).unwrap();
     assert_eq!(
         out.removed_skill_dirs.len(),
-        2,
-        "uninstall must remove BOTH ~/.codex and ~/.claude skill dirs"
+        3,
+        "uninstall must remove ~/.codex, ~/.claude AND ~/.copilot skill dirs"
     );
     assert!(!codex.exists(), "~/.codex skill dir must be removed");
     assert!(!claude.exists(), "~/.claude skill dir must be removed");
+    assert!(!copilot.exists(), "~/.copilot skill dir must be removed");
 }

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

@@ -40,24 +40,36 @@ pub enum InstallerCommand {
 pub enum SkillTarget {
     Codex,
     Claude,
+    /// GitHub Copilot CLI(0.3.x 新增 provider)。skill 落 `~/.copilot/skills/team-agent`
+    /// —— 实证:copilot bundle skill 源枚举含 `personal-copilot (~/.copilot/skills)`,
+    /// config dir = `~/.copilot`(可被 `$COPILOT_HOME` 覆盖),manifest 约定 `**/SKILL.md`
+    /// 同 claude/codex(见 `.team/artifacts/copilot-probe/`)。
+    Copilot,
     All,
 }
 
 impl SkillTarget {
+    /// `All` fan-out 的单目标全集(表驱动唯一真相源:新增 provider 只改这里,
+    /// install/uninstall/install-skill 三处共用,杜绝漏装/漏卸)。
+    pub const SINGLE_TARGETS: [SkillTarget; 3] =
+        [SkillTarget::Codex, SkillTarget::Claude, SkillTarget::Copilot];
+
     /// 单目标 → 对应 provider(`All` 无单一 provider → `None`)。与 [`Provider`] 对齐,防散字符串再生。
     pub fn provider(self) -> Option<Provider> {
         match self {
             Self::Codex => Some(Provider::Codex),
             Self::Claude => Some(Provider::ClaudeCode),
+            Self::Copilot => Some(Provider::Copilot),
             Self::All => None,
         }
     }
 
-    /// `_skill_dest_dir`:`~/.codex|.claude/skills/team-agent`(`All` 应 fan-out 到两者,非单 dir → None)。
+    /// `_skill_dest_dir`:`~/.codex|.claude|.copilot/skills/team-agent`(`All` fan-out 全集,非单 dir → None)。
     pub fn dest_dir(self, home: &Path) -> Option<SkillDestDir> {
         match self {
             Self::Codex => Some(SkillDestDir(home.join(".codex").join("skills").join("team-agent"))),
             Self::Claude => Some(SkillDestDir(home.join(".claude").join("skills").join("team-agent"))),
+            Self::Copilot => Some(SkillDestDir(home.join(".copilot").join("skills").join("team-agent"))),
             Self::All => None,
         }
     }

package/crates/team-agent/src/provider/adapter.rs

@@ -1025,6 +1025,43 @@ fn scan_session_candidates_once(
             agent_path_match,
         });
     }
+    // E6 层1·C(机会性兜底):若盘上真有 expected_session_id 命名的 transcript(claude 哪天
+    // 真采用 --session-id,或别的 provider 本就采用),直接唯一命中,省去时间窗扫描。
+    // 命不中(交互式 claude 现实:不落 <expected>.jsonl)→ 回落 B。
+    if let Some(expected) = context.expected_session_id.as_ref() {
+        if let Some(hit) = out.iter().find(|candidate| {
+            candidate
+                .captured
+                .session_id
+                .as_ref()
+                .is_some_and(|session| session.as_str() == expected.as_str())
+        }) {
+            return Ok(vec![hit.clone()]);
+        }
+    }
+    // E6 层1·B(主路径,交互式现实):cwd 匹配但盘上有多个 sibling transcript(claude 自生成,
+    // 不采用预定 UUID)→ 用 spawn 时间窗唯一选:只留 mtime >= spawned_at 的候选,打破歧义。
+    // spawned_at 缺/无法解析时不收窄(保守,维持既有行为)。
+    if context.expected_session_id.is_none() || out.len() > 1 {
+        if let Some(spawned_at) = context.spawned_at.as_deref().and_then(parse_spawned_at) {
+            let within: Vec<CapturedSessionCandidate> = out
+                .iter()
+                .filter(|candidate| {
+                    candidate
+                        .captured
+                        .rollout_path
+                        .as_ref()
+                        .and_then(|p| std::fs::metadata(p.as_path()).and_then(|m| m.modified()).ok())
+                        .is_some_and(|mtime| mtime >= spawned_at)
+                })
+                .cloned()
+                .collect();
+            // 只有当时间窗把候选收成唯一时才采用(收成 0 或仍多义则不强行,交给上层 ambiguous)。
+            if within.len() == 1 {
+                return Ok(within);
+            }
+        }
+    }
     if let Some(expected) = context.expected_session_id.as_ref() {
         out.sort_by_key(|candidate| {
             candidate
@@ -1037,6 +1074,28 @@ fn scan_session_candidates_once(
     Ok(out)
 }
 
+/// 解析 state 里的 `spawned_at`(RFC3339)为 SystemTime,用于 spawn 时间窗候选筛选。
+/// 解析失败 → None(调用方据此不收窄时间窗,保守维持既有行为)。
+fn parse_spawned_at(raw: &str) -> Option<std::time::SystemTime> {
+    chrono::DateTime::parse_from_rfc3339(raw)
+        .ok()
+        .map(|dt| std::time::SystemTime::from(dt.with_timezone(&chrono::Utc)))
+}
+
+/// E6 层1·B:把 spawn cwd 映射成 claude transcript 子目录 `~/.claude/projects/<encoded>`。
+/// claude 用 **canonical(realpath)** cwd 且把每个 `/` 替换成 `-`(实证:cwd
+/// `/private/tmp/x` → `-private-tmp-x`;macOS `/tmp`→`/private/tmp` 必须先 canonical)。
+/// canonical 失败(目录已不在)退回原始路径,仍尽力编码。dir 不存在也返回(调用方
+/// `collect_optional_candidate_files` 对不存在目录是 no-op)。
+fn claude_projects_dir_for_cwd(home: &Path, spawn_cwd: &Path) -> Option<PathBuf> {
+    let canonical = std::fs::canonicalize(spawn_cwd).unwrap_or_else(|_| spawn_cwd.to_path_buf());
+    let encoded = canonical.to_string_lossy().replace('/', "-");
+    if encoded.is_empty() {
+        return None;
+    }
+    Some(home.join(".claude").join("projects").join(encoded))
+}
+
 /// §C4 cr verdict — copilot session 真相源 sqlite 点查。
 ///
 /// 路径:`<HOME>/.copilot/session-store.db`,sessions 表(id/cwd/created_at/updated_at)
@@ -1113,6 +1172,12 @@ fn candidate_session_files(
             }
             Provider::Claude | Provider::ClaudeCode => {
                 collect_optional_candidate_files(&home.join(".claude").join("sessions"), &context.agent_id, &mut out)?;
+                // E6 层1·B:优先锚到 ~/.claude/projects/<canonical spawn_cwd 编码> 子目录
+                // (claude 把 cwd 的 '/' 编码成 '-';交互式 worker 的真实 transcript 落在此),
+                // 而非全 projects 树盲扫(交互式 claude 自生成 UUID,锚 cwd 子目录 + 时间窗才能唯一选)。
+                if let Some(dir) = claude_projects_dir_for_cwd(&home, &context.spawn_cwd) {
+                    collect_optional_candidate_files(&dir, &context.agent_id, &mut out)?;
+                }
                 collect_optional_candidate_files(&home.join(".claude").join("projects"), &context.agent_id, &mut out)?;
             }
             // §C4 cr verdict + 设计 §C: copilot session 真相源是 ~/.copilot/session-store.db
@@ -1765,3 +1830,142 @@ fn next_session_token() -> String {
         bytes[15],
     )
 }
+
+#[cfg(test)]
+mod e6_session_attribution_tests {
+    #![allow(clippy::unwrap_used)]
+    use super::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    fn tmp_root(tag: &str) -> PathBuf {
+        static CTR: AtomicU64 = AtomicU64::new(0);
+        let dir = std::env::temp_dir().join(format!(
+            "ta-e6-attr-{}-{}-{}",
+            tag,
+            std::process::id(),
+            CTR.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    fn write_transcript(dir: &Path, uuid: &str, cwd: &Path) -> PathBuf {
+        std::fs::create_dir_all(dir).unwrap();
+        let path = dir.join(format!("{uuid}.jsonl"));
+        let line = serde_json::json!({
+            "sessionId": uuid,
+            "cwd": cwd.to_string_lossy(),
+        });
+        std::fs::write(&path, format!("{line}\n")).unwrap();
+        path
+    }
+
+    #[test]
+    fn claude_projects_dir_for_cwd_encodes_slashes_to_dashes() {
+        let home = Path::new("/home/u");
+        // 用一个真实存在的 cwd 让 canonicalize 成功(否则退回原始);用 tmp。
+        let cwd = tmp_root("encode");
+        let got = claude_projects_dir_for_cwd(home, &cwd).unwrap();
+        let canon = std::fs::canonicalize(&cwd).unwrap();
+        let expected_leaf = canon.to_string_lossy().replace('/', "-");
+        assert_eq!(got, home.join(".claude").join("projects").join(expected_leaf));
+        let _ = std::fs::remove_dir_all(&cwd);
+    }
+
+    #[test]
+    fn parse_spawned_at_rfc3339_roundtrips_and_rejects_junk() {
+        assert!(parse_spawned_at("2026-06-10T21:40:00+00:00").is_some());
+        assert!(parse_spawned_at("not-a-date").is_none());
+        assert!(parse_spawned_at("").is_none());
+    }
+
+    #[test]
+    fn scan_expected_session_id_hit_returns_only_that_candidate() {
+        // C 兜底:盘上恰有 <expected>.jsonl(假设 claude 哪天真采用)→ 唯一命中,忽略 sibling。
+        let base = tmp_root("c-hit");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let proj = base.join("projects");
+        write_transcript(&proj, "11111111-1111-4111-8111-111111111111", &cwd);
+        write_transcript(&proj, "22222222-2222-4222-8222-222222222222", &cwd);
+        let ctx = CaptureSessionContext {
+            agent_id: "w1".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: Some(SessionId::new("22222222-2222-4222-8222-222222222222")),
+            provider_projects_root: Some(proj.clone()),
+        };
+        let out = scan_session_candidates_once(Provider::ClaudeCode, &ctx).unwrap();
+        assert_eq!(out.len(), 1, "expected-id hit must collapse to the single match");
+        assert_eq!(
+            out[0].captured.session_id.as_ref().unwrap().as_str(),
+            "22222222-2222-4222-8222-222222222222"
+        );
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    fn scan_spawn_time_window_disambiguates_two_siblings() {
+        // B 主路径:claude 不采用预定 UUID,盘上两个自生成 sibling 都匹配 cwd。
+        // 只有一个在 spawn 时间窗内(mtime >= spawned_at)→ 时间窗唯一选出它。
+        let base = tmp_root("b-window");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let proj = base.join("projects");
+        let old = write_transcript(&proj, "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", &cwd);
+        let new = write_transcript(&proj, "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb", &cwd);
+        // 把 old 的 mtime 设到很久以前,new 保持现在;spawned_at = 两者之间。
+        let long_ago = std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(1_000_000);
+        filetime_set(&old, long_ago);
+        // spawned_at 取一个介于 old 与 new 之间、肯定早于 new 真实 mtime 的时刻(2020 年)。
+        let ctx = CaptureSessionContext {
+            agent_id: "w1".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: Some("2020-01-01T00:00:00+00:00".to_string()),
+            expected_session_id: None,
+            provider_projects_root: Some(proj.clone()),
+        };
+        let out = scan_session_candidates_once(Provider::ClaudeCode, &ctx).unwrap();
+        assert_eq!(out.len(), 1, "time window must collapse two siblings to one");
+        assert_eq!(
+            out[0].captured.session_id.as_ref().unwrap().as_str(),
+            "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+            "the in-window (recent) transcript must win"
+        );
+        let _ = new;
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    fn scan_no_spawned_at_keeps_both_siblings_ambiguous() {
+        // 保守:spawned_at 缺 → 不收窄时间窗,两 sibling 仍并存(交上层 ambiguous 处理)。
+        let base = tmp_root("b-noamb");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let proj = base.join("projects");
+        write_transcript(&proj, "cccccccc-cccc-4ccc-8ccc-cccccccccccc", &cwd);
+        write_transcript(&proj, "dddddddd-dddd-4ddd-8ddd-dddddddddddd", &cwd);
+        let ctx = CaptureSessionContext {
+            agent_id: "w1".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: None,
+            provider_projects_root: Some(proj.clone()),
+        };
+        let out = scan_session_candidates_once(Provider::ClaudeCode, &ctx).unwrap();
+        assert!(out.len() >= 2, "no spawned_at → no time-window narrowing");
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    fn filetime_set(path: &Path, when: std::time::SystemTime) {
+        // 用 utimensat 经 std:无直接 set_mtime,借 filetime-free 方式:写后用 File::set_modified。
+        let f = std::fs::OpenOptions::new().write(true).open(path).unwrap();
+        f.set_modified(when).unwrap();
+    }
+}

package/crates/team-agent/src/state/selector.rs

@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 
 use serde_json::Value;
 
-use crate::model::paths::{canonical_run_workspace, team_workspace};
+use crate::model::paths::{canonical_run_workspace, runtime_spec_path, team_workspace};
 use crate::state::persist::{load_runtime_state, runtime_state_path};
 use crate::state::projection::{select_runtime_state, team_state_key};
 use crate::state::StateError;
@@ -20,7 +20,13 @@ pub struct SelectedTeam {
     pub run_workspace: PathBuf,
     pub team_key: String,
     pub state: Value,
+    /// E5 §3 解耦:**角色定义目录**(用户目录,含 TEAM.md+agents/*.md+profiles)。
+    /// 给 compile_team / 找角色定义 / profiles。**永远是用户目录**,不是 spec 落点。
+    /// 来源 = state.team_dir;缺则回落 run_workspace(自含 team-dir 布局)。
+    pub team_dir: PathBuf,
+    /// spec yaml 所在目录(demote 后 = .team/runtime/<team_key>/)。读写 spec yaml 用。
     pub spec_workspace: Option<PathBuf>,
+    /// spec yaml 路径(= runtime_spec_path(run_ws, team_key))。读写 spec yaml 用。
     pub spec_path: Option<PathBuf>,
 }
 
@@ -30,7 +36,7 @@ pub fn resolve_active_team(
     mode: SelectorMode,
 ) -> Result<SelectedTeam, StateError> {
     let explicit_spec = input.join("team.spec.yaml");
-    let (run_workspace, state, spec_workspace) = if explicit_spec.exists() {
+    let (run_workspace, state) = if explicit_spec.exists() {
         let team_run = team_workspace(input).map_err(|e| StateError::TeamSelect(e.to_string()))?;
         let run = if runtime_state_path(input).exists() || !runtime_state_path(&team_run).exists() {
             input.to_path_buf()
@@ -38,7 +44,7 @@ pub fn resolve_active_team(
             team_run
         };
         let state = select_runtime_state(&run, team).or_else(|_| load_runtime_state(&run))?;
-        (run, state, Some(input.to_path_buf()))
+        (run, state)
     } else {
         let run = canonical_run_workspace(input)
             .map_err(|e| StateError::TeamSelect(e.to_string()))?;
@@ -53,30 +59,58 @@ pub fn resolve_active_team(
             )));
         }
         let state = select_runtime_state(&run, team).or_else(|_| load_runtime_state(&run))?;
-        let spec_workspace = spec_workspace_from_state(&state)
-            .or_else(|| run.join("team.spec.yaml").exists().then(|| run.clone()));
-        (run, state, spec_workspace)
+        (run, state)
     };
 
-    let spec_path = spec_workspace.as_ref().map(|workspace| workspace.join("team.spec.yaml"));
+    // E5 spec 迁移·读序 B(architect+leader 裁定):
+    //   1) runtime spec 优先严格:<run_ws>/.team/runtime/<team_key>/team.spec.yaml 存在即必用。
+    //   2) 缺失才**只读回落**用户目录旧 spec(过渡腿;绝不在此写/迁移——迁移+清理只属启动重建)。
+    // TODO(E5 后续版本):新 team 永不写用户目录(G1),回落腿可在 legacy 清零后移除。
+    let team_key = selected_team_key(&state, team);
+    let runtime_spec = runtime_spec_path(&run_workspace, &team_key);
+    let (spec_workspace, spec_path) = if runtime_spec.exists() {
+        (
+            runtime_spec.parent().map(Path::to_path_buf),
+            Some(runtime_spec.clone()),
+        )
+    } else {
+        // 回落(只读):优先 explicit input/team.spec.yaml,其次 state 推断的 spec_workspace。
+        let legacy_ws = if explicit_spec.exists() {
+            Some(input.to_path_buf())
+        } else {
+            spec_workspace_from_state(&state)
+                .or_else(|| run_workspace.join("team.spec.yaml").exists().then(|| run_workspace.clone()))
+        };
+        let legacy_spec = legacy_ws.as_ref().map(|ws| ws.join("team.spec.yaml"));
+        (legacy_ws, legacy_spec)
+    };
     if matches!(mode, SelectorMode::RequireSpec) && !spec_path.as_ref().is_some_and(|path| path.exists()) {
-        let expected = spec_path
-            .as_ref()
-            .cloned()
-            .unwrap_or_else(|| run_workspace.join("team.spec.yaml"));
+        // 期望路径报 canonical runtime spec(重建落点),非用户目录。
+        let expected = spec_path.as_ref().cloned().unwrap_or(runtime_spec);
+        // E5 Bug2 N38:spec=中间产物,运行期由 restart 以角色定义重建;首装走 quick-start;
+        // 加新角色用 add-agent。不再提 reconcile(已废)。
         return Err(StateError::TeamSelect(format!(
-            "active team spec not found: input_workspace={} run_workspace={} team_key={} expected_spec_path={} hint=run quick-start or pass --team/--workspace <teamdir>",
+            "active team spec not found: input_workspace={} run_workspace={} team_key={} expected_spec_path={} hint=run `team-agent restart` to rebuild it from the role docs, or `team-agent quick-start <teamdir>` for first launch (to add a role at runtime use `team-agent add-agent <id> --role-file <path>`)",
             input.display(),
             run_workspace.display(),
-            selected_team_key(&state, team),
+            team_key,
             expected.display()
         )));
     }
 
+    // E5 §3 解耦:team_dir = 角色定义目录(用户目录),恒取 state.team_dir;缺则回落 run_workspace。
+    let team_dir = state
+        .get("team_dir")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .map(PathBuf::from)
+        .unwrap_or_else(|| run_workspace.clone());
+
     Ok(SelectedTeam {
         run_workspace,
-        team_key: selected_team_key(&state, team),
+        team_key,
         state,
+        team_dir,
         spec_workspace,
         spec_path,
     })

package/crates/team-agent/src/tmux_backend.rs

@@ -448,9 +448,21 @@ impl TmuxBackend {
         ];
         let output = self.run_spawn(&pane_argv)?;
         let pane = output.stdout.trim();
-        let pane_id = if pane.is_empty() { "%0" } else { pane };
+        // T3-5 (harvest §1): never fabricate a `%0` pane id on an empty reply — a fake
+        // pane id mis-addresses every later inject/capture/kill. Surface the miss.
+        if pane.is_empty() {
+            return Err(TransportError::Subprocess {
+                argv: pane_argv,
+                code: output.code,
+                stderr: format!(
+                    "tmux display-message returned no pane id for {}:{}",
+                    session.as_str(),
+                    window.as_str()
+                ),
+            });
+        }
         Ok(SpawnResult {
-            pane_id: PaneId::new(pane_id),
+            pane_id: PaneId::new(pane),
             session: session.clone(),
             window: window.clone(),
             child_pid: None,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.3.6",
-    "@team-agent/cli-darwin-x64": "0.3.6",
-    "@team-agent/cli-linux-x64": "0.3.6"
+    "@team-agent/cli-darwin-arm64": "0.3.7",
+    "@team-agent/cli-darwin-x64": "0.3.7",
+    "@team-agent/cli-linux-x64": "0.3.7"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",