@team-agent/installer 0.3.7 → 0.3.8

package/crates/team-agent/src/lifecycle/tests/core.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::transport::PaneLiveness;
 
 // ───────────────────────────────────────────────────────────────────────
 // classify_first_send_at — _classify_first_send_at (orchestration.py:404)
@@ -794,6 +795,189 @@ fn detect_dangerous_approval_clean_process_is_disabled() {
     assert!(!got.inherited);
 }
 
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_absent_pane_fails_fast() {
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "%9999");
+    let transport =
+        crate::transport::test_support::OfflineTransport::new().with_pane_presence("%9999", false);
+    let err = validate_active_leader_pane_env(&transport).expect_err("absent pane must fail");
+    let msg = err.to_string();
+    assert!(msg.contains("TEAM_AGENT_LEADER_PANE_ID"), "got: {msg}");
+    assert!(msg.contains("absent"), "got: {msg}");
+    assert!(msg.contains("%9999"), "got: {msg}");
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_dead_pane_fails_fast() {
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "%404");
+    let transport = crate::transport::test_support::OfflineTransport::new()
+        .with_liveness("%404", PaneLiveness::Dead);
+    let err = validate_active_leader_pane_env(&transport).expect_err("dead pane must fail");
+    let msg = err.to_string();
+    assert!(msg.contains("TEAM_AGENT_LEADER_PANE_ID"), "got: {msg}");
+    assert!(msg.contains("dead"), "got: {msg}");
+    assert!(msg.contains("%404"), "got: {msg}");
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_unset_passes_without_probe() {
+    let _leader_pane = EnvVarGuard::remove("TEAM_AGENT_LEADER_PANE_ID");
+    let transport = crate::transport::test_support::OfflineTransport::new();
+    validate_active_leader_pane_env(&transport).expect("unset env must pass");
+    assert!(
+        transport.calls().is_empty(),
+        "unset env must not probe transport: {:?}",
+        transport.calls()
+    );
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_unknown_when_unprovable_does_not_fail_fast() {
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "%8888");
+    let transport = crate::transport::test_support::OfflineTransport::new()
+        .with_default_liveness(PaneLiveness::Unknown);
+    validate_active_leader_pane_env(&transport).expect("unknown/unprovable pane must not fail");
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_non_numeric_pane_id_is_unknown_not_absent() {
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "abc-notapane");
+    let transport = crate::transport::test_support::OfflineTransport::new()
+        .with_pane_presence("abc-notapane", false)
+        .with_liveness("abc-notapane", PaneLiveness::Dead);
+    validate_active_leader_pane_env(&transport)
+        .expect("non `%<digits>` env values are unprovable, not absent");
+    assert!(
+        transport.calls().is_empty(),
+        "invalid pane id format must not hit tmux probe: {:?}",
+        transport.calls()
+    );
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_invalid_format_writes_warning_event() {
+    let ws = temp_ws();
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "abc-notapane");
+    let transport = crate::transport::test_support::OfflineTransport::new()
+        .with_pane_presence("abc-notapane", false);
+
+    validate_active_leader_pane_env_with_workspace(&transport, Some(&ws))
+        .expect("invalid format is warning-only");
+
+    let events = crate::event_log::EventLog::new(&ws).tail(0).expect("events");
+    let event = events
+        .iter()
+        .find(|event| {
+            event.get("event").and_then(serde_json::Value::as_str)
+                == Some("leader_pane_env.validation_warning")
+        })
+        .expect("warning event");
+    assert_eq!(
+        event.get("value").and_then(serde_json::Value::as_str),
+        Some("abc-notapane")
+    );
+    assert_eq!(
+        event.get("warning").and_then(serde_json::Value::as_str),
+        Some("invalid pane id format, skipping validation")
+    );
+}
+
+#[test]
+#[serial_test::serial(env)]
+fn leader_pane_env_invalid_format_writes_warning_to_all_candidate_workspaces() {
+    let cli_ws = temp_ws();
+    let team_ws = temp_ws();
+    let _leader_pane = EnvVarGuard::set("TEAM_AGENT_LEADER_PANE_ID", "abc-notapane");
+    let transport = crate::transport::test_support::OfflineTransport::new();
+
+    validate_active_leader_pane_env_with_workspaces(&transport, &[&cli_ws, &team_ws])
+        .expect("invalid format is warning-only");
+
+    for ws in [&cli_ws, &team_ws] {
+        let events = crate::event_log::EventLog::new(ws).tail(0).expect("events");
+        assert!(
+            events.iter().any(|event| {
+                event.get("event").and_then(serde_json::Value::as_str)
+                    == Some("leader_pane_env.validation_warning")
+                    && event.get("value").and_then(serde_json::Value::as_str)
+                        == Some("abc-notapane")
+            }),
+            "warning event missing in {}: {events:?}",
+            ws.display()
+        );
+    }
+}
+
+#[test]
+fn leader_pane_env_cross_socket_live_wins() {
+    let pane = crate::transport::PaneId::new("%7");
+    let absent =
+        crate::transport::test_support::OfflineTransport::new().with_pane_presence("%7", false);
+    let live =
+        crate::transport::test_support::OfflineTransport::new().with_pane_presence("%7", true);
+
+    let state = active_leader_pane_state_across_transports(
+        [&absent as &dyn crate::transport::Transport, &live],
+        &pane,
+    );
+
+    assert_eq!(state, LeaderPaneEnvState::Live);
+}
+
+#[test]
+fn leader_pane_env_cross_socket_dead_rejects_without_live() {
+    let pane = crate::transport::PaneId::new("%404");
+    let absent = crate::transport::test_support::OfflineTransport::new()
+        .with_pane_presence("%404", false);
+    let dead = crate::transport::test_support::OfflineTransport::new()
+        .with_liveness("%404", PaneLiveness::Dead);
+
+    let state = active_leader_pane_state_across_transports(
+        [&absent as &dyn crate::transport::Transport, &dead],
+        &pane,
+    );
+
+    assert_eq!(state, LeaderPaneEnvState::Dead);
+}
+
+#[test]
+fn leader_pane_env_cross_socket_absent_when_reachable_servers_confirm_missing() {
+    let pane = crate::transport::PaneId::new("%9999");
+    let absent = crate::transport::test_support::OfflineTransport::new()
+        .with_pane_presence("%9999", false);
+    let unknown = crate::transport::test_support::OfflineTransport::new()
+        .with_default_liveness(PaneLiveness::Unknown);
+
+    let state = active_leader_pane_state_across_transports(
+        [&absent as &dyn crate::transport::Transport, &unknown],
+        &pane,
+    );
+
+    assert_eq!(state, LeaderPaneEnvState::Absent);
+}
+
+#[test]
+fn leader_pane_env_cross_socket_all_probe_errors_stays_unknown() {
+    let pane = crate::transport::PaneId::new("%maybe");
+    let unknown_a = crate::transport::test_support::OfflineTransport::new()
+        .with_default_liveness(PaneLiveness::Unknown);
+    let unknown_b = crate::transport::test_support::OfflineTransport::new()
+        .with_default_liveness(PaneLiveness::Unknown);
+
+    let state = active_leader_pane_state_across_transports(
+        [&unknown_a as &dyn crate::transport::Transport, &unknown_b],
+        &pane,
+    );
+
+    assert_eq!(state, LeaderPaneEnvState::Unknown);
+}
+
 struct EnvVarGuard {
     key: &'static str,
     previous: Option<String>,
@@ -807,6 +991,14 @@ impl EnvVarGuard {
         }
         Self { key, previous }
     }
+
+    fn remove(key: &'static str) -> Self {
+        let previous = std::env::var(key).ok();
+        unsafe {
+            std::env::remove_var(key);
+        }
+        Self { key, previous }
+    }
 }
 
 impl Drop for EnvVarGuard {

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -545,6 +545,42 @@ fn e5_restart_rebuilds_runtime_spec_from_role_docs() {
     );
 }
 
+// RED-2 (P0) — restart existence gate must use selected.spec_path (read-order B: runtime spec),
+// NOT the user-dir team.spec.yaml. spec-demote put spec under .team/runtime/<key>/, so the old
+// pre-resolve gate (`!workspace.join("team.spec.yaml").exists()`) falsely reported "missing spec".
+#[test]
+fn red2_restart_finds_runtime_spec_not_missing_when_user_dir_has_no_spec() {
+    let ws = restart_ws_two_resumable_workers(); // has TEAM.md + agents + state
+    // Simulate spec-demote: remove any user-dir spec the fixture wrote; restart must still find
+    // the runtime spec (rebuilt from role docs / read-order B), NOT report "missing spec".
+    let _ = std::fs::remove_file(ws.join("team.spec.yaml"));
+    assert!(!ws.join("team.spec.yaml").exists(), "user-dir spec removed (spec-demote condition)");
+    let transport = OfflineTransport::new();
+    let result = restart_with_transport(&ws, false, None, &transport);
+    // The gate must NOT short-circuit with "missing spec for restart" — restart must proceed
+    // (any later resume/rebuild outcome is fine; we only assert the spec-missing gate is gone).
+    let text = format!("{result:?}");
+    assert!(
+        !text.contains("missing spec for restart"),
+        "RED-2: restart must locate the runtime spec via read-order B, not report missing; got {text}"
+    );
+}
+
+// RED-2 negative — a truly empty workspace (no role docs, no spec, no state) must STILL report
+// missing spec (gate moved, not removed).
+#[test]
+fn red2_restart_empty_workspace_still_reports_missing() {
+    let ws = temp_ws(); // empty, no TEAM.md/agents/spec/state
+    let transport = OfflineTransport::new();
+    let result = restart_with_transport(&ws, false, None, &transport);
+    let text = format!("{result:?}");
+    assert!(
+        text.contains("missing spec") || text.to_lowercase().contains("not found") || text.contains("no_local_team_context") || text.to_lowercase().contains("invalid workspace"),
+        "RED-2 negative: empty workspace restart must still error (missing/not-found); got {text}"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
 // E5 task#3 / RC-A6b — restart with role definitions MISSING explicitly refuses (lists what's
 // missing) and leaves the previous runtime spec in place (no silent path, no data destruction).
 #[test]

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/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() {