@rynx-ai/runtime 0.1.11-beta.19 → 0.1.11-beta.20

package/dist/claude/native-integration.d.ts

@@ -283,6 +283,8 @@ export declare class ClaudeLiveSession {
      *  sent an Escape — an Escape into idle claude submits an empty turn, which
      *  claude answers with a stray "No response requested." bubble. */
     isTurnOpen(): boolean;
+    /** Fail an open turn exactly once when its native terminal/runner disappears. */
+    failOpenTurn(error: Error): boolean;
     private closeTurn;
     private closeTurnError;
     private resetMessageCorrelation;

package/dist/claude/native-integration.js

@@ -1086,6 +1086,13 @@ export class ClaudeLiveSession {
     isTurnOpen() {
         return this.turnOpen;
     }
+    /** Fail an open turn exactly once when its native terminal/runner disappears. */
+    failOpenTurn(error) {
+        if (!this.turnOpen)
+            return false;
+        this.closeTurnError(error);
+        return true;
+    }
     closeTurn() {
         if (!this.turnOpen)
             return;

package/dist/codex-app-server/forwarder.d.ts

@@ -120,6 +120,11 @@ export declare class CodexSessionForwarder {
      * not doubled.
      */
     replayBackfill(turns: ResumedTurn[]): void;
+    /** Reconcile only the exact active turn after an observer resume. Historical
+     * items are intentionally not replayed on an existing-thread reconnect. */
+    reconcileActiveTurn(turn: ResumedTurn | undefined): boolean;
+    /** Fail an open response exactly once when its observer or terminal exits. */
+    failOpenTurn(error: Error): boolean;
     private handle;
     private scheduleCompletion;
     private refreshCompletionGrace;

package/dist/codex-app-server/forwarder.js

@@ -175,6 +175,27 @@ export class CodexSessionForwarder {
                 this.sink.onTurnEnd(mapped.usage);
         }
     }
+    /** Reconcile only the exact active turn after an observer resume. Historical
+     * items are intentionally not replayed on an existing-thread reconnect. */
+    reconcileActiveTurn(turn) {
+        if (!this.turnOpen || !turn || turn.status === "inProgress")
+            return false;
+        const resumedTurnId = turn.id ?? turn.turnId;
+        if (!this.currentTurnIdValue || resumedTurnId !== this.currentTurnIdValue)
+            return false;
+        const mapped = mapCodexNotification("turn/completed", { turn });
+        this.settle(mapped.fatalError
+            ? { kind: "error", error: mapped.fatalError }
+            : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
+        return true;
+    }
+    /** Fail an open response exactly once when its observer or terminal exits. */
+    failOpenTurn(error) {
+        if (!this.turnOpen)
+            return false;
+        this.settle({ kind: "error", error });
+        return true;
+    }
     handle(method, params) {
         if (method === "thread/started" || method === "thread.started") {
             const tid = threadIdFrom(params);

package/dist/codex-app-server/protocol.d.ts

@@ -105,11 +105,14 @@ export interface ThreadStartParams {
 }
 export interface ThreadResumeParams extends ThreadStartParams {
     threadId: string;
-    /** When true, the resume response omits the thread's `turns` backlog (used to
-     *  SUBSCRIBE without re-replaying history). When false/absent, the response
-     *  carries `thread.turns[].items[]` — the backfill the forwarder replays for a
-     *  fresh thread's first turn (reference implementation's `_replay_resume_response`). */
+    /** Legacy whole-backlog suppression. New callers should prefer
+     * `initialTurnsPage` so recovery can fetch one summarized terminal status. */
     excludeTurns?: boolean;
+    initialTurnsPage?: {
+        limit?: number | null;
+        sortDirection?: "asc" | "desc" | null;
+        itemsView?: "notLoaded" | "summary" | "full" | null;
+    } | null;
 }
 /** One turn in a resumed thread's backlog (`thread/resume` response). */
 export interface ResumedTurn {

package/dist/codex-app-server/ws-channel.js

@@ -28,6 +28,7 @@ async function freeLoopbackPort() {
         });
     });
 }
+const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
 export class WsRpcChannel {
     opts;
     child = null;
@@ -40,7 +41,7 @@ export class WsRpcChannel {
     url = "";
     constructor(opts) {
         this.opts = opts;
-        this.readyTimeoutMs = opts.readyTimeoutMs ?? 15_000;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
     }
     onLine(cb) {
         this.lineCb = cb;
@@ -114,7 +115,7 @@ export class WsRpcChannel {
         // eslint-disable-next-line no-constant-condition
         while (Date.now() < deadline) {
             try {
-                return await this.tryConnect(url);
+                return await this.tryConnect(url, Math.max(1, deadline - Date.now()));
             }
             catch (error) {
                 lastError = error;
@@ -123,9 +124,9 @@ export class WsRpcChannel {
         }
         throw new Error(`codex app-server ws did not become ready at ${url}: ${lastError?.message ?? "timeout"}`);
     }
-    tryConnect(url) {
+    tryConnect(url, handshakeTimeout) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
+            const ws = new WebSocket(url, { handshakeTimeout });
             const onOpen = () => {
                 ws.off("error", onError);
                 resolve(ws);
@@ -166,7 +167,7 @@ export class ExternalWsChannel {
     /** The `ws://IP:PORT` of the already-running app-server to attach to. */
     url, opts = {}) {
         this.url = url;
-        this.readyTimeoutMs = opts.readyTimeoutMs ?? 15_000;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
     }
     onLine(cb) {
         this.lineCb = cb;
@@ -178,20 +179,16 @@ export class ExternalWsChannel {
         return this.ws?.readyState === WebSocket.OPEN;
     }
     async start() {
-        const deadline = Date.now() + this.readyTimeoutMs;
-        let lastError;
-        while (Date.now() < deadline) {
-            try {
-                this.ws = await this.connect(this.url);
-                break;
-            }
-            catch (error) {
-                lastError = error;
-                await new Promise((r) => setTimeout(r, 150));
-            }
+        // A channel instance is reusable after an observer disconnect. Do not let
+        // the prior closed socket make a failed reconnect look successful, and arm
+        // close delivery for the newly connected socket.
+        this.ws = null;
+        this.closedEmitted = false;
+        try {
+            this.ws = await this.connect(this.url);
         }
-        if (!this.ws) {
-            throw new Error(`could not attach to app-server ws ${this.url}: ${lastError?.message ?? "timeout"}`);
+        catch (error) {
+            throw new Error(`could not attach to app-server ws ${this.url}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
         this.ws.on("message", (data) => this.lineCb?.(data.toString()));
         this.ws.on("close", (code) => this.emitClose(code ?? null, null, null));
@@ -227,7 +224,10 @@ export class ExternalWsChannel {
     }
     connect(url) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
+            // The app-server owner has already completed its readiness probe. Use one
+            // bounded attach, then reuse this exact connection as the forwarder
+            // instead of running a second startup retry stage.
+            const ws = new WebSocket(url, { handshakeTimeout: this.readyTimeoutMs });
             const onOpen = () => {
                 ws.off("error", onError);
                 resolve(ws);

package/dist/host.d.ts

@@ -125,6 +125,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private readonly clock;
     private readonly backendIdleTtlMs;
     private readonly forwarderClientFactory;
+    private readonly observerReconnectTimeoutMs;
     private readonly backends;
     private readonly sessionId;
     private readonly runtimeHomeSessionId;
@@ -133,6 +134,10 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private readonly runtimeHomes;
     private readonly liveSessions;
     private readonly liveClaudeSessions;
+    /** Exact pre-live startup failure, retained after the partial handle has been
+     * cleaned up so Core/plugin callers receive the failed phase, not a generic
+     * `live session unavailable` wrapper. */
+    private readonly liveStartupErrors;
     /** Claude forwarders stopped before their terminal is killed. Runner shutdown
      * finalizes these synchronously afterwards to scrub raw interaction answers. */
     private readonly pendingClaudeFinalizers;
@@ -141,7 +146,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
     /** Short-lived dedupe for managed fork notifications delivered after the
      * `thread/fork` response. Values are expected source Provider thread ids. */
     private readonly managedForkThreadStarts;
-    constructor({ config, commandRunner, sessionStore, allowedRoots, appServerClient, now, backendIdleTtlMs, forwarderClientFactory, sessionId, runtimeHomeSessionId, }: {
+    constructor({ config, commandRunner, sessionStore, allowedRoots, appServerClient, now, backendIdleTtlMs, forwarderClientFactory, observerReconnectTimeoutMs, sessionId, runtimeHomeSessionId, }: {
         config: AppConfig;
         commandRunner?: CodexCommandRunner;
         sessionStore?: CodexSessionStore;
@@ -153,6 +158,8 @@ export declare class LocalAgentHost implements CodexCapabilities {
         backendIdleTtlMs?: number;
         /** Override the live-session forwarder connection factory (tests inject a fake). */
         forwarderClientFactory?: (appServerUrl: string) => CodexAppServerClient;
+        /** Grace window for observer reconnect before an active response is failed. */
+        observerReconnectTimeoutMs?: number;
         /** The rynx session (localThreadId) this host serves — a per-session runner
          *  child sets it from `RYNX_RUNNER_SESSION` so the private CODEX_HOME is
          *  session-scoped. The shared `__cap__` child / tests fall back to a sentinel
@@ -218,11 +225,16 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * Subscribe the forwarder connection to a thread (reference implementation's
      * `_subscribe_until_ready`). A fresh TUI thread has no rollout until its first
      * turn, so `thread/resume` is retried: park until the forwarder observes the
-     * thread active, then retry WITHOUT `excludeTurns` so the response backfills the
-     * first turn's items (replayed, deduped against the live stream). Once resume
-     * succeeds, subsequent turns arrive as live notifications on this connection.
+     * thread active, then retry. Resume only fetches the newest summarized Turn:
+     * recovery reconciles the exact active Turn's terminal status and never replays
+     * historical items. Once resume succeeds, subsequent turns arrive live.
      */
     private subscribeUntilReady;
+    /** Restore the independent observer after an unexpected exit. The active turn
+     * remains open during the bounded grace so resume can reconcile its exact id. */
+    private reconnectForwarder;
+    private armObserverReconnectDeadline;
+    private clearObserverReconnectDeadline;
     /** Await a live session's thread binding. `null` leaves the deadline to the
      *  caller; a number keeps the Provider-local bound. Returns false on timeout /
      *  no live session. Injection and the runner's `live.ready` gate on this. */
@@ -233,6 +245,10 @@ export declare class LocalAgentHost implements CodexCapabilities {
     waitTerminalReady(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
     /** Diagnostic from the provider adapter when native discovery/resume failed. */
     liveSessionError(localThreadId: string): string | undefined;
+    /** Publish the background TUI/thread discovery failure so an executor
+     * already waiting in the 60s bridge window exits immediately with the exact
+     * 30s discovery cause. */
+    failLiveStartup(localThreadId: string, error: Error): boolean;
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
      * single-writer web send. `turn/steer` when a turn is open (mid-turn
@@ -292,6 +308,8 @@ export declare class LocalAgentHost implements CodexCapabilities {
      *  terminal registry — the host does not hold tmux). Ignored for codex sessions
      *  (they inject via the app-server). Idempotent. */
     attachTerminalInjector(localThreadId: string, injector: TerminalInjector): void;
+    /** Close an active native response when its terminal or runner disappears. */
+    failLiveSession(localThreadId: string, error: Error): boolean;
     /** List the models a runtime exposes (App Server for codex/traex; static for claude). */
     listModels(runtime?: AgentRuntimeId): Promise<ModelListResponse | null>;
     /**

package/dist/host.js

@@ -182,6 +182,8 @@ export class SpawnCodexCommandRunner {
  *  budget (set proactively); claude has no programmatic compaction, so this
  *  signal is the lever consumers surface to the user. */
 const CONTEXT_WARN_RATIO = 0.8;
+/** Wait for native bridge/thread binding before injection gives up. */
+const CODEX_BRIDGE_READY_TIMEOUT_MS = 60_000;
 function providerPluginSkillName(namespace, name) {
     const candidate = `${namespace}-${name}`;
     if (candidate.length <= 128)
@@ -245,6 +247,7 @@ export class LocalAgentHost {
     // multi-connection model). Defaults to an ExternalWsChannel client attached to
     // the backend's app-server; tests inject a fake.
     forwarderClientFactory;
+    observerReconnectTimeoutMs;
     // Keyed by `codexBackendKey` — the bare runtime id for budget-less agents, or
     // a `${runtime}::${retryHash}` composite for a per-agent retry budget.
     backends = new Map();
@@ -264,6 +267,10 @@ export class LocalAgentHost {
     // Per-session claude-native live forwarders (parallel to liveSessions; claude
     // has no app-server, so it tails the bridge + transcript instead of RPC).
     liveClaudeSessions = new Map();
+    /** Exact pre-live startup failure, retained after the partial handle has been
+     * cleaned up so Core/plugin callers receive the failed phase, not a generic
+     * `live session unavailable` wrapper. */
+    liveStartupErrors = new Map();
     /** Claude forwarders stopped before their terminal is killed. Runner shutdown
      * finalizes these synchronously afterwards to scrub raw interaction answers. */
     pendingClaudeFinalizers = new Set();
@@ -274,7 +281,7 @@ export class LocalAgentHost {
     /** Short-lived dedupe for managed fork notifications delivered after the
      * `thread/fork` response. Values are expected source Provider thread ids. */
     managedForkThreadStarts = new Map();
-    constructor({ config, commandRunner, sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(config)), allowedRoots = resolveAllowedRoots(config), appServerClient, now = () => Date.now(), backendIdleTtlMs = 300_000, forwarderClientFactory, sessionId, runtimeHomeSessionId, }) {
+    constructor({ config, commandRunner, sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(config)), allowedRoots = resolveAllowedRoots(config), appServerClient, now = () => Date.now(), backendIdleTtlMs = 300_000, forwarderClientFactory, observerReconnectTimeoutMs = 15_000, sessionId, runtimeHomeSessionId, }) {
         this.config = config;
         this.sessionId = sessionId ?? "__default__";
         this.runtimeHomeSessionId = runtimeHomeSessionId ?? this.sessionId;
@@ -285,6 +292,7 @@ export class LocalAgentHost {
         this.injectedAppServerClient = appServerClient;
         this.clock = now;
         this.backendIdleTtlMs = backendIdleTtlMs;
+        this.observerReconnectTimeoutMs = observerReconnectTimeoutMs;
         this.forwarderClientFactory =
             forwarderClientFactory ??
                 ((appServerUrl) => new CodexAppServerClient({ channel: new ExternalWsChannel(appServerUrl) }));
@@ -564,6 +572,7 @@ export class LocalAgentHost {
         }
     }
     async startLiveCodexSession(localThreadId, emit, opts) {
+        this.liveStartupErrors.delete(localThreadId);
         // cancel-before-recreate (reference implementation Layer 2, runner/app.py `_cancel_auto_forwarder_task`):
         // never run a new forwarder alongside a stale one for this id. ensureLive's has()
         // fast-path normally makes this a no-op; it closes the stop→re-ensure race that
@@ -587,6 +596,7 @@ export class LocalAgentHost {
                 snapshotSkills = await this.prepareExecutionSkills(execution);
             }
             catch (err) {
+                this.liveStartupErrors.set(localThreadId, `${runtime === "traex" ? "Traex" : "Codex"} skill preparation failed: ${err instanceof Error ? err.message : String(err)}`);
                 console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
                 return false;
             }
@@ -599,6 +609,7 @@ export class LocalAgentHost {
         }
         catch (err) {
             void snapshotSkills.skillsCleanup();
+            this.liveStartupErrors.set(localThreadId, `${runtime === "traex" ? "Traex" : "Codex"} skill persistence failed: ${err instanceof Error ? err.message : String(err)}`);
             console.error(`[session-snapshot] session=${localThreadId} skill persistence failed: ${err instanceof Error ? err.message : String(err)}`);
             return false;
         }
@@ -618,6 +629,7 @@ export class LocalAgentHost {
         };
         const injectClient = this.getBackend(runtime, execution.budget ?? undefined).appServerClient;
         if (!injectClient) {
+            this.liveStartupErrors.set(localThreadId, `${runtime === "traex" ? "Traex" : "Codex"} app-server is unavailable for this Session`);
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} no app-server client`);
             return abandon();
         }
@@ -625,11 +637,13 @@ export class LocalAgentHost {
             await injectClient.ensureInitialized();
         }
         catch (err) {
+            this.liveStartupErrors.set(localThreadId, `${runtime === "traex" ? "Traex" : "Codex"} app-server initialization failed during its 10s readiness phase: ${err instanceof Error ? err.message : String(err)}`);
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} app-server init failed: ${err instanceof Error ? err.message : String(err)}`);
             return abandon();
         }
         const appServerUrl = injectClient.terminalRemoteUrl();
         if (!appServerUrl) {
+            this.liveStartupErrors.set(localThreadId, `${runtime === "traex" ? "Traex" : "Codex"} app-server started without a Terminal remote endpoint`);
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} app-server has no remote url`);
             return abandon(); // needs the ws app-server (live-terminal mode)
         }
@@ -641,6 +655,7 @@ export class LocalAgentHost {
             await forwarderClient.ensureInitialized();
         }
         catch (err) {
+            this.liveStartupErrors.set(localThreadId, `${runtime === "traex" ? "Traex" : "Codex"} observer could not attach to the ready app-server: ${err instanceof Error ? err.message : String(err)}`);
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} forwarder init failed: ${err instanceof Error ? err.message : String(err)}`);
             return abandon();
         }
@@ -650,6 +665,10 @@ export class LocalAgentHost {
         const ready = new Promise((resolve) => {
             markReady = resolve;
         });
+        let markStartupFailed;
+        const startupFailed = new Promise((resolve) => {
+            markStartupFailed = resolve;
+        });
         let markTerminalReady;
         const terminalReady = new Promise((resolve) => {
             markTerminalReady = resolve;
@@ -669,6 +688,8 @@ export class LocalAgentHost {
             threadId: record?.codexSessionId ?? null,
             ready,
             markReady,
+            startupFailed,
+            markStartupFailed,
             terminalReady,
             markTerminalReady,
             injectLock: Promise.resolve(),
@@ -677,6 +698,7 @@ export class LocalAgentHost {
             subscribing: false,
             rotationPending: false,
             stopped: false,
+            observerAvailable: true,
             skillsCleanup: snapshotSkills.skillsCleanup,
             interactionOwners: new Map(),
             interactionStandbys: new Map(),
@@ -906,10 +928,19 @@ export class LocalAgentHost {
             });
             client.setConnectionListener((state) => {
                 if (state === "connected") {
-                    live.disconnectedClients.delete(client);
+                    // Observer transport recovery alone does not prove that an in-flight
+                    // interaction request was replayed onto this connection. Its request
+                    // listener clears disconnectedClients when that duplicate arrives.
+                    if (client !== live.forwarderClient)
+                        live.disconnectedClients.delete(client);
                     return;
                 }
                 live.disconnectedClients.add(client);
+                if (client === live.forwarderClient && !live.stopped) {
+                    live.observerAvailable = false;
+                    this.armObserverReconnectDeadline(live);
+                    void this.reconnectForwarder(live);
+                }
                 for (const [interactionId, recovery] of [...live.interactionRecoveries]) {
                     if (allInteractionClientsUnavailable(interactionId)) {
                         finishRecovery(interactionId, recovery.event);
@@ -1086,7 +1117,15 @@ export class LocalAgentHost {
                             threadId: record.codexSessionId,
                             ...threadWorkspaceParams(runtime, workspace, sandbox),
                             approvalPolicy,
+                            // The injection connection only needs to bind/subcribe. Codex
+                            // 0.146 can ignore initialTurnsPage and return the whole rollout,
+                            // so explicitly suppress history here; it is never replayed.
                             excludeTurns: true,
+                            initialTurnsPage: {
+                                limit: 1,
+                                sortDirection: "desc",
+                                itemsView: "summary",
+                            },
                         });
                         resumedThreadId = resumed.threadId;
                         break;
@@ -1134,9 +1173,11 @@ export class LocalAgentHost {
             live.stopped = true;
             forwarder.stop();
             void forwarderClient.stop().catch(() => undefined);
+            this.liveStartupErrors.set(localThreadId, `${runtime === "traex" ? "Traex" : "Codex"} native thread binding failed: ${err instanceof Error ? err.message : String(err)}`);
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} thread bind failed: ${err instanceof Error ? err.message : String(err)}`);
             return abandon();
         }
+        this.liveStartupErrors.delete(localThreadId);
         return true;
     }
     /** Bind a session's codex thread id once known (TUI broadcast or store): persist
@@ -1196,30 +1237,37 @@ export class LocalAgentHost {
      * Subscribe the forwarder connection to a thread (reference implementation's
      * `_subscribe_until_ready`). A fresh TUI thread has no rollout until its first
      * turn, so `thread/resume` is retried: park until the forwarder observes the
-     * thread active, then retry WITHOUT `excludeTurns` so the response backfills the
-     * first turn's items (replayed, deduped against the live stream). Once resume
-     * succeeds, subsequent turns arrive as live notifications on this connection.
+     * thread active, then retry. Resume only fetches the newest summarized Turn:
+     * recovery reconciles the exact active Turn's terminal status and never replays
+     * historical items. Once resume succeeds, subsequent turns arrive live.
      */
     async subscribeUntilReady(live, threadId) {
-        let sawNotReady = false;
         while (!live.stopped) {
             try {
                 const resp = await live.forwarderClient.threadResume({
                     threadId,
                     ...threadWorkspaceParams(live.runtime, live.workspace, live.sandbox),
                     approvalPolicy: live.approvalPolicy,
-                    excludeTurns: !sawNotReady,
+                    initialTurnsPage: {
+                        limit: 1,
+                        sortDirection: "desc",
+                        itemsView: "summary",
+                    },
                 });
-                if (sawNotReady && Array.isArray(resp.thread.turns) && resp.thread.turns.length > 0) {
-                    live.forwarder.replayBackfill(resp.thread.turns);
-                }
+                // Codex 0.146.1 accepts initialTurnsPage but can still return the entire
+                // rollout in chronological order. Never infer newest from array position:
+                // recovery may settle only the exact active turn id already owned here.
+                const activeTurnId = live.forwarder.currentTurnId();
+                const activeTurn = activeTurnId && Array.isArray(resp.thread.turns)
+                    ? resp.thread.turns.find((turn) => (turn.id ?? turn.turnId) === activeTurnId)
+                    : undefined;
+                live.forwarder.reconcileActiveTurn(activeTurn);
                 return true; // subscribed — live item/turn notifications now flow to the forwarder
             }
             catch (error) {
                 if (!isThreadNotReadyError(error)) {
                     return false; // other failure — injection still works via the backend client
                 }
-                sawNotReady = true;
                 // Park until the thread goes active (its first turn materializes the
                 // rollout); a short poll covers the flush race after "active".
                 await new Promise((resolve) => {
@@ -1231,6 +1279,54 @@ export class LocalAgentHost {
         }
         return false;
     }
+    /** Restore the independent observer after an unexpected exit. The active turn
+     * remains open during the bounded grace so resume can reconcile its exact id. */
+    reconnectForwarder(live) {
+        if (live.observerReconnect)
+            return live.observerReconnect;
+        const reconnect = (async () => {
+            while (!live.stopped && live.threadId) {
+                try {
+                    await live.forwarderClient.ensureInitialized();
+                    if (await this.subscribeUntilReady(live, live.threadId)) {
+                        live.observerAvailable = true;
+                        this.clearObserverReconnectDeadline(live);
+                        return;
+                    }
+                }
+                catch {
+                    // Retry below. Injection uses its independent client and remains usable.
+                }
+                await new Promise((resolve) => {
+                    const timer = setTimeout(resolve, 250);
+                    timer.unref?.();
+                });
+            }
+        })();
+        const settled = reconnect.finally(() => {
+            if (live.observerReconnect === settled)
+                live.observerReconnect = undefined;
+        });
+        live.observerReconnect = settled;
+        return settled;
+    }
+    armObserverReconnectDeadline(live) {
+        if (live.observerReconnectTimer || !live.forwarder.isTurnOpen())
+            return;
+        live.observerReconnectTimer = setTimeout(() => {
+            live.observerReconnectTimer = undefined;
+            if (live.stopped)
+                return;
+            const provider = live.runtime === "traex" ? "Traex" : "Codex";
+            live.forwarder.failOpenTurn(new Error(`${provider} observer did not reconnect within ${this.observerReconnectTimeoutMs}ms`));
+        }, this.observerReconnectTimeoutMs);
+        live.observerReconnectTimer.unref?.();
+    }
+    clearObserverReconnectDeadline(live) {
+        if (live.observerReconnectTimer)
+            clearTimeout(live.observerReconnectTimer);
+        live.observerReconnectTimer = undefined;
+    }
     /** Await a live session's thread binding. `null` leaves the deadline to the
      *  caller; a number keeps the Provider-local bound. Returns false on timeout /
      *  no live session. Injection and the runner's `live.ready` gate on this. */
@@ -1241,13 +1337,15 @@ export class LocalAgentHost {
         const live = this.liveSessions.get(localThreadId);
         if (!live)
             return false;
+        const ready = live.ready.then(() => true);
+        const failed = live.startupFailed.then(() => false);
         if (timeoutMs === null)
-            return live.ready.then(() => true);
+            return Promise.race([ready, failed]);
         let timer;
         const timeout = new Promise((resolve) => {
             timer = setTimeout(() => resolve(false), timeoutMs);
         });
-        const ok = await Promise.race([live.ready.then(() => true), timeout]);
+        const ok = await Promise.race([ready, failed, timeout]);
         if (timer)
             clearTimeout(timer);
         return ok;
@@ -1277,7 +1375,21 @@ export class LocalAgentHost {
     }
     /** Diagnostic from the provider adapter when native discovery/resume failed. */
     liveSessionError(localThreadId) {
-        return this.liveClaudeSessions.get(localThreadId)?.error;
+        return this.liveClaudeSessions.get(localThreadId)?.error
+            ?? this.liveSessions.get(localThreadId)?.startupError
+            ?? this.liveStartupErrors.get(localThreadId);
+    }
+    /** Publish the background TUI/thread discovery failure so an executor
+     * already waiting in the 60s bridge window exits immediately with the exact
+     * 30s discovery cause. */
+    failLiveStartup(localThreadId, error) {
+        const live = this.liveSessions.get(localThreadId);
+        if (!live || live.threadId || live.stopped)
+            return false;
+        live.startupError = error.message;
+        this.liveStartupErrors.set(localThreadId, error.message);
+        live.markStartupFailed();
+        return true;
     }
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
@@ -1338,7 +1450,7 @@ export class LocalAgentHost {
                 return "failed";
             // Park until the thread binds (~60s, reference implementation codex_native_executor:177-186),
             // not a 20s race that returns false and lets the caller re-run on a 2nd path.
-            const bound = await this.waitLiveReady(localThreadId, 60_000);
+            const bound = await this.waitLiveReady(localThreadId, CODEX_BRIDGE_READY_TIMEOUT_MS);
             const threadId = live.threadId ?? live.forwarder.threadId();
             if (!bound || !threadId)
                 return "notReady";
@@ -1400,6 +1512,9 @@ export class LocalAgentHost {
                             pendingInput.state = "optimistic";
                         }
                         live.forwarder.noteTurnAccepted(steered.turnId);
+                        if (!live.observerAvailable) {
+                            this.armObserverReconnectDeadline(live);
+                        }
                         return "injected";
                     }
                 }
@@ -1428,6 +1543,9 @@ export class LocalAgentHost {
                 // Do not wait for the independent observer connection's `turn/started`:
                 // a second message accepted in that window must steer, not double-start.
                 live.forwarder.noteTurnAccepted(started.turnId);
+                if (!live.observerAvailable) {
+                    this.armObserverReconnectDeadline(live);
+                }
                 return "injected";
             }
             catch (error) {
@@ -1535,6 +1653,11 @@ export class LocalAgentHost {
             return;
         this.liveSessions.delete(localThreadId);
         live.stopped = true;
+        if (!live.threadId) {
+            live.startupError ??= "native Session stopped before thread discovery completed";
+            live.markStartupFailed();
+        }
+        this.clearObserverReconnectDeadline(live);
         live.releaseActive?.();
         live.injectClient.cancelInteractions("session_stopped");
         live.forwarderClient.cancelInteractions("session_stopped");
@@ -2076,6 +2199,19 @@ export class LocalAgentHost {
         if (live)
             live.injector = injector;
     }
+    /** Close an active native response when its terminal or runner disappears. */
+    failLiveSession(localThreadId, error) {
+        const claude = this.liveClaudeSessions.get(localThreadId);
+        if (claude)
+            return claude.forwarder.failOpenTurn(error);
+        const codex = this.liveSessions.get(localThreadId);
+        if (!codex)
+            return false;
+        const failed = codex.forwarder.failOpenTurn(error);
+        if (failed)
+            this.clearObserverReconnectDeadline(codex);
+        return failed;
+    }
     /** List the models a runtime exposes (App Server for codex/traex; static for claude). */
     async listModels(runtime) {
         const resolved = runtime ?? this.defaultRuntime;

package/dist/runner/child.d.ts

@@ -38,11 +38,13 @@ interface LiveCodexProvider {
         execution: ResolvedExecutionSnapshot;
         retargetMirror?: RetargetMirror;
     }): Promise<boolean>;
-    /** `null` delegates the only deadline to RunnerManager. */
+    /** `null` delegates the deadline to RunnerManager. */
     waitLiveReady?(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
-    /** `null` delegates the only deadline to RunnerManager. */
+    /** `null` delegates the deadline to RunnerManager. */
     waitTerminalReady?(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
     liveSessionError?(localThreadId: string): string | undefined;
+    failLiveStartup?(localThreadId: string, error: Error): boolean;
+    failLiveSession?(localThreadId: string, error: Error): boolean;
     injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
     interruptLive?(localThreadId: string): Promise<boolean>;
     stopLiveCodexSession?(localThreadId: string, opts?: {
@@ -76,6 +78,7 @@ export declare class RunnerSession {
     private readonly attachments;
     private readonly attachmentThreadIds;
     private readonly traexStartupWatchers;
+    private readonly terminalWatchers;
     /** Opens are async; a close received before attach resolves tombstones the id. */
     private readonly pendingTerminalOpens;
     private readonly cancelledTerminalOpens;
@@ -94,18 +97,24 @@ export declare class RunnerSession {
     private mirrorChannel;
     /**
      * Eagerly bring up a session's codex-native live view: start the persistent
-     * forwarder connection (which resume-subscribes to mirror every turn) and
-     * launch the detached `codex --remote resume` TUI against the thread the
-     * structured runtime created. The forwarder subscribes to that same thread,
-     * so the TUI is usable immediately and its turns mirror to chat.
+     * observer connection before launching the detached Codex TUI. Fresh-session
+     * thread discovery then continues in the background while the first
+     * injection waits for the same bridge state.
      */
     private ensureLive;
+    private monitorCodexThreadStartup;
+    /** Discovery failure is terminal for this partial native launch. Publish the
+     * exact cause first so an in-flight injection wakes, then drop the observer
+     * and TUI so a later task retry creates a clean launch instead of reusing an
+     * already-rejected readiness promise. */
+    private failCodexThreadStartup;
     private inject;
     private interruptLive;
     /** Launch (idempotently) the session's codex TUI pane from the executor's
      *  `codexTerminalSpec`. Shares the `${id}-main` terminal id with `term.open`,
      *  so the web attach reuses the same detached pane. */
     private launchCodexPane;
+    private watchNativeTerminal;
     private cancelTraexStartupWatcher;
     private skipTraexStartupPrompts;
     private stopLive;

package/dist/runner/child.js

@@ -1,6 +1,8 @@
 import { TerminalRegistry } from "../terminal/registry.js";
 import { toWireError } from "./protocol.js";
 import { isManagedNativeProvider } from "./startup-policy.js";
+/** Maximum time for a fresh Codex-lineage TUI to publish its native thread. */
+const CODEX_THREAD_START_TIMEOUT_MS = 30_000;
 const TRAEX_STARTUP_WATCH_MS = 20_000;
 const TRAEX_STARTUP_POLL_MS = 100;
 const TRAEX_AUTHORIZATION_POLL_MS = 500;
@@ -30,6 +32,7 @@ export class RunnerSession {
     attachments = new Map();
     attachmentThreadIds = new Map();
     traexStartupWatchers = new Map();
+    terminalWatchers = new Map();
     /** Opens are async; a close received before attach resolves tombstones the id. */
     pendingTerminalOpens = new Set();
     cancelledTerminalOpens = new Set();
@@ -157,10 +160,9 @@ export class RunnerSession {
     }
     /**
      * Eagerly bring up a session's codex-native live view: start the persistent
-     * forwarder connection (which resume-subscribes to mirror every turn) and
-     * launch the detached `codex --remote resume` TUI against the thread the
-     * structured runtime created. The forwarder subscribes to that same thread,
-     * so the TUI is usable immediately and its turns mirror to chat.
+     * observer connection before launching the detached Codex TUI. Fresh-session
+     * thread discovery then continues in the background while the first
+     * injection waits for the same bridge state.
      */
     async ensureLive(msg) {
         const provider = this.liveProvider;
@@ -177,58 +179,59 @@ export class RunnerSession {
                     reqId: msg.reqId,
                     localThreadId: msg.localThreadId,
                     ok: false,
-                    error: "live provider did not start",
+                    error: provider.liveSessionError?.(msg.localThreadId)
+                        ?? "live provider did not start",
                 });
                 return;
             }
             this.liveIds.add(msg.localThreadId);
-            // Native Provider startup has one authoritative parent-side deadline.
-            // Codex and Traex can accept/queue a turn while MCP startup settles;
-            // Claude instead waits for SessionStart before terminal injection. The
-            // historical 20-second gates raced all three valid startup paths.
-            const providerStartupTimeoutMs = isManagedNativeProvider(msg.execution?.provider)
-                ? null
-                : undefined;
+            // Codex-lineage startup is phase-bounded: app-server readiness is
+            // handled by its channel, then the already-connected
+            // observer gets a full window for the TUI's thread/started event.
+            // Claude retains the parent-owned SessionStart deadline.
+            const runtime = msg.execution?.provider;
+            // Do not add another provider-local deadline around resume/preload. The
+            // parent control request remains bounded for process safety; fresh-thread
+            // discovery owns the separate 30s phase below.
+            const terminalReadyTimeoutMs = isManagedNativeProvider(runtime) ? null : undefined;
             // Launch the TUI attached to the already-bound thread. Re-launch when the
             // pane is absent OR its process has died (`isAlive` probes `#{pane_dead}`) — so a
             // reconnect after the TUI exited restarts it instead of skipping (a
             // launched-once guard would leave a dead "Pane is dead" husk forever).
             if (!this.terminals.get(`${msg.localThreadId}-main`)?.isAlive()) {
                 const terminalReady = provider.waitTerminalReady
-                    ? await provider.waitTerminalReady(msg.localThreadId, providerStartupTimeoutMs)
+                    ? await provider.waitTerminalReady(msg.localThreadId, terminalReadyTimeoutMs)
                     : true;
                 if (!terminalReady) {
+                    const providerName = runtime === "traex" ? "Traex" : runtime === "codex" ? "Codex" : "Provider";
                     this.transport.send({
                         t: "live.ready",
                         reqId: msg.reqId,
                         localThreadId: msg.localThreadId,
                         ok: false,
-                        error: "Provider thread was not ready for Terminal resume",
+                        error: runtime === "codex" || runtime === "traex"
+                            ? provider.liveSessionError?.(msg.localThreadId)
+                                ?? `${providerName} app-server was ready, but its existing thread could not be resumed for the Terminal`
+                            : "Provider thread was not ready for Terminal resume",
                     });
                     return;
                 }
                 await this.launchCodexPane(msg.localThreadId, msg.cols, msg.rows);
             }
-            const ready = msg.waitForReady === false
-                ? true
-                : provider.waitLiveReady
-                    ? await provider.waitLiveReady(msg.localThreadId, providerStartupTimeoutMs)
-                    : true;
-            const terminal = this.terminals.get(`${msg.localThreadId}-main`);
-            const paneFailure = !ready && terminal && !terminal.isAlive()
-                ? terminal
-                    .capturePane()
-                    .split("\n")
-                    .map((line) => line.trim())
-                    .filter(Boolean)
-                    .slice(-6)
-                    .join(" ")
-                    .slice(-1_000)
-                : "";
-            const readinessError = provider.liveSessionError?.(msg.localThreadId)
-                ?? (paneFailure
-                    ? `Provider terminal exited before session discovery: ${paneFailure}`
-                    : "live session was not ready before timeout");
+            let ready = true;
+            if (runtime === "codex" || runtime === "traex") {
+                // Discover thread/started in the background for 30s while injection
+                // waits up to 60s for either bridge readiness or that startup error.
+                // Do not serialize the two waits here.
+                this.monitorCodexThreadStartup(msg.localThreadId, runtime, provider);
+            }
+            else if (msg.waitForReady !== false && provider.waitLiveReady) {
+                ready = await provider.waitLiveReady(msg.localThreadId, terminalReadyTimeoutMs);
+            }
+            const readinessError = ready
+                ? undefined
+                : provider.liveSessionError?.(msg.localThreadId)
+                    ?? "live session was not ready before timeout";
             this.transport.send({
                 t: "live.ready",
                 reqId: msg.reqId,
@@ -247,6 +250,53 @@ export class RunnerSession {
             });
         }
     }
+    monitorCodexThreadStartup(localThreadId, runtime, provider) {
+        if (!provider.waitLiveReady)
+            return;
+        void provider.waitLiveReady(localThreadId, CODEX_THREAD_START_TIMEOUT_MS).then((ready) => {
+            if (ready)
+                return;
+            const terminal = this.terminals.get(`${localThreadId}-main`);
+            const paneFailure = terminal && !terminal.isAlive()
+                ? terminal
+                    .capturePane()
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .slice(-6)
+                    .join(" ")
+                    .slice(-1_000)
+                : "";
+            const detail = provider.liveSessionError?.(localThreadId)
+                ?? (paneFailure
+                    ? `Provider terminal exited before session discovery: ${paneFailure}`
+                    : `${runtime === "traex" ? "Traex" : "Codex"} TUI did not publish thread/started within ${CODEX_THREAD_START_TIMEOUT_MS / 1_000}s after app-server and observer readiness`);
+            this.failCodexThreadStartup(localThreadId, provider, new Error(detail));
+        }).catch((error) => {
+            this.failCodexThreadStartup(localThreadId, provider, error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    /** Discovery failure is terminal for this partial native launch. Publish the
+     * exact cause first so an in-flight injection wakes, then drop the observer
+     * and TUI so a later task retry creates a clean launch instead of reusing an
+     * already-rejected readiness promise. */
+    failCodexThreadStartup(localThreadId, provider, error) {
+        if (!provider.failLiveStartup?.(localThreadId, error))
+            return;
+        const watcher = this.terminalWatchers.get(localThreadId);
+        if (watcher)
+            clearInterval(watcher);
+        this.terminalWatchers.delete(localThreadId);
+        this.cancelTraexStartupWatcher(localThreadId);
+        try {
+            this.terminals.close(`${localThreadId}-main`);
+        }
+        catch (closeError) {
+            console.warn(`[runner] session=${localThreadId} failed to close native Terminal after startup failure: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
+        }
+        provider.stopLiveCodexSession?.(localThreadId);
+        this.liveIds.delete(localThreadId);
+    }
     async inject(msg) {
         const provider = this.liveProvider;
         try {
@@ -254,7 +304,16 @@ export class RunnerSession {
             const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
             // App-server injection is independent of the Terminal TUI startup, so it
             // must not cancel prompt handling for the pane that is still starting.
-            this.transport.send({ t: "injected", reqId: msg.reqId, localThreadId: msg.localThreadId, outcome });
+            const error = outcome === "injected"
+                ? undefined
+                : provider.liveSessionError?.(msg.localThreadId);
+            this.transport.send({
+                t: "injected",
+                reqId: msg.reqId,
+                localThreadId: msg.localThreadId,
+                outcome,
+                ...(error ? { error } : {}),
+            });
         }
         catch (error) {
             this.transport.send({
@@ -306,6 +365,32 @@ export class RunnerSession {
             void this.skipTraexStartupPrompts(localThreadId, term, watcher);
         }
         this.liveProvider.attachTerminalInjector?.(localThreadId, term);
+        this.watchNativeTerminal(localThreadId, terminalId, term);
+    }
+    watchNativeTerminal(localThreadId, terminalId, terminal) {
+        const previous = this.terminalWatchers.get(localThreadId);
+        if (previous)
+            clearInterval(previous);
+        let checking = false;
+        const timer = setInterval(() => {
+            if (checking || this.shuttingDown || this.terminals.get(terminalId) !== terminal)
+                return;
+            checking = true;
+            const probe = terminal.isAliveAsync?.() ?? Promise.resolve(terminal.isAlive());
+            void probe.then((alive) => {
+                if (alive || this.shuttingDown || this.terminals.get(terminalId) !== terminal)
+                    return;
+                clearInterval(timer);
+                this.terminalWatchers.delete(localThreadId);
+                this.cancelTraexStartupWatcher(localThreadId);
+                this.liveProvider.failLiveSession?.(localThreadId, new Error("Provider terminal exited unexpectedly"));
+                this.failCodexThreadStartup(localThreadId, this.liveProvider, new Error("Provider terminal exited before native thread discovery completed"));
+            }).finally(() => {
+                checking = false;
+            });
+        }, 1_000);
+        timer.unref?.();
+        this.terminalWatchers.set(localThreadId, timer);
     }
     cancelTraexStartupWatcher(localThreadId) {
         if (localThreadId)
@@ -375,6 +460,9 @@ export class RunnerSession {
         }
     }
     stopLive() {
+        for (const timer of this.terminalWatchers.values())
+            clearInterval(timer);
+        this.terminalWatchers.clear();
         for (const id of this.liveIds) {
             this.liveProvider.stopLiveCodexSession?.(id, {
                 deferClaudeInteractionCleanup: true,

package/dist/runner/manager.d.ts

@@ -56,9 +56,8 @@ export interface RunnerManagerOptions {
     liveStartTimeoutMs?: number;
     /** Max wait for a Provider-native thread to become ready. */
     liveReadyTimeoutMs?: number;
-    /** End-to-end native readiness deadline for message delivery. The runner
-     * child delegates its Provider-local gates to this single timeout. Setup-pane
-     * requests keep the shorter `liveStartTimeoutMs`. */
+    /** Claude SessionStart deadline. Codex/Traex use `liveStartTimeoutMs` for the
+     * pane/observer acknowledgement; their thread discovery is asynchronous. */
     nativeLiveStartTimeoutMs?: number;
     /** Max wait for a native interrupt acknowledgement before reporting it
      * unproven. Callers may then use the explicit force-stop path. */
@@ -236,8 +235,9 @@ export declare class RunnerManager implements AgentCapabilities {
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if
-     * needed. Idempotent. Resolves true once the codex thread is bound; false for a
-     * non-codex / non-live session (the caller then uses the normal run path).
+     * needed. Idempotent. For Codex-lineage fresh sessions, resolves after the
+     * app-server/observer and pane are launched; thread discovery continues in
+     * parallel with injection. Other providers retain their readiness gate.
      */
     ensureLiveSession(localThreadId: string, opts: {
         workspace: SessionWorkspaceSnapshot;
@@ -326,6 +326,7 @@ export declare class RunnerManager implements AgentCapabilities {
      * terminateHandle immediately afterwards, so these are the final events for
      * the abandoned responses. */
     private failStaleActiveResponses;
+    private failActiveResponses;
     /** Track only response lifecycle, not output volume. Output deltas from a
      * runaway TUI/Provider must not refresh the stale-active deadline. */
     private observeHandleRuntimeEvent;

package/dist/runner/manager.js

@@ -34,13 +34,15 @@ const STDERR_TAIL_LINES = 40;
 const DEFAULT_SHUTDOWN_GRACE_MS = 5_000;
 /** Time allowed for exit after SIGKILL before shutdown reports failure. */
 const DEFAULT_SHUTDOWN_KILL_GRACE_MS = 5_000;
-/** Setup-pane launch should acknowledge quickly; never pin its HTTP request. */
-const DEFAULT_LIVE_START_TIMEOUT_MS = 10_000;
+/** Setup-pane launch includes the app-server readiness phase but does not wait
+ * for native thread discovery. Keep enough headroom around the app-server's
+ * own 10s gate so scheduling/IPC overhead cannot win the same deadline. */
+const DEFAULT_LIVE_START_TIMEOUT_MS = 30_000;
 /** Legacy fallback for a provider without a native startup policy. */
 const DEFAULT_LIVE_READY_TIMEOUT_MS = 25_000;
-/** Native CLIs can spend tens of seconds in provider-owned startup (MCP
- * degradation for Codex/Traex; terminal + SessionStart discovery for Claude).
- * Keep one outer deadline instead of racing it with child-local gates. */
+/** Claude has no app-server bridge and keeps a parent-owned SessionStart
+ * deadline. Codex-lineage startup instead acknowledges pane/observer startup
+ * and lets thread discovery race injection. */
 const DEFAULT_NATIVE_LIVE_START_TIMEOUT_MS = 60_000;
 /** A submitted TUI command should become a mirrored turn or native rotation
  * quickly. If it does not, the runner is fenced by a verified process-tree
@@ -500,8 +502,9 @@ export class RunnerManager {
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if
-     * needed. Idempotent. Resolves true once the codex thread is bound; false for a
-     * non-codex / non-live session (the caller then uses the normal run path).
+     * needed. Idempotent. For Codex-lineage fresh sessions, resolves after the
+     * app-server/observer and pane are launched; thread discovery continues in
+     * parallel with injection. Other providers retain their readiness gate.
      */
     ensureLiveSession(localThreadId, opts) {
         const admission = this.reserveAdmission();
@@ -542,14 +545,23 @@ export class RunnerManager {
         return new Promise((resolve) => {
             const timeoutMs = !waitForReady
                 ? this.liveStartTimeoutMs
-                : isManagedNativeProvider(opts.execution.provider)
+                : opts.execution.provider === "claude"
                     ? this.nativeLiveStartTimeoutMs
-                    : this.liveReadyTimeoutMs;
+                    : isManagedNativeProvider(opts.execution.provider)
+                        ? this.liveStartTimeoutMs
+                        : this.liveReadyTimeoutMs;
             const timeout = setTimeout(() => {
                 if (!handle.live.delete(reqId))
                     return;
                 const finishTimeout = () => {
-                    const reason = `runner did not acknowledge ${waitForReady ? "live readiness" : "terminal start"} within ${timeoutMs}ms`;
+                    const provider = opts.execution.provider;
+                    const reason = !waitForReady
+                        ? `runner did not acknowledge terminal start within ${timeoutMs}ms`
+                        : provider === "claude"
+                            ? `Claude SessionStart was not observed within ${Math.round(timeoutMs / 1_000)}s; the runner process was reset before retry`
+                            : provider === "codex" || provider === "traex"
+                                ? `${provider === "traex" ? "Traex" : "Codex"} app-server/observer/Terminal launch was not acknowledged within ${Math.round(timeoutMs / 1_000)}s; the runner process was reset before retry`
+                                : `runner did not acknowledge live readiness within ${timeoutMs}ms`;
                     this.liveErrors.set(localThreadId, reason);
                     this.liveSessionKeys.delete(localThreadId);
                     // A child that cannot answer a bounded control round-trip is unsafe
@@ -1270,7 +1282,7 @@ export class RunnerManager {
         }
     }
     /** Mark a handle dead and reject every pending run/cap with the exit reason. */
-    failHandle(handle, reason) {
+    failHandle(handle, reason, opts = {}) {
         if (handle.dead) {
             return;
         }
@@ -1289,6 +1301,9 @@ export class RunnerManager {
         }
         const tail = handle.stderr.join("\n");
         const message = tail ? `${reason}\n--- runner log tail ---\n${tail}` : reason;
+        if (opts.failActiveResponses !== false) {
+            this.failActiveResponses(handle, "runner_crashed", message);
+        }
         const error = new AgentRuntimeError(message, 500, "runner_crashed");
         for (const pending of handle.caps.values()) {
             pending.reject(error);
@@ -1319,7 +1334,7 @@ export class RunnerManager {
                 catch {
                     // The process signal below remains the authoritative shutdown path.
                 }
-                this.failHandle(handle, reason);
+                this.failHandle(handle, reason, { failActiveResponses: false });
             }
             this.signalChild(handle.child, "SIGTERM", handle.processGroup);
             let childExited = await waitForChildExit(handle.completion, this.shutdownGraceMs);
@@ -1385,6 +1400,9 @@ export class RunnerManager {
      * terminateHandle immediately afterwards, so these are the final events for
      * the abandoned responses. */
     failStaleActiveResponses(handle, idleForMs) {
+        this.failActiveResponses(handle, "stale_runner_reaped", `Runner was reaped after ${Math.floor(idleForMs / 1000)}s without user activity`);
+    }
+    failActiveResponses(handle, code, message) {
         const responseIds = [...handle.activeResponseIds];
         handle.activeResponseIds.clear();
         const sessionId = this.currentTerminalSessionId(handle, handle.key);
@@ -1394,8 +1412,8 @@ export class RunnerManager {
                 responseId,
                 error: {
                     source: "execution",
-                    code: "stale_runner_reaped",
-                    message: `Runner was reaped after ${Math.floor(idleForMs / 1000)}s without user activity`,
+                    code,
+                    message,
                 },
             });
         }

package/dist/runner/protocol.d.ts

@@ -70,8 +70,9 @@ export type ToChild = {
 }
 /** Eagerly bring up a session's live codex TUI + forwarder (codex-native), so
  *  its turns mirror to the bus regardless of whether the web has attached the
- *  terminal. Idempotent; the child replies `live.ready` (echoing `reqId`) once
- *  the thread is bound. */
+ *  terminal. For Codex-lineage fresh sessions, `live.ready` acknowledges that
+ *  the pane and observer exist; background thread discovery races the
+ *  executor's bridge wait. */
  | {
     t: "live.ensure";
     reqId: string;
@@ -160,8 +161,9 @@ export type FromChild = {
     execution: ResolvedExecutionSnapshot;
     parentSessionId?: string;
 }
-/** Result of a `live.ensure`: `ok` once the requested gate is reached (pane
- *  started for setup, otherwise native thread bound). Echoes `reqId`. */
+/** Result of a `live.ensure`: for Codex-lineage sessions `ok` means the pane
+ *  and observer started; thread discovery continues in parallel with
+ *  injection. Other Providers retain their own readiness gate. */
  | {
     t: "live.ready";
     reqId: string;

package/dist/terminal/tmux.d.ts

@@ -112,7 +112,7 @@ export declare class TmuxTerminal {
      *  there stalls the runner child's event loop (freezing the PTY stream → the
      *  terminal appears "stuck"). reference implementation's `_tmux_session_alive` uses an async
      *  subprocess + timeout for exactly this reason. */
-    private isAliveAsync;
+    isAliveAsync(): Promise<boolean>;
     /** Type literal text into the pane (agent injection / co-drive from a
      *  non-PTY caller). `-l` sends the text literally rather than as key names. */
     sendKeys(text: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.19",
+  "version": "0.1.11-beta.20",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -27,7 +27,7 @@
     "node-pty": "1.2.0-beta.15",
     "smol-toml": "1.7.1",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.19"
+    "@rynx-ai/core": "0.1.11-beta.20"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"