@team-agent/installer 0.3.7 → 0.3.9

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

@@ -499,12 +499,14 @@ pub enum QuickStartReport {
         session_name: Option<SessionName>,
         state_path: Option<PathBuf>,
         next_actions: Vec<String>,
+        attach_commands: Vec<String>,
     },
     /// preflight 阻塞(`quick_start.py:59`)。
     PreflightBlocked {
         summary: String,
         blockers: Vec<String>,
         next_actions: Vec<String>,
+        attach_commands: Vec<String>,
     },
 }
 

package/crates/team-agent/src/messaging/results.rs

@@ -689,28 +689,33 @@ pub fn report_result_for_owner_team(
                     std::thread::sleep(std::time::Duration::from_millis(50));
                 }
             }
-            match inject_leader_notification_direct(workspace, &delivery_state, &content, &message_id) {
-                Ok(()) => {
-                    store.mark(&message_id, "delivered", None)?;
-                    outcome = crate::messaging::DeliveryOutcome {
-                        ok: true,
-                        status: crate::messaging::DeliveryStatus::Delivered,
-                        message_status: super::helpers::MessageStatusShadow("delivered".to_string()),
-                        message_id: Some(message_id),
-                        verification: None,
-                        stage: None,
-                        reason: None,
-                        channel: Some("leader_receiver".to_string()),
-                    };
-                }
-                Err(reason) => {
-                    event_log.write(
-                        "leader_receiver.direct_inject_skipped",
-                        serde_json::json!({
-                            "message_id": message_id,
-                            "reason": reason,
-                        }),
-                    )?;
+            // E15(F4.4 双投修):direct inject 是 deliver **失败时的兜底**,不是无条件第二投。
+            // deliver loop 成功(outcome.ok)→ 跳过 direct inject,leader 仅收 deliver 那一条;
+            // 全失败 → direct inject 兜底投一条(不丢 result,守 #230/MUST-8)。两全:恰一条。
+            if !outcome.ok {
+                match inject_leader_notification_direct(workspace, &delivery_state, &content, &message_id) {
+                    Ok(()) => {
+                        store.mark(&message_id, "delivered", None)?;
+                        outcome = crate::messaging::DeliveryOutcome {
+                            ok: true,
+                            status: crate::messaging::DeliveryStatus::Delivered,
+                            message_status: super::helpers::MessageStatusShadow("delivered".to_string()),
+                            message_id: Some(message_id),
+                            verification: None,
+                            stage: None,
+                            reason: None,
+                            channel: Some("leader_receiver".to_string()),
+                        };
+                    }
+                    Err(reason) => {
+                        event_log.write(
+                            "leader_receiver.direct_inject_skipped",
+                            serde_json::json!({
+                                "message_id": message_id,
+                                "reason": reason,
+                            }),
+                        )?;
+                    }
                 }
             }
     }

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1435,3 +1435,21 @@ fn r8_attach_requeue_exhausted_to_notify_failed_golden_attach_event() {
     assert_eq!(ev.get("trigger").and_then(|v| v.as_str()), Some("attach_leader"));
     assert_eq!(ev.get("new_pane_id").and_then(|v| v.as_str()), Some("%leader-new"));
 }
+
+// E15 (F4.4 双投修)·源码守卫:report_result 的 direct inject 必须被 `if !outcome.ok` 守为
+// deliver 失败时的真兜底,绝不在 deliver 成功后无条件再投一次(=用户看到两条同内容回复)。
+#[test]
+fn e15_direct_inject_is_gated_by_deliver_failure_not_unconditional() {
+    let src = include_str!("../results.rs");
+    // 锁:inject_leader_notification_direct 调用点之前必须有 `if !outcome.ok` 门。
+    let gate = "if !outcome.ok {";
+    let inject_call = "match inject_leader_notification_direct(";
+    let gate_pos = src.find(gate);
+    let inject_pos = src.find(inject_call);
+    assert!(gate_pos.is_some(), "E15: direct inject must be gated by `if !outcome.ok` (deliver-fail fallback)");
+    assert!(inject_pos.is_some(), "inject_leader_notification_direct call site must exist (do NOT delete it; #230 fallback)");
+    assert!(
+        gate_pos.unwrap() < inject_pos.unwrap(),
+        "E15: the `if !outcome.ok` gate must precede the direct-inject call (deliver-success must skip inject → leader gets exactly one copy)"
+    );
+}

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

@@ -1118,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 {
@@ -1968,4 +1989,145 @@ mod e6_session_attribution_tests {
         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!({});

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

@@ -503,6 +503,50 @@
         );
     }
 
+    #[test]
+    fn has_pane_is_direct_existence_probe_not_liveness_guess() {
+        let (be, rec) = backend_with(MockResp::Out(ok("%7")), vec![]);
+        assert_eq!(be.has_pane(&PaneId::new("%7")).expect("has_pane"), Some(true));
+        let argv0 = rec.lock().unwrap()[0].clone();
+        assert!(
+            argv0.contains(&"display-message".to_string())
+                && argv0.iter().any(|x| x.contains("#{pane_id}"))
+                && argv0.contains(&"%7".to_string()),
+            "has_pane must use the cheap display-message #{{pane_id}} probe; got {argv0:?}"
+        );
+
+        let (be, _r) = backend_with(MockResp::Out(ok("")), vec![]);
+        assert_eq!(
+            be.has_pane(&PaneId::new("%9999")).expect("has_pane"),
+            Some(false),
+            "real tmux can report a missing pane as exit 0 with empty stdout"
+        );
+
+        let (be, _r) = backend_with(MockResp::Out(fail(1, "can't find pane: %9999")), vec![]);
+        assert_eq!(be.has_pane(&PaneId::new("%9999")).expect("has_pane"), Some(false));
+
+        let (be, _r) = backend_with(MockResp::Out(ok("%8")), vec![]);
+        assert_eq!(
+            be.has_pane(&PaneId::new("%7")).expect("has_pane"),
+            None,
+            "a successful but mismatched pane id is not proof that the requested pane exists"
+        );
+
+        let (be, _r) = backend_with(MockResp::Out(ok("not-a-pane")), vec![]);
+        assert_eq!(
+            be.has_pane(&PaneId::new("%7")).expect("has_pane"),
+            None,
+            "a successful but invalid pane id stays Unknown"
+        );
+
+        let (be, _r) = backend_with(MockResp::Out(fail(1, "error connecting to server: No such file or directory")), vec![]);
+        assert_eq!(
+            be.has_pane(&PaneId::new("%7")).expect("has_pane"),
+            None,
+            "server/probe errors remain Unknown, not absent"
+        );
+    }
+
     // ── CP-1: per-team socket — for_workspace injects `-L ta-<hash>` at the run chokepoint; new() does NOT ─
     #[test]
     fn for_workspace_backend_injects_per_team_socket_but_default_backend_does_not() {

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

@@ -18,6 +18,7 @@
 use std::collections::BTreeMap;
 use std::hash::{Hash, Hasher};
 use std::io::{Read, Write};
+use std::os::unix::fs::FileTypeExt;
 use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::time::{Duration, Instant};
@@ -331,6 +332,20 @@ pub(crate) fn socket_name_for_workspace(workspace: &Path) -> String {
 }
 
 pub(crate) fn socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
+    if let Some(existing) = existing_socket_path_for_workspace(workspace) {
+        return Some(existing);
+    }
+    let uid = unsafe { libc::geteuid() };
+    let default_root = PathBuf::from(format!("/tmp/tmux-{uid}"));
+    let default_root = default_root.canonicalize().unwrap_or(default_root);
+    Some(default_root.join(socket_name_for_workspace(workspace)))
+}
+
+pub(crate) fn socket_probe_missing_for_workspace(workspace: &Path) -> bool {
+    existing_socket_path_for_workspace(workspace).is_none()
+}
+
+fn existing_socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
     let socket_name = socket_name_for_workspace(workspace);
     let roots = tmux_socket_roots();
     for root in &roots {
@@ -340,12 +355,19 @@ pub(crate) fn socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
             return Some(candidate.canonicalize().unwrap_or(candidate));
         }
     }
-    let uid = unsafe { libc::geteuid() };
-    let default_root = PathBuf::from(format!("/tmp/tmux-{uid}"));
-    let default_root = default_root
-        .canonicalize()
-        .unwrap_or(default_root);
-    Some(default_root.join(socket_name))
+    None
+}
+
+pub(crate) fn socket_missing_hint_for_workspace(workspace: &Path) -> String {
+    let socket_name = socket_name_for_workspace(workspace);
+    let roots = tmux_socket_roots()
+        .into_iter()
+        .map(|root| root.display().to_string())
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!(
+        "tmux socket {socket_name} not found under [{roots}]; run `team-agent attach-leader` or restart the team before attaching"
+    )
 }
 
 pub(crate) fn attach_command_for_workspace(
@@ -373,7 +395,7 @@ pub(crate) fn attach_commands_for_windows<'a>(
         .collect()
 }
 
-fn tmux_socket_roots() -> Vec<PathBuf> {
+pub(crate) fn tmux_socket_roots() -> Vec<PathBuf> {
     let uid = unsafe { libc::geteuid() };
     let mut roots = vec![PathBuf::from(format!("/tmp/tmux-{uid}"))];
     if let Some(tmpdir) = std::env::var_os("TMPDIR") {
@@ -384,6 +406,29 @@ fn tmux_socket_roots() -> Vec<PathBuf> {
     roots
 }
 
+pub(crate) fn tmux_socket_endpoints() -> Vec<String> {
+    let mut endpoints = Vec::new();
+    for root in tmux_socket_roots() {
+        let Ok(entries) = std::fs::read_dir(root) else {
+            continue;
+        };
+        for entry in entries.flatten() {
+            let Ok(file_type) = entry.file_type() else {
+                continue;
+            };
+            if !file_type.is_socket() {
+                continue;
+            }
+            let path = entry.path();
+            let path = path.canonicalize().unwrap_or(path);
+            endpoints.push(path.to_string_lossy().to_string());
+        }
+    }
+    endpoints.sort();
+    endpoints.dedup();
+    endpoints
+}
+
 pub(crate) fn socket_name_from_tmux_env() -> Option<String> {
     let tmux = std::env::var("TMUX")
         .ok()
@@ -673,6 +718,10 @@ impl Transport for TmuxBackend {
         BackendKind::Tmux
     }
 
+    fn probes_real_tmux_socket_roots(&self) -> bool {
+        true
+    }
+
     fn spawn_first(
         &self,
         session: &SessionName,
@@ -859,6 +908,40 @@ impl Transport for TmuxBackend {
         }
     }
 
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "display-message".to_string(),
+            "-p".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            "#{pane_id}".to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if output.success {
+            let pane_id = output.stdout.trim();
+            if pane_id.is_empty() {
+                return Ok(Some(false));
+            }
+            if pane_id == pane.as_str()
+                && pane_id.starts_with('%')
+                && pane_id[1..].chars().all(|ch| ch.is_ascii_digit())
+            {
+                return Ok(Some(true));
+            }
+            return Ok(None);
+        }
+        let stderr = output.stderr.to_ascii_lowercase();
+        if stderr.contains("can't find pane")
+            || stderr.contains("no such pane")
+            || (stderr.contains("can't find") && stderr.contains("pane"))
+        {
+            Ok(Some(false))
+        } else {
+            Ok(None)
+        }
+    }
+
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
         // P5 (C-P5-3): `#{pane_pid}` rides the single list-panes call (field index 11),
         // killing the per-pane display-message N+1 fallback.

package/crates/team-agent/src/transport/test_support.rs

@@ -18,18 +18,39 @@ pub struct SpawnRecord {
     pub argv: Vec<String>,
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 struct OfflineState {
     session_present: bool,
     session_absent_after_spawn_first: bool,
     targets: Vec<PaneInfo>,
     windows: Vec<WindowName>,
+    pane_presence: BTreeMap<String, bool>,
+    liveness: BTreeMap<String, PaneLiveness>,
+    default_liveness: PaneLiveness,
     calls: Vec<&'static str>,
     spawns: Vec<SpawnRecord>,
     inject_targets: Vec<Target>,
     inject_payloads: Vec<String>,
 }
 
+impl Default for OfflineState {
+    fn default() -> Self {
+        Self {
+            session_present: false,
+            session_absent_after_spawn_first: false,
+            targets: Vec::new(),
+            windows: Vec::new(),
+            pane_presence: BTreeMap::new(),
+            liveness: BTreeMap::new(),
+            default_liveness: PaneLiveness::Unknown,
+            calls: Vec::new(),
+            spawns: Vec::new(),
+            inject_targets: Vec::new(),
+            inject_payloads: Vec::new(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct OfflineTransport {
     inner: Arc<Mutex<OfflineState>>,
@@ -60,6 +81,25 @@ impl OfflineTransport {
         self
     }
 
+    pub fn with_default_liveness(self, liveness: PaneLiveness) -> Self {
+        self.with_state(|state| state.default_liveness = liveness);
+        self
+    }
+
+    pub fn with_liveness(self, pane: impl Into<String>, liveness: PaneLiveness) -> Self {
+        self.with_state(|state| {
+            state.liveness.insert(pane.into(), liveness);
+        });
+        self
+    }
+
+    pub fn with_pane_presence(self, pane: impl Into<String>, present: bool) -> Self {
+        self.with_state(|state| {
+            state.pane_presence.insert(pane.into(), present);
+        });
+        self
+    }
+
     pub fn calls(&self) -> Vec<&'static str> {
         self.with_state(|state| state.calls.clone())
     }
@@ -198,9 +238,22 @@ impl Transport for OfflineTransport {
         Ok(None)
     }
 
-    fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
-        self.record("liveness");
-        Ok(PaneLiveness::Unknown)
+    fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
+        Ok(self.with_state(|state| {
+            state.calls.push("liveness");
+            state
+                .liveness
+                .get(pane.as_str())
+                .copied()
+                .unwrap_or(state.default_liveness)
+        }))
+    }
+
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        Ok(self.with_state(|state| {
+            state.calls.push("has_pane");
+            state.pane_presence.get(pane.as_str()).copied()
+        }))
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {

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

@@ -399,6 +399,12 @@ pub trait Transport: Send + Sync {
     /// 后端种类(诊断/事件用)。
     fn kind(&self) -> BackendKind;
 
+    /// Only the concrete tmux backend should scan real tmux socket roots.
+    /// Test doubles stay hermetic and use their injected probe results.
+    fn probes_real_tmux_socket_roots(&self) -> bool {
+        false
+    }
+
     // —— SPAWN(ST):所有后端天然满足;cwd/env 是 spawn 参数,无独立动词(§gap-setenv)——
 
     /// tmux=`new-session -d` / wezterm=`spawn --new-window` / conpty=`openpty`+spawn。
@@ -481,6 +487,13 @@ pub trait Transport: Send + Sync {
     /// pane 存活三态(`PaneLiveness`,bug-085 穷尽 match;unknown ≠ dead ≠ live)。
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError>;
 
+    /// Cheap direct pane existence check when a backend can prove it. `Ok(None)`
+    /// preserves the existing Unknown boundary.
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        let _ = pane;
+        Ok(None)
+    }
+
     // —— ENUMERATE / IDENTITY(SL + 进程探测):身份/rebind 地基 ——
 
     /// 全局枚举所有 pane + 每 pane 的 leader_env。tmux=`list-panes -a` + 读进程 env;