@team-agent/installer 0.3.12 → 0.3.13

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

@@ -1030,24 +1030,151 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
         matches!(result, Ok(RestartReport::Restarted { coordinator_started: true, .. })),
         "restart must reach RestartReport::Restarted with coordinator_started=true (AlreadyRunning, seeded); got {result:?}"
     );
+    let events = crate::event_log::EventLog::new(&ws).tail(20).unwrap();
+    let completed = events
+        .iter()
+        .find(|event| event.get("event").and_then(|v| v.as_str()) == Some("restart.completed"))
+        .expect("restart.completed event for successful restart");
+    assert_eq!(completed.get("rc").and_then(|v| v.as_str()), Some("ok"));
 
     let ws = restart_ws_two_resumable_workers();
     let dead_after_first = OfflineTransport::new().with_session_absent_after_spawn_first();
-    let result = restart_with_transport(&ws, false, None, &dead_after_first);
+    let result =
+        restart_with_transport_with_readiness_deadline(&ws, false, None, &dead_after_first, Some(0));
     let recorded = dead_after_first.spawn_records();
     assert_eq!(
         recorded.len(),
-        1,
-        "if the session disappears after alpha, restart must stop before spawning bravo; got result={result:?} recorded={recorded:?}"
+        2,
+        "if the session disappears after alpha, restart must isolate alpha and still try bravo; got result={result:?} recorded={recorded:?}"
+    );
+    assert!(
+        recorded.iter().all(|(kind, _)| kind == "spawn_first"),
+        "restart must not call spawn_into/new-window against a dead server; result={result:?} recorded={recorded:?}"
+    );
+    assert!(
+        dead_after_first.calls().iter().all(|call| *call != "kill_session"),
+        "a single worker/session disappearance must not trigger another shared-session kill; calls={:?}",
+        dead_after_first.calls()
+    );
+    let events = crate::event_log::EventLog::new(&ws).tail(20).unwrap();
+    let failed = events
+        .iter()
+        .find(|event| event.get("event").and_then(|v| v.as_str()) == Some("restart.agent_failed"))
+        .expect("restart.agent_failed event for isolated alpha");
+    assert_eq!(failed.get("agent_id").and_then(|v| v.as_str()), Some("alpha"));
+    assert!(
+        failed
+            .get("error")
+            .and_then(|v| v.as_str())
+            .is_some_and(|error| error.contains("session_disappeared_after_spawn")),
+        "restart must report the first resumed agent/session disappearance explicitly; event={failed} result={result:?}"
+    );
+}
+
+#[test]
+fn restart_spawn_failure_isolated_to_partial_report() {
+    let ws = restart_ws_two_resumable_workers();
+    let transport = OfflineTransport::new().with_spawn_failure("bravo", "injected bravo failure");
+
+    let result = restart_with_transport(&ws, false, None, &transport);
+
+    let report = result.expect("single worker failure must be represented as partial report");
+    let RestartReport::Partial {
+        agents,
+        failed_agents,
+        coordinator_started,
+        ..
+    } = report
+    else {
+        panic!("single worker failure must return RestartReport::Partial; got {report:?}");
+    };
+    assert!(coordinator_started, "partial restart still starts coordinator for successful agents");
+    assert_eq!(
+        agents.iter().map(|agent| agent.agent_id.as_str()).collect::<Vec<_>>(),
+        vec!["alpha"]
+    );
+    assert_eq!(failed_agents.len(), 1);
+    assert_eq!(failed_agents[0].agent_id.as_str(), "bravo");
+    assert_eq!(failed_agents[0].phase, "spawn");
+
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    assert_eq!(state.pointer("/agents/alpha/status").and_then(|v| v.as_str()), Some("running"));
+    assert_eq!(state.pointer("/agents/bravo/status").and_then(|v| v.as_str()), Some("failed"));
+    assert!(
+        state
+            .pointer("/agents/bravo/restart_error")
+            .and_then(|v| v.as_str())
+            .is_some_and(|error| error.contains("injected bravo failure")),
+        "failed agent must retain restart_error in state: {state}"
+    );
+
+    let events = crate::event_log::EventLog::new(&ws).tail(20).unwrap();
+    let completed = events
+        .iter()
+        .find(|event| event.get("event").and_then(|v| v.as_str()) == Some("restart.completed"))
+        .expect("restart.completed event for partial restart");
+    assert_eq!(completed.get("rc").and_then(|v| v.as_str()), Some("partial"));
+    assert!(
+        completed
+            .get("successful_agents")
+            .and_then(|v| v.as_array())
+            .is_some_and(|agents| agents.iter().any(|agent| agent.as_str() == Some("alpha"))),
+        "completed event must list successful agents: {completed}"
     );
     assert!(
-        recorded.iter().all(|(kind, _)| kind != "spawn_into"),
-        "restart must not call spawn_into/new-window for bravo against a dead server; result={result:?} recorded={recorded:?}"
+        completed
+            .get("failed_agents")
+            .and_then(|v| v.as_array())
+            .is_some_and(|agents| agents.iter().any(|agent| {
+                agent.get("agent_id").and_then(|v| v.as_str()) == Some("bravo")
+                    && agent.get("phase").and_then(|v| v.as_str()) == Some("spawn")
+            })),
+        "completed event must list failed agents with phase: {completed}"
     );
-    let error = format!("{result:?}");
+}
+
+#[test]
+fn restart_all_spawn_failures_return_failed_report() {
+    let ws = restart_ws_one_resumable_worker();
+    let transport = OfflineTransport::new().with_spawn_failure("alpha", "injected alpha failure");
+
+    let result = restart_with_transport(&ws, false, None, &transport);
+
+    let report = result.expect("all worker failures should return typed failed report");
+    let RestartReport::Failed { failed_agents, .. } = report else {
+        panic!("all worker failures must return RestartReport::Failed; got {report:?}");
+    };
+    assert_eq!(failed_agents.len(), 1);
+    assert_eq!(failed_agents[0].agent_id.as_str(), "alpha");
+    assert_eq!(failed_agents[0].phase, "spawn");
+
+    let events = crate::event_log::EventLog::new(&ws).tail(20).unwrap();
+    let completed = events
+        .iter()
+        .find(|event| event.get("event").and_then(|v| v.as_str()) == Some("restart.completed"))
+        .expect("restart.completed event for failed restart");
+    assert_eq!(completed.get("rc").and_then(|v| v.as_str()), Some("fail"));
+}
+
+#[test]
+fn restart_spawn_loop_keeps_failure_isolation_guard() {
+    let source = include_str!("../restart/rebuild.rs");
+    let start = source
+        .find("BEGIN_B5_RESTART_ISOLATION_LOOP")
+        .expect("B5 isolation loop start marker");
+    let end = source
+        .find("END_B5_RESTART_ISOLATION_LOOP")
+        .expect("B5 isolation loop end marker");
+    let body = &source[start..end];
+    for forbidden in ["?;", "break", "return "] {
+        assert!(
+            !body.contains(forbidden),
+            "B5 spawn loop must not fail-fast via {forbidden:?}; body={body}"
+        );
+    }
     assert!(
-        error.contains("session_disappeared_after_spawn") || error.contains("provider_resume_exited"),
-        "restart must report the first resumed agent/session disappearance explicitly, not continue to a later no-server failure; result={result:?}"
+        body.contains("continue"),
+        "B5 spawn loop should isolate per-agent failures and continue; body={body}"
     );
 }
 

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

@@ -620,6 +620,23 @@ pub enum RestartReport {
         next_actions: Vec<String>,
         attach_commands: Vec<String>,
     },
+    /// At least one worker failed during live spawn, but other workers were isolated
+    /// and restarted. The CLI reports `status=partial` and exits non-zero.
+    Partial {
+        session_name: SessionName,
+        agents: Vec<RestartedAgent>,
+        failed_agents: Vec<RestartFailedAgent>,
+        coordinator_started: bool,
+        next_actions: Vec<String>,
+        attach_commands: Vec<String>,
+    },
+    /// All workers failed during live spawn. No worker is reported as restarted.
+    Failed {
+        session_name: SessionName,
+        failed_agents: Vec<RestartFailedAgent>,
+        next_actions: Vec<String>,
+        attach_commands: Vec<String>,
+    },
     /// atomic refusal(`reason=resume_atomicity`):某 interacted worker 不可 resume
     /// 且非 allow_fresh。**nothing created yet**,无需回滚。
     RefusedResumeAtomicity {
@@ -652,6 +669,17 @@ pub struct RestartedAgent {
     pub session_id: Option<SessionId>,
 }
 
+/// Worker restart failure isolated from the rest of the restart pass.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RestartFailedAgent {
+    pub agent_id: AgentId,
+    pub restart_mode: StartMode,
+    pub decision: ResumeDecision,
+    pub session_id: Option<SessionId>,
+    pub phase: String,
+    pub error: String,
+}
+
 /// atomic refusal 里的不可重建 worker(`orchestration.py:517`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct UnresumableWorker {

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

@@ -744,7 +744,7 @@ fn recipient_pane_has_actionable_startup_prompt(
     let provider = agent
         .and_then(|agent| agent.get("provider"))
         .and_then(serde_json::Value::as_str);
-    if !matches!(provider, Some("codex" | "claude" | "claude_code")) {
+    if !matches!(provider, Some("codex" | "claude" | "claude_code" | "copilot")) {
         return false;
     }
     // step2-retry/scrollback root-cause (rt binary 6c9c6c1c): once the agent's
@@ -777,6 +777,10 @@ fn recipient_pane_has_actionable_startup_prompt(
             crate::provider::classify_claude_startup_screen(&captured),
             crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
         ),
+        Some("copilot") => matches!(
+            crate::provider::classify_copilot_startup_screen(&captured),
+            crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
+        ),
         _ => false,
     }
 }

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

@@ -123,7 +123,7 @@ pub(crate) fn non_provider_command(command: &str) -> Option<&str> {
     let base = command.rsplit('/').next().unwrap_or(command);
     let normalized = base.to_ascii_lowercase();
     match normalized.as_str() {
-        "" | "codex" | "claude" | "gemini" | "openai" | "team-agent" => None,
+        "" | "codex" | "claude" | "copilot" | "gemini" | "openai" | "team-agent" => None,
         _ => Some(base),
     }
 }

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

@@ -174,6 +174,20 @@ fn classify_idle_prompt_beats_recent_output_for_just_launched_agent() {
     );
 }
 
+#[test]
+fn classify_copilot_idle_prompt_is_not_masked_by_current_command() {
+    let state = json(serde_json::json!({}));
+    let a = classify_agent_activity(
+        &state,
+        " / commands · ? help\n❯ \n",
+        false,
+        Some("copilot"),
+        None,
+    );
+    assert_eq!(a.status, ActivityStatus::Idle);
+    assert_eq!(a.confidence, 0.9);
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // GROUP H — attempt_trust_auto_answer: own-vs-foreign realpath + fail-safe
 // pane-width + opt-in gate + reason byte-locks. leader_panes.py:383-470.

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

@@ -233,6 +233,11 @@ pub trait ProviderAdapter {
                     transport, target, checks, sleep_s,
                 )
             }
+            Provider::Copilot => {
+                super::startup_prompt::copilot_handle_startup_prompts(
+                    transport, target, checks, sleep_s,
+                )
+            }
             _ => super::startup_prompt::StartupPromptOutcome::default(),
         }))
         .unwrap_or_default()
@@ -869,9 +874,7 @@ impl ProviderAdapter for BasicProviderAdapter {
         match self.provider {
             Provider::Claude | Provider::ClaudeCode => patterns(r"[>❯]\s", r"[✶✢✽✻✳·].*…", r"Error|Traceback"),
             Provider::Codex => patterns(r"(›|❯|codex>)", r"•.*esc to interrupt", r"Error|Traceback|panic"),
-            // C-3-3 cr verdict: copilot 真值待用户真会话样本(§E3 line 105),一期占位
-            // 仅 error 行至少能识别;idle/processing 留 Unknown(N11 守,classify→None)。
-            Provider::Copilot => patterns(r">", r"working|processing", r"Error|panic"),
+            Provider::Copilot => patterns(r"(?m)^\s*❯\s*$| / commands · \? help", r"working|processing", r"Error|panic"),
             Provider::GeminiCli | Provider::Fake => patterns(r">", r"working|processing", r"Error|Traceback"),
         }
     }

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

@@ -28,6 +28,18 @@ const CLAUDE_TRUST_MARKERS: &[&str] = &[
     "Enter to confirm",
 ];
 const CLAUDE_READY_MARKERS: &[&str] = &["Claude Code"];
+pub const COPILOT_TRUST_PROMPT_MARKER: &str =
+    include_str!("testdata/copilot-trust-prompt.txt");
+pub const COPILOT_READY_MARKER: &str =
+    include_str!("testdata/copilot-ready-marker.txt");
+const COPILOT_TRUST_MARKERS: &[&str] = &[COPILOT_TRUST_PROMPT_MARKER];
+const COPILOT_READY_MARKERS: &[&str] = &[COPILOT_READY_MARKER];
+const COPILOT_TRUST_TITLE: &str = "Confirm folder trust";
+const COPILOT_TRUST_QUESTION: &str = "Do you trust the files in this folder?";
+const COPILOT_TRUST_YES_SESSION: &str = "❯ 1. Yes";
+const COPILOT_TRUST_REMEMBER: &str = "2. Yes, and remember this folder for future sessions";
+const COPILOT_TRUST_NO: &str = "3. No (Esc)";
+const COPILOT_READY_FOOTER: &str = " / commands · ? help";
 /// Plain ready markers (not the bare `›` glyph — that glyph also indicates a
 /// numbered-menu selector and is handled by [`rightmost_input_prompt_glyph`] with
 /// shape gating per N15 / CR-063: detect by SHAPE, not a single Unicode codepoint).
@@ -106,6 +118,20 @@ pub fn classify_claude_startup_screen(output: &str) -> StartupScreenDecision {
     }
 }
 
+pub fn classify_copilot_startup_screen(output: &str) -> StartupScreenDecision {
+    let ready_pos = copilot_ready_pos(output);
+    if has_active_copilot_trust_shape(output)
+        && is_more_recent(copilot_trust_pos(output), ready_pos)
+    {
+        return StartupScreenDecision::AnswerWorkspaceTrust;
+    }
+    if ready_pos.is_some() {
+        StartupScreenDecision::Ready
+    } else {
+        StartupScreenDecision::KeepPolling
+    }
+}
+
 /// Actionable trust shape (N15): the captured text contains a trust phrase AND a
 /// numbered-menu selector line `› <digit>. `. This is the modal-still-active signal
 /// that survives Codex's pre-rendering of the banner/input prompt below the menu.
@@ -161,6 +187,53 @@ fn has_claude_ready_shape(output: &str) -> bool {
         && rightmost_claude_input_prompt_glyph(output).is_some()
 }
 
+fn has_active_copilot_trust_shape(output: &str) -> bool {
+    if max_rfind(output, COPILOT_TRUST_MARKERS).is_some() {
+        return true;
+    }
+    [
+        COPILOT_TRUST_TITLE,
+        COPILOT_TRUST_QUESTION,
+        COPILOT_TRUST_YES_SESSION,
+        COPILOT_TRUST_REMEMBER,
+        COPILOT_TRUST_NO,
+    ]
+    .iter()
+    .all(|marker| output.contains(marker))
+}
+
+fn copilot_trust_pos(output: &str) -> Option<usize> {
+    max_two(
+        max_rfind(output, COPILOT_TRUST_MARKERS),
+        max_rfind(output, &[COPILOT_TRUST_TITLE, COPILOT_TRUST_QUESTION]),
+    )
+}
+
+fn copilot_ready_pos(output: &str) -> Option<usize> {
+    let fixture_pos = max_rfind(output, COPILOT_READY_MARKERS);
+    let footer_pos = output.rfind(COPILOT_READY_FOOTER);
+    let prompt_pos = rightmost_copilot_input_prompt_glyph(output);
+    if footer_pos.is_some() && prompt_pos.is_some() {
+        max_two(fixture_pos, max_two(footer_pos, prompt_pos))
+    } else {
+        fixture_pos
+    }
+}
+
+fn rightmost_copilot_input_prompt_glyph(output: &str) -> Option<usize> {
+    let mut best = None;
+    let mut offset = 0;
+    for line in output.split_inclusive('\n') {
+        if line.trim() == "❯" {
+            if let Some(idx) = line.find('❯') {
+                best = Some(offset + idx);
+            }
+        }
+        offset += line.len();
+    }
+    best
+}
+
 fn rightmost_claude_input_prompt_glyph(output: &str) -> Option<usize> {
     let mut best = rightmost_input_prompt_for_glyph(output, '❯');
     best = max_two(best, rightmost_input_prompt_for_glyph(output, '>'));
@@ -316,6 +389,40 @@ pub fn claude_handle_startup_prompts(
     StartupPromptOutcome { handled, capture_error }
 }
 
+pub fn copilot_handle_startup_prompts(
+    transport: &dyn Transport,
+    target: &Target,
+    checks: usize,
+    sleep_s: f64,
+) -> StartupPromptOutcome {
+    let mut handled = Vec::new();
+    let mut capture_error: Option<String> = None;
+    for _ in 0..checks {
+        let screen = match transport.capture(target, CaptureRange::Full) {
+            Ok(captured) => captured.text,
+            Err(error) => {
+                capture_error.get_or_insert_with(|| error.to_string());
+                String::new()
+            }
+        };
+        match classify_copilot_startup_screen(&screen) {
+            StartupScreenDecision::AnswerWorkspaceTrust => {
+                let _ = transport.send_keys(target, &[Key::Enter]);
+                handled.push(HandledPrompt {
+                    prompt: "copilot_workspace_trust".to_string(),
+                    action: "sent_enter_yes_session".to_string(),
+                });
+                sleep_between_polls(sleep_s);
+            }
+            StartupScreenDecision::Ready => break,
+            StartupScreenDecision::SkipUpdatePrompt | StartupScreenDecision::KeepPolling => {
+                sleep_between_polls(sleep_s);
+            }
+        }
+    }
+    StartupPromptOutcome { handled, capture_error }
+}
+
 fn max_rfind(output: &str, needles: &[&str]) -> Option<usize> {
     needles.iter().filter_map(|needle| output.rfind(needle)).max()
 }
@@ -445,6 +552,44 @@ mod tests {
         );
     }
 
+    #[test]
+    fn copilot_trust_fixture_answers_yes_for_this_session() {
+        assert_eq!(
+            classify_copilot_startup_screen(COPILOT_TRUST_PROMPT_MARKER),
+            StartupScreenDecision::AnswerWorkspaceTrust
+        );
+        assert!(
+            COPILOT_TRUST_PROMPT_MARKER.contains(COPILOT_TRUST_YES_SESSION),
+            "copilot trust default must remain option 1, not persistent option 2"
+        );
+    }
+
+    #[test]
+    fn copilot_trust_prompt_tolerates_path_variation() {
+        let dir_b = COPILOT_TRUST_PROMPT_MARKER.replace("/dir-a", "/dir-b");
+        assert_eq!(
+            classify_copilot_startup_screen(&dir_b),
+            StartupScreenDecision::AnswerWorkspaceTrust
+        );
+    }
+
+    #[test]
+    fn copilot_ready_fixture_is_ready_without_trust_prompt() {
+        assert_eq!(
+            classify_copilot_startup_screen(COPILOT_READY_MARKER),
+            StartupScreenDecision::Ready
+        );
+    }
+
+    #[test]
+    fn copilot_ready_after_stale_trust_wins() {
+        let screen = format!("{COPILOT_TRUST_PROMPT_MARKER}\n{COPILOT_READY_MARKER}");
+        assert_eq!(
+            classify_copilot_startup_screen(&screen),
+            StartupScreenDecision::Ready
+        );
+    }
+
     // ── ④ transport.capture() SEAM — the loop answers trust then breaks on ready, via the seam ───────
     /// Scripted transport: `capture` pops the next canned screen; `send_keys` records the keys. All
     /// other methods are unreachable by the startup-prompt loop.
@@ -532,4 +677,32 @@ mod tests {
             "on workspace-trust the loop must send Enter via the transport.capture() seam; got {sent:?}"
         );
     }
+
+    #[test]
+    fn copilot_loop_answers_trust_then_breaks_on_ready_via_capture_seam() {
+        let t = ScriptedTransport {
+            screens: Mutex::new(vec![
+                COPILOT_TRUST_PROMPT_MARKER.to_string(),
+                COPILOT_READY_MARKER.to_string(),
+            ]),
+            sent: Mutex::new(Vec::new()),
+        };
+        let target = Target::Pane(PaneId::new("%1"));
+
+        let handled = copilot_handle_startup_prompts(&t, &target, 5, 0.0).handled;
+
+        assert_eq!(
+            handled,
+            vec![HandledPrompt {
+                prompt: "copilot_workspace_trust".to_string(),
+                action: "sent_enter_yes_session".to_string(),
+            }]
+        );
+        let sent = t.sent.lock().unwrap();
+        assert_eq!(
+            sent.iter().filter(|keys| keys.as_slice() == [Key::Enter]).count(),
+            1,
+            "copilot trust prompt must choose option 1 with one Enter; got {sent:?}"
+        );
+    }
 }

package/crates/team-agent/src/provider/testdata/copilot-ready-marker.txt

@@ -0,0 +1,5 @@
+ /private/tmp/copilot-trust-fixture-20260611T160323Z/dir-a
+────────────────────────────────────────────────────────────────────────────────
+❯
+────────────────────────────────────────────────────────────────────────────────
+ / commands · ? help                                              qwen3.6-local

package/crates/team-agent/src/provider/testdata/copilot-trust-prompt.txt

@@ -0,0 +1,19 @@
+╭──────────────────────────────────────────────────────────────────────────────╮
+│ Confirm folder trust                                                         │
+│ ──────────────────────────────────────────────────────────────────────────── │
+│ ╭──────────────────────────────────────────────────────────────────────────╮ │
+│ │ /private/tmp/copilot-trust-fixture-20260611T160323Z/dir-a                │ │
+│ ╰──────────────────────────────────────────────────────────────────────────╯ │
+│                                                                              │
+│ Copilot can read files in this folder and, with your permission, edit them   │
+│ or run code and shell commands. It will remember your permissions for the    │
+│ rest of this session.                                                        │
+│                                                                              │
+│ Do you trust the files in this folder?                                       │
+│                                                                              │
+│ ❯ 1. Yes                                                                     │
+│   2. Yes, and remember this folder for future sessions                       │
+│   3. No (Esc)                                                                │
+│                                                                              │
+│ ↑/↓ to navigate · enter to select · esc to cancel                            │
+╰──────────────────────────────────────────────────────────────────────────────╯

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

@@ -25,6 +25,7 @@ struct OfflineState {
     targets: Vec<PaneInfo>,
     windows: Vec<WindowName>,
     pane_presence: BTreeMap<String, bool>,
+    spawn_failures: BTreeMap<String, String>,
     spawned_panes_addressable: bool,
     liveness: BTreeMap<String, PaneLiveness>,
     default_liveness: PaneLiveness,
@@ -42,6 +43,7 @@ impl Default for OfflineState {
             targets: Vec::new(),
             windows: Vec::new(),
             pane_presence: BTreeMap::new(),
+            spawn_failures: BTreeMap::new(),
             spawned_panes_addressable: true,
             liveness: BTreeMap::new(),
             default_liveness: PaneLiveness::Unknown,
@@ -102,6 +104,13 @@ impl OfflineTransport {
         self
     }
 
+    pub fn with_spawn_failure(self, window: impl Into<String>, error: impl Into<String>) -> Self {
+        self.with_state(|state| {
+            state.spawn_failures.insert(window.into(), error.into());
+        });
+        self
+    }
+
     pub fn with_spawned_panes_addressable(self, present: bool) -> Self {
         self.with_state(|state| state.spawned_panes_addressable = present);
         self
@@ -149,10 +158,16 @@ impl OfflineTransport {
         session: &SessionName,
         window: &WindowName,
         argv: &[String],
-    ) -> SpawnResult {
+    ) -> Result<SpawnResult, TransportError> {
         let pane_index = self.with_state(|state| {
             state.calls.push(kind);
             state.spawns.push(SpawnRecord { kind: kind.to_string(), argv: argv.to_vec() });
+            if let Some(error) = state.spawn_failures.get(window.as_str()) {
+                return Err(TransportError::Spawn {
+                    backend: BackendKind::Tmux,
+                    source: std::io::Error::other(error.clone()),
+                });
+            }
             if kind == "spawn_first" && !state.session_absent_after_spawn_first {
                 state.session_present = true;
             }
@@ -160,14 +175,14 @@ impl OfflineTransport {
             state
                 .pane_presence
                 .insert(format!("%{pane_index}"), state.spawned_panes_addressable);
-            pane_index
-        });
-        SpawnResult {
+            Ok(pane_index)
+        })?;
+        Ok(SpawnResult {
             pane_id: PaneId::new(format!("%{pane_index}")),
             session: session.clone(),
             window: window.clone(),
             child_pid: None,
-        }
+        })
     }
 
     fn inject_report() -> InjectReport {
@@ -194,7 +209,7 @@ impl Transport for OfflineTransport {
         _cwd: &Path,
         _env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError> {
-        Ok(self.spawn_result("spawn_first", session, window, argv))
+        self.spawn_result("spawn_first", session, window, argv)
     }
 
     fn spawn_into(
@@ -205,7 +220,7 @@ impl Transport for OfflineTransport {
         _cwd: &Path,
         _env: &BTreeMap<String, String>,
     ) -> Result<SpawnResult, TransportError> {
-        Ok(self.spawn_result("spawn_into", session, window, argv))
+        self.spawn_result("spawn_into", session, window, argv)
     }
 
     fn inject(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "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.12",
-    "@team-agent/cli-darwin-x64": "0.3.12",
-    "@team-agent/cli-linux-x64": "0.3.12"
+    "@team-agent/cli-darwin-arm64": "0.3.13",
+    "@team-agent/cli-darwin-x64": "0.3.13",
+    "@team-agent/cli-linux-x64": "0.3.13"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",