@rynx-ai/runtime 0.1.11-beta.2 → 0.1.11-beta.21

package/dist/host.js

@@ -15,6 +15,7 @@ import { CodexAppServerClient, buildRuntimeUserInput, } from "./codex-app-server
 import { buildAppServerBaseArgs, CodexTransportError, } from "./codex-app-server/transport.js";
 import { WsRpcChannel, ExternalWsChannel } from "./codex-app-server/ws-channel.js";
 import { CodexSessionForwarder } from "./codex-app-server/forwarder.js";
+import { readMcpStartupPlan } from "./codex-app-server/mcp-startup.js";
 import { buildCodexRemoteArgs } from "./terminal/codex-tui.js";
 import { buildClaudeTuiArgs } from "./terminal/claude-tui.js";
 import { providerAdditionalDirs, threadWorkspaceParams, turnWorkspaceParams, } from "./provider-workspace.js";
@@ -181,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)
@@ -244,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();
@@ -263,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();
@@ -273,17 +281,18 @@ 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;
         this.sessionStore = sessionStore;
         this.allowedRoots = allowedRoots;
-        this.defaultRuntime = config.AGENT_RUNTIME ?? "codex";
+        this.defaultRuntime = config.DEFAULT_RUNTIME ?? "codex";
         this.injectedCommandRunner = commandRunner;
         this.injectedAppServerClient = appServerClient;
         this.clock = now;
         this.backendIdleTtlMs = backendIdleTtlMs;
+        this.observerReconnectTimeoutMs = observerReconnectTimeoutMs;
         this.forwarderClientFactory =
             forwarderClientFactory ??
                 ((appServerUrl) => new CodexAppServerClient({ channel: new ExternalWsChannel(appServerUrl) }));
@@ -472,6 +481,9 @@ export class LocalAgentHost {
         // to the same effective sandbox.
         const sandbox = live?.sandbox ?? this.sessionSandbox ?? this.config.AGENT_SANDBOX;
         const approvalPolicy = live?.approvalPolicy ?? this.sessionApprovalPolicy ?? this.config.AGENT_APPROVAL_POLICY;
+        const traexYolo = runtime === "traex" &&
+            sandbox === "danger-full-access" &&
+            approvalPolicy === "never";
         const configOverrides = sandbox === "workspace-write"
             ? ["sandbox_workspace_write.network_access=true"]
             : [];
@@ -500,9 +512,11 @@ export class LocalAgentHost {
                 remoteUrl,
                 ...(activeThreadId ? { threadId: activeThreadId } : {}),
                 configOverrides,
+                codexArgs: traexYolo ? ["--dangerously-bypass-hook-trust"] : [],
                 additionalDirs: providerAdditionalDirs(live.workspace),
             }),
             cwd: live.workspace.cwd,
+            ...(runtime === "traex" ? { skipTraexStartupPrompts: true } : {}),
             // Share the app-server's private CODEX_HOME so the TUI inherits the same
             // login/settings and skips the real home's update/NUX prompt. RYNX_SESSION_ID
             // scopes agent-run CLIs (rynx-emulator) to this session at the daemon.
@@ -558,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
@@ -581,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;
             }
@@ -593,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;
         }
@@ -612,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();
         }
@@ -619,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)
         }
@@ -635,15 +655,20 @@ 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();
         }
-        const model = execution.model;
+        const model = execution.model ?? "";
         const reasoningEffort = execution.reasoningEffort ?? undefined;
         let markReady;
         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;
@@ -663,6 +688,8 @@ export class LocalAgentHost {
             threadId: record?.codexSessionId ?? null,
             ready,
             markReady,
+            startupFailed,
+            markStartupFailed,
             terminalReady,
             markTerminalReady,
             injectLock: Promise.resolve(),
@@ -671,6 +698,7 @@ export class LocalAgentHost {
             subscribing: false,
             rotationPending: false,
             stopped: false,
+            observerAvailable: true,
             skillsCleanup: snapshotSkills.skillsCleanup,
             interactionOwners: new Map(),
             interactionStandbys: new Map(),
@@ -704,9 +732,8 @@ export class LocalAgentHost {
                 // `turn/started` land on ONE response instead of splitting into random
                 // ids (the DB `resp_codex_<uuid>` doubling). Mirrors reference implementation `_response_id`.
                 responseId,
-                // Traex intentionally leaves the launch model empty to use its own
-                // config. Canonical/Direct events still require a printable producer
-                // label, so report the runtime when the exact model is unknown.
+                // A null Session model intentionally leaves selection to the Provider
+                // CLI. Canonical events still require a printable label.
                 model: model || runtime,
             });
             return normalizer;
@@ -901,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);
@@ -919,8 +955,59 @@ export class LocalAgentHost {
             }
             live.canonicalInteractions.clear();
         };
+        const completeCurrentTurn = (usage, reason) => {
+            closeCanonicalInteractions();
+            if (!normalizer)
+                return;
+            const completedResponseId = currentResponseId;
+            if (usage) {
+                for (const se of normalizer.next({ type: "turn_completed", usage }))
+                    emitCurrent(se);
+            }
+            for (const se of normalizer.next({ type: "done" })) {
+                if (reason === "superseded" && se.type === "session.status")
+                    continue;
+                emitCurrent(se);
+            }
+            clearPendingInputsForResponse(completedResponseId);
+            normalizer = null;
+            currentResponseId = null;
+        };
+        const failCurrentTurn = (error) => {
+            closeCanonicalInteractions();
+            if (!normalizer)
+                return;
+            const failedResponseId = currentResponseId;
+            const responseStopped = error.message === "Codex turn was interrupted";
+            const providerName = runtime === "traex" ? "Traex" : "Codex";
+            const message = responseStopped
+                ? "Response stopped"
+                : runtime === "traex"
+                    ? error.message.replace(/^Codex\b/, providerName)
+                    : error.message;
+            for (const se of normalizer.fail({
+                code: responseStopped
+                    ? "response_stopped"
+                    : runtime === "traex" ? "traex_error" : "codex_error",
+                message,
+                source: "execution",
+            })) {
+                emitCurrent(se.type === "session.status"
+                    ? { ...se, status: "failed", note: message }
+                    : se);
+            }
+            clearPendingInputsForResponse(failedResponseId);
+            normalizer = null;
+            currentResponseId = null;
+        };
         const sink = {
             onTurnStart: (turnId) => startNormalizer(turnId),
+            onTurnObserved: (turnId) => {
+                const n = startNormalizer(turnId);
+                for (const event of n.next({ type: "turn_started", ...(turnId ? { turnId } : {}) })) {
+                    emitCurrent(event);
+                }
+            },
             onUserMessage: (content) => {
                 const normalizedContent = typeof content === "string"
                     ? [{ type: "input_text", text: content }]
@@ -942,45 +1029,40 @@ export class LocalAgentHost {
                 for (const se of n.next(event))
                     emitCurrent(se);
             },
-            onTurnEnd: (usage) => {
-                closeCanonicalInteractions();
-                if (!normalizer)
-                    return;
-                const completedResponseId = currentResponseId;
-                if (usage) {
-                    for (const se of normalizer.next({ type: "turn_completed", usage }))
-                        emitCurrent(se);
-                }
-                for (const se of normalizer.next({ type: "done" }))
-                    emitCurrent(se);
-                clearPendingInputsForResponse(completedResponseId);
-                normalizer = null;
-                currentResponseId = null;
+            onStatus: (note, statusKind) => {
+                const responseId = currentResponseId ??
+                    live.pendingInjectedInputs.find((entry) => entry.responseId)?.responseId;
+                emitCurrent({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    ...(responseId ? { responseId } : {}),
+                    status: "running",
+                    ...(note ? { note } : {}),
+                    ...(statusKind ? { statusKind } : {}),
+                });
             },
-            onTurnError: (error) => {
-                closeCanonicalInteractions();
-                if (!normalizer)
+            // A newer authoritative turn/started completes the old canonical
+            // response without publishing a false idle edge in a running→running
+            // transition.
+            onTurnEnd: completeCurrentTurn,
+            onRecoveredTurnStatus: (status, turnId, error) => {
+                const responseId = turnId ? `resp_codex_${turnId}` : undefined;
+                if (normalizer && (!responseId || currentResponseId === responseId)) {
+                    if (status === "failed")
+                        failCurrentTurn(error ?? new Error("Codex turn failed"));
+                    else
+                        completeCurrentTurn();
                     return;
-                const failedResponseId = currentResponseId;
-                const responseStopped = error.message === "Codex turn was interrupted";
-                const providerName = runtime === "traex" ? "Traex" : "Codex";
-                const message = responseStopped
-                    ? "Response stopped"
-                    : runtime === "traex"
-                        ? error.message.replace(/^Codex\b/, providerName)
-                        : error.message;
-                for (const se of normalizer.fail({
-                    code: responseStopped
-                        ? "response_stopped"
-                        : runtime === "traex" ? "traex_error" : "codex_error",
-                    message,
-                    source: "execution",
-                }))
-                    emitCurrent(se);
-                clearPendingInputsForResponse(failedResponseId);
-                normalizer = null;
-                currentResponseId = null;
+                }
+                emitCurrent({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    ...(responseId ? { responseId } : {}),
+                    status,
+                    ...(error ? { note: error.message } : {}),
+                });
             },
+            onTurnError: failCurrentTurn,
             // A resumed TUI may rebroadcast `thread/started`; binding is idempotent.
             shouldIgnoreThreadStarted: (threadId, forkedFromId) => this.shouldIgnoreManagedForkThreadStarted(live, threadId, forkedFromId),
             onThreadStarted: (threadId, forkedFromId) => this.onLiveThreadStarted(live, localThreadId, threadId, forkedFromId),
@@ -995,6 +1077,7 @@ export class LocalAgentHost {
             turnCompletionGraceMs: runtime === "traex" ? 150 : 0,
             assistantMessageGraceMs: runtime === "traex" ? 150 : 0,
             surfaceQueueStatus: runtime === "traex",
+            mcpStartup: readMcpStartupPlan(this.runtimeHome(runtime), runtime),
         });
         live.forwarder = forwarder;
         live.onNativeThreadRotated = (threadId, kind) => {
@@ -1068,7 +1151,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;
@@ -1083,11 +1174,25 @@ export class LocalAgentHost {
                     }
                 }
                 if (resumedThreadId) {
+                    forwarder.noteThreadBound(resumedThreadId);
                     this.onLiveThreadStarted(live, localThreadId, resumedThreadId);
                 }
+                else if (resumeError &&
+                    isThreadNotReadyError(resumeError) &&
+                    !record.parentSessionId &&
+                    !record.runtimeHomeOwnerSessionId) {
+                    // A native thread that still has no rollout after the bounded retry
+                    // window has never materialized a Turn. It is safe to forget this
+                    // ordinary binding and let the TUI create a fresh native thread.
+                    // Fork bindings stay strict because their Provider-native ancestry
+                    // must not be silently replaced.
+                    await this.sessionStore.delete(localThreadId);
+                    live.threadId = null;
+                    live.markTerminalReady(true);
+                }
                 else {
-                    // Never replace an existing binding. A delayed native index is
-                    // retryable; a genuinely missing thread remains an explicit error.
+                    // A delayed/missing native index or a fork binding remains explicit:
+                    // neither is proof that replacing Provider history is safe.
                     throw resumeError;
                 }
             }
@@ -1103,9 +1208,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
@@ -1165,30 +1272,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 or publishes the newest explicit
+     * terminal status without replaying 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. An identified active turn is matched
+                // by id; the no-active fallback reads only the final explicit status.
+                const turns = Array.isArray(resp.thread.turns)
+                    ? resp.thread.turns
+                    : [];
+                live.forwarder.reconcileResumeTurns(turns);
                 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) => {
@@ -1200,7 +1314,56 @@ export class LocalAgentHost {
         }
         return false;
     }
-    /** Await a live session's thread binding (bounded). Returns false on timeout /
+    /** 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. */
     async waitLiveReady(localThreadId, timeoutMs = 20_000) {
         const claude = this.liveClaudeSessions.get(localThreadId);
@@ -1209,11 +1372,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 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;
@@ -1230,6 +1397,8 @@ export class LocalAgentHost {
         const live = this.liveSessions.get(localThreadId);
         if (!live)
             return false;
+        if (timeoutMs === null)
+            return live.terminalReady;
         let timer;
         const timeout = new Promise((resolve) => {
             timer = setTimeout(() => resolve(false), timeoutMs);
@@ -1241,7 +1410,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
@@ -1302,7 +1485,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";
@@ -1316,6 +1499,7 @@ export class LocalAgentHost {
                 ...(runtimeInput.responseId ? { responseId: runtimeInput.responseId } : {}),
             };
             live.pendingInjectedInputs.push(pendingInput);
+            let injectionMethod = "turn/start";
             const forgetPendingInput = () => {
                 const index = live.pendingInjectedInputs.indexOf(pendingInput);
                 if (index >= 0)
@@ -1326,6 +1510,7 @@ export class LocalAgentHost {
                 if (live.forwarder.isTurnOpen()) {
                     const turnId = live.forwarder.currentTurnId();
                     if (turnId) {
+                        injectionMethod = "turn/steer";
                         const steered = await live.injectClient.turnSteer({
                             threadId,
                             expectedTurnId: turnId,
@@ -1342,7 +1527,11 @@ export class LocalAgentHost {
                             live.publishInjectedInput(steered.turnId, pendingInput.content);
                             pendingInput.state = "optimistic";
                         }
-                        return "injected";
+                        live.forwarder.noteTurnAccepted(steered.turnId);
+                        if (!live.observerAvailable) {
+                            this.armObserverReconnectDeadline(live);
+                        }
+                        return "steered";
                     }
                 }
                 // Carry the agent-spec model on the turn so a web-injected turn runs the
@@ -1366,13 +1555,22 @@ export class LocalAgentHost {
                     live.publishInjectedInput(started.turnId, pendingInput.content);
                     pendingInput.state = "optimistic";
                 }
+                // The injection RPC and active-turn write are one serialized operation.
+                // 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) {
                 forgetPendingInput();
                 // Preserve the app-server's error instead of collapsing every failure
                 // into the unactionable `live injection failed` string.
-                const detail = codexInjectionError(error);
+                const baseDetail = codexRpcError(error, injectionMethod);
+                const startupDetail = live.forwarder.mcpStartupDetail();
+                const detail = startupDetail ? `${baseDetail} (${startupDetail})` : baseDetail;
                 console.error(`[codex-live] session=${localThreadId} runtime=${live.runtime} injection failed: ${detail}`);
                 throw new Error(detail, { cause: error });
             }
@@ -1417,21 +1615,35 @@ export class LocalAgentHost {
         const live = this.liveSessions.get(localThreadId);
         if (!live)
             return false;
-        // Only interrupt an OPEN turn — codex's app-server rejects a stale turnId, and
-        // reference implementation no-ops (204) when no turn is active.
-        if (!live.forwarder.isTurnOpen())
-            return false;
         const threadId = live.threadId ?? live.forwarder.threadId();
-        const turnId = live.forwarder.currentTurnId();
-        if (!threadId || !turnId)
-            return false;
-        try {
-            await live.injectClient.turnInterrupt({ threadId, turnId });
-            return true;
+        const pendingMcp = live.forwarder.cancelMcpStartup();
+        const turnId = live.forwarder.isTurnOpen()
+            ? live.forwarder.currentTurnId()
+            : null;
+        if (!threadId)
+            return pendingMcp.length > 0;
+        let handled = pendingMcp.length > 0;
+        if (pendingMcp.length > 0) {
+            // Codex's TUI cancels a provider-owned MCP startup round with an empty
+            // turn id. Best-effort for Traex: it shares the app-server surface, while
+            // the active-turn interrupt below remains authoritative if it rejects this.
+            try {
+                await live.injectClient.turnInterrupt({ threadId, turnId: "" });
+            }
+            catch (error) {
+                console.warn(`[codex-live] session=${localThreadId} runtime=${live.runtime} MCP startup interrupt failed: ${codexRpcError(error, "turn/interrupt")}`);
+            }
         }
-        catch {
-            return false;
+        if (turnId) {
+            try {
+                await live.injectClient.turnInterrupt({ threadId, turnId });
+                handled = true;
+            }
+            catch {
+                // The startup cancellation above is still a handled Stop operation.
+            }
         }
+        return handled;
     }
     /** Stop + drop a session's live forwarder and its dedicated connection (session
      *  close / runner shutdown). The backend inject client is shared — left running. */
@@ -1457,6 +1669,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");
@@ -1522,7 +1739,7 @@ export class LocalAgentHost {
         });
         const settings = { ...effectiveSettings, ...hookSettings };
         const settingsPath = writeManagedClaudeSettings(claudeBridgeDir(localThreadId), settings);
-        // The live session carries the immutable execution snapshot used by Chat.
+        // The live session carries the daemon-owned execution state used by Chat.
         const args = buildClaudeTuiArgs({
             settingsJson: settingsPath,
             // A rynx-managed Session must have one interaction owner. Loading host or
@@ -1530,7 +1747,10 @@ export class LocalAgentHost {
             // resolve the same native request while rynx still exposes it as pending.
             // Explicit rynx hooks and selected-skill plugin dirs remain enabled.
             settingSources: "",
-            model: live.execution.model,
+            ...(live.execution.model ? { model: live.execution.model } : {}),
+            ...(live.execution.reasoningEffort
+                ? { reasoningEffort: live.execution.reasoningEffort }
+                : {}),
             ...(live.execution.instructions
                 ? { appendSystemPrompt: live.execution.instructions }
                 : {}),
@@ -1633,8 +1853,16 @@ export class LocalAgentHost {
                 throw failedPluginSkill.reason;
             }
             const pluginSkills = materializedPluginSkills.flatMap((result) => result.status === "fulfilled" ? result.value : []);
+            const selectedSkills = [...skillEnv.resolved, ...pluginSkills];
+            const selectedNames = new Set();
+            for (const skill of selectedSkills) {
+                if (selectedNames.has(skill.name)) {
+                    throw new Error(`duplicate final Session skill name: ${skill.name}`);
+                }
+                selectedNames.add(skill.name);
+            }
             return {
-                selectedSkills: [...skillEnv.resolved, ...pluginSkills],
+                selectedSkills,
                 skillsCleanup: () => rm(sessionSkillsDir, { recursive: true, force: true }),
             };
         }
@@ -1664,7 +1892,7 @@ export class LocalAgentHost {
             console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
             return false;
         }
-        const model = execution.model;
+        const model = execution.model ?? "";
         const skillPlugin = await materializeSkillPlugin(snapshotSkills.selectedSkills);
         void snapshotSkills.skillsCleanup();
         const permissionMode = execution.permissionMode;
@@ -1695,7 +1923,7 @@ export class LocalAgentHost {
             normalizer = new SessionNormalizer({
                 sessionId: currentSessionId,
                 responseId,
-                model,
+                model: model || "claude",
             });
             return normalizer;
         };
@@ -1776,6 +2004,17 @@ export class LocalAgentHost {
                     emitCurrent(se);
             },
             onInteraction: forwardInteraction,
+            onStatus: (status, blockedOn) => {
+                const responseId = currentResponseId ??
+                    live.pendingInjectedInputs.find((entry) => entry.responseId)?.responseId;
+                emitCurrent({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    ...(responseId ? { responseId } : {}),
+                    status,
+                    ...(blockedOn ? { note: blockedOn } : {}),
+                });
+            },
             onTurnEnd: (usage) => {
                 if (!normalizer)
                     return;
@@ -1816,16 +2055,20 @@ export class LocalAgentHost {
                     });
                 }
             },
-            onTurnError: () => {
+            onTurnError: (error) => {
                 if (!normalizer)
                     return;
                 const rid = currentResponseId;
+                const message = error.message || "Agent turn failed";
                 for (const se of normalizer.fail({
                     code: "agent_error",
-                    message: "Agent turn failed",
+                    message,
                     source: "execution",
-                }))
-                    emitCurrent(se);
+                })) {
+                    emitCurrent(se.type === "session.status"
+                        ? { ...se, status: "failed", note: message }
+                        : se);
+                }
                 live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
                 normalizer = null;
                 currentResponseId = undefined;
@@ -1956,7 +2199,8 @@ export class LocalAgentHost {
                 });
                 return ok ? "injected" : "failed";
             }
-            catch {
+            catch (error) {
+                live.error = error instanceof Error ? error.message : String(error);
                 return "failed";
             }
             finally {
@@ -1983,8 +2227,25 @@ export class LocalAgentHost {
      *  (they inject via the app-server). Idempotent. */
     attachTerminalInjector(localThreadId, injector) {
         const live = this.liveClaudeSessions.get(localThreadId);
-        if (live)
+        if (live) {
+            if (live.injector === injector)
+                return;
             live.injector = injector;
+            live.forwarder.attachStatusSource({ panePid: () => injector.panePid?.() });
+        }
+    }
+    /** 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.noteTerminalExit(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) {
@@ -2113,7 +2374,7 @@ export class LocalAgentHost {
                         threadId: record.codexSessionId,
                         excludeTurns: true,
                         ...threadWorkspaceParams(runtime, workspace, execution.sandbox ?? "workspace-write"),
-                        model: execution.model,
+                        ...(execution.model ? { model: execution.model } : {}),
                         approvalPolicy: execution.approvalPolicy,
                     });
                 }
@@ -2155,11 +2416,11 @@ export class LocalAgentHost {
         }
     }
 }
-function codexInjectionError(error) {
+function codexRpcError(error, method) {
     if (error instanceof CodexTransportError) {
-        return `Codex app-server rejected turn/start: ${error.message} (code ${error.code})`;
+        return `Codex app-server rejected ${method}: ${error.message} (code ${error.code})`;
     }
-    return `Codex turn/start failed: ${error instanceof Error ? error.message : String(error)}`;
+    return `Codex ${method} failed: ${error instanceof Error ? error.message : String(error)}`;
 }
 export function parseCodexLoginStatus(exitCode, output) {
     const normalized = output.trim();
@@ -2184,15 +2445,18 @@ export function parseCodexLoginStatus(exitCode, output) {
         issues: normalized ? [normalized] : [],
     };
 }
-/** Race a live session's `ready` promise against failure / timeout. */
+/** Race a live session's `ready` promise against failure and, when supplied,
+ * a timeout. */
 function raceReady(ready, timeoutMs, failed) {
     let timer;
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve(false), timeoutMs);
-    });
-    const outcomes = [ready.then(() => true), timeout];
+    const outcomes = [ready.then(() => true)];
     if (failed)
         outcomes.push(failed.then(() => false));
+    if (timeoutMs !== null) {
+        outcomes.push(new Promise((resolve) => {
+            timer = setTimeout(() => resolve(false), timeoutMs);
+        }));
+    }
     return Promise.race(outcomes).finally(() => {
         if (timer)
             clearTimeout(timer);