@team-agent/installer 0.3.6 → 0.3.8

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)
@@ -1059,30 +1118,51 @@ fn scan_copilot_session_store(context: &CaptureSessionContext) -> Vec<CapturedSe
     ) else {
         return Vec::new();
     };
-    let cwd = context.spawn_cwd.to_string_lossy().to_string();
-    let mut stmt = match conn.prepare(
-        "select id from sessions where cwd = ?1 order by updated_at desc, id desc limit 1",
-    ) {
-        Ok(stmt) => stmt,
-        Err(_) => return Vec::new(),
-    };
-    let row: Option<String> = stmt
-        .query_row([cwd.as_str()], |row| row.get::<_, String>(0))
-        .ok();
-    let Some(session_id) = row else {
+    // E11 层1(本机实锤):copilot honor `--session-id`(sessions.id == 注入的 expected_session_id),
+    // 故 worker 权威 id 可靠在 db。**expected-id 优先点查**:命中即返(High,直接根治 leader/worker
+    // 同 cwd 共享 db 时 latest-wins 误抓 leader 的 bug)。expected 查无 → **不 promote**(E6 铁律:
+    // 不硬写不在盘的假 session),回落 cwd-latest 让收敛重试。
+    if let Some(expected) = context.expected_session_id.as_ref() {
+        let hit: Option<String> = conn
+            .prepare("select id from sessions where id = ?1 limit 1")
+            .ok()
+            .and_then(|mut stmt| {
+                stmt.query_row([expected.as_str()], |row| row.get::<_, String>(0)).ok()
+            });
+        if let Some(session_id) = hit {
+            return vec![copilot_candidate(session_id, &db_path, context)];
+        }
+        // expected 设了但 db 无该 id → 返空(收敛重试),绝不回落抓别人(尤其 leader)的 latest。
         return Vec::new();
-    };
-    vec![CapturedSessionCandidate {
+    }
+    // 无 expected → **返空**(保守,不 cwd-latest 猜)。
+    // E11 层1 兜底洞(architect 核实):leader+worker 同 cwd 共享 db 时,cwd-latest 可能抓 leader
+    // 的 session;而 allocator 的 claimed 去重只扫 state.agents,**leader 在 state.leader/team_owner
+    // 不在 agents → 兜不住**;且 leader 的 copilot session_id 运行期不入 state(team_owner 只存
+    // leader_session_uuid,非 copilot db id),故无从显式排除。所幸 copilot build_command_plan **总**
+    // 注入 --session-id(expected_session_id 恒 Some)→ 真实 copilot worker 永走上面点查路径,
+    // 此 expected=None 分支对真实 worker 不可达。故直接返空最干净:不猜、绝不把 leader session 分给
+    // worker。db 留 _。
+    let _ = (&db_path, &conn);
+    Vec::new()
+}
+
+fn copilot_candidate(
+    session_id: String,
+    db_path: &Path,
+    context: &CaptureSessionContext,
+) -> CapturedSessionCandidate {
+    CapturedSessionCandidate {
         captured: CapturedSession {
             session_id: Some(SessionId::new(session_id)),
-            rollout_path: Some(RolloutPath::new(db_path.clone())),
+            rollout_path: Some(RolloutPath::new(db_path.to_path_buf())),
             captured_via: CaptureVia::FsWatch,
             attribution_confidence: Confidence::High,
             spawn_cwd: context.spawn_cwd.clone(),
         },
         positive_agent_id_match: false,
         agent_path_match: false,
-    }]
+    }
 }
 
 fn command_on_path(name: &str) -> bool {
@@ -1113,6 +1193,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 +1851,283 @@ 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();
+    }
+
+    // ── E11 层1:copilot session 归因(expected-id 优先,不抓 leader latest)──
+    struct HomeGuard {
+        prev: Option<std::ffi::OsString>,
+    }
+    impl HomeGuard {
+        fn set(home: &Path) -> Self {
+            let prev = std::env::var_os("HOME");
+            std::env::set_var("HOME", home);
+            Self { prev }
+        }
+    }
+    impl Drop for HomeGuard {
+        fn drop(&mut self) {
+            match &self.prev {
+                Some(v) => std::env::set_var("HOME", v),
+                None => std::env::remove_var("HOME"),
+            }
+        }
+    }
+
+    /// 造一个 copilot session-store.db,写 (id, cwd, updated_at) 行。
+    fn seed_copilot_db(home: &Path, rows: &[(&str, &str, i64)]) {
+        let dir = home.join(".copilot");
+        std::fs::create_dir_all(&dir).unwrap();
+        let conn = rusqlite::Connection::open(dir.join("session-store.db")).unwrap();
+        conn.execute(
+            "create table sessions (id text primary key, cwd text, updated_at integer)",
+            [],
+        )
+        .unwrap();
+        for (id, cwd, updated) in rows {
+            conn.execute(
+                "insert into sessions (id, cwd, updated_at) values (?1, ?2, ?3)",
+                rusqlite::params![id, cwd, updated],
+            )
+            .unwrap();
+        }
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_expected_id_wins_over_leader_latest_same_cwd() {
+        // 真机复现的确定性 fixture:leader row updated 晚(latest),worker row id == expected。
+        // capture 必返 worker 自己的 id,不返 leader 的 latest。
+        let base = tmp_root("e11-copilot");
+        let home = base.join("home");
+        std::fs::create_dir_all(&home).unwrap();
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let worker_id = "1142c4c2-0000-4000-8000-000000000001";
+        let leader_id = "f9c5485d-0000-4000-8000-00000000beef";
+        // leader updated_at 更大(latest-wins 会抓它);worker 更早。
+        seed_copilot_db(
+            &home,
+            &[
+                (worker_id, &cwd.to_string_lossy(), 100),
+                (leader_id, &cwd.to_string_lossy(), 999),
+            ],
+        );
+        let _h = HomeGuard::set(&home);
+        let ctx = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: Some(SessionId::new(worker_id)),
+            provider_projects_root: None,
+        };
+        let out = scan_copilot_session_store(&ctx);
+        assert_eq!(out.len(), 1, "expected-id point query → single authoritative candidate");
+        assert_eq!(
+            out[0].captured.session_id.as_ref().unwrap().as_str(),
+            worker_id,
+            "must return worker's own (expected) session, NOT leader's latest"
+        );
+        drop(_h);
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_expected_id_absent_in_db_returns_empty_not_leader() {
+        // expected 设了但 db 无该 id(会话还没落)→ 返空(收敛重试),绝不回落抓 leader latest。
+        let base = tmp_root("e11-copilot-absent");
+        let home = base.join("home");
+        std::fs::create_dir_all(&home).unwrap();
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let leader_id = "f9c5485d-0000-4000-8000-00000000beef";
+        seed_copilot_db(&home, &[(leader_id, &cwd.to_string_lossy(), 999)]);
+        let _h = HomeGuard::set(&home);
+        let ctx = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: Some(SessionId::new("1142c4c2-0000-4000-8000-000000000001")),
+            provider_projects_root: None,
+        };
+        let out = scan_copilot_session_store(&ctx);
+        assert!(
+            out.is_empty(),
+            "expected id absent in db → empty (no promote, no leader latest); got {out:?}"
+        );
+        drop(_h);
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_no_expected_same_cwd_only_leader_row_returns_empty_not_leader() {
+        // E11 层1 兜底洞(architect):无 expected + 同 cwd 仅 leader row → 必返空,绝不返 leader。
+        // (真实 copilot worker 恒有 expected,此分支不可达;保守返空堵住 allocator 不排除 leader 的洞。)
+        let base = tmp_root("e11-copilot-noexp");
+        let home = base.join("home");
+        std::fs::create_dir_all(&home).unwrap();
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let leader_id = "f9c5485d-0000-4000-8000-00000000beef";
+        seed_copilot_db(&home, &[(leader_id, &cwd.to_string_lossy(), 999)]);
+        let _h = HomeGuard::set(&home);
+        let ctx = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: None, // 无 expected → 兜底路径
+            provider_projects_root: None,
+        };
+        let out = scan_copilot_session_store(&ctx);
+        assert!(
+            out.is_empty(),
+            "no expected + only leader row in same cwd → must return empty, NOT leader; got {out:?}"
+        );
+        drop(_h);
+        let _ = std::fs::remove_dir_all(&base);
+    }
+}

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

@@ -422,6 +422,7 @@ fn py_repr_str(s: &str) -> String {
 mod tests {
     #![allow(clippy::unwrap_used, clippy::panic, clippy::expect_used)]
     use super::*;
+    use serial_test::serial;
     use std::collections::HashMap;
     use std::sync::atomic::{AtomicU32, Ordering};
 
@@ -446,6 +447,32 @@ mod tests {
         ws
     }
 
+    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),
+                }
+            }
+        }
+    }
+
     #[test]
     fn os_user_and_fingerprint() {
         assert_eq!(identity_os_user(&env(&[("USER", "alice")])), "alice");
@@ -560,7 +587,9 @@ mod tests {
     }
 
     #[test]
+    #[serial(env)]
     fn apply_first_time_binding_success_writes_state() {
+        let _env = EnvUnsetGuard::unset(&["TMUX", "TMUX_PANE"]);
         let ws = temp_ws();
         let now = "2026-06-02T09:17:59.994383+00:00";
         let mut state = json!({});