@rynx-ai/runtime 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/host.js

@@ -4,29 +4,54 @@ import { cp, mkdir, mkdtemp, realpath, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import readline from "node:readline";
-import { buildAgentSkillEnvironment, hashPluginPackageTree, scanSkillsDir, SessionNormalizer, } from "@rynx-ai/core";
+import { buildAgentSkillEnvironment, hashPluginPackageTree, scanSkillsDir, SessionNormalizer, newSessionItemId, } from "@rynx-ai/core";
 import { getRuntimeProfile, } from "@rynx-ai/core";
 import { resolveRuntimeBinary, } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
-import { prepareRuntimeHome, populateCodexSkills, runtimeHomePath, } from "./codex-home.js";
-import { materializeSkillPlugin } from "./claude/executor.js";
+import { applyCodexProviderRetryPolicy, codexLaunchRequiresLogin, prepareRuntimeHome, populateCodexSkills, readCodexDeveloperInstructionsState, runtimeHomePath, syncCodexDeveloperInstructions, trustCodexProject, } from "./codex-home.js";
+import { materializeClaudePlugin, reuseClaudePlugin, } from "./claude/executor.js";
 import { listClaudeModels } from "./claude/models.js";
+import { validateInteractionResolution } from "./interactions.js";
 import { CodexAppServerClient, buildRuntimeUserInput, } from "./codex-app-server/client.js";
 import { buildAppServerBaseArgs, CodexTransportError, } from "./codex-app-server/transport.js";
 import { WsRpcChannel, ExternalWsChannel } from "./codex-app-server/ws-channel.js";
+import { reapRuntimeProcessesForStateDir } from "./codex-app-server/process-registry.js";
 import { CodexSessionForwarder } from "./codex-app-server/forwarder.js";
+import { readMcpStartupPlan } from "./codex-app-server/mcp-startup.js";
+import { runtimeSessionStateDir } from "./runtime-state-paths.js";
 import { buildCodexRemoteArgs } from "./terminal/codex-tui.js";
 import { buildClaudeTuiArgs } from "./terminal/claude-tui.js";
 import { providerAdditionalDirs, threadWorkspaceParams, turnWorkspaceParams, } from "./provider-workspace.js";
 import { ensureProjectTrusted } from "./claude/trust.js";
 import { claudeAttachmentToken, claudeInputText, runtimeUserContent, } from "./input-resources.js";
-import { claudeBridgeDir, prepareClaudeBridgeDir, removeManagedClaudeSettings, writeManagedClaudeSettings, } from "./claude/native-bridge.js";
+import { prepareClaudeBridgeDir, removeManagedClaudeSettings, writeManagedClaudeSettings, } from "./claude/native-bridge.js";
 import { ClaudeLiveSession, injectViaTerminal, } from "./claude/native-integration.js";
 import { buildClaudeHookSettings } from "./claude/native-hooks.js";
 import { buildManagedClaudeSettings } from "./claude/settings.js";
 import { FileCodexSessionStore, resolveCodexSessionStorePath, } from "./codex-session-store.js";
 import { AgentRuntimeError as CodexRuntimeError } from "@rynx-ai/core";
 import { newSessionId as makeSessionId } from "@rynx-ai/core";
+function isDurableSessionEvent(event) {
+    return event.type === "response.output_item.done" ||
+        event.type === "session.input.consumed" ||
+        event.type === "session.interaction.requested" ||
+        event.type === "session.interaction.resolved" ||
+        event.type === "session.interaction.cancelled";
+}
+/**
+ * Events produced while a native Provider is crossing a logical Session
+ * rotation are normalized before the new Rynx id is known. Re-stamp both the
+ * envelope and any durable item before releasing that buffer into the target.
+ */
+function retargetSessionEvent(event, sessionId) {
+    const retargeted = structuredClone(event);
+    if (typeof retargeted.sessionId === "string")
+        retargeted.sessionId = sessionId;
+    if (retargeted.item && typeof retargeted.item.sessionId === "string") {
+        retargeted.item.sessionId = sessionId;
+    }
+    return retargeted;
+}
 import { resolveAllowedRoots, } from "@rynx-ai/core";
 export { FileCodexSessionStore, resolveCodexSessionStorePath, };
 // The runtime error type lives in @rynx-ai/core (as AgentRuntimeError) so channels
@@ -181,6 +206,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)
@@ -189,44 +216,85 @@ function providerPluginSkillName(namespace, name) {
     return `${namespace.slice(0, 48)}-${name.slice(0, 65)}-${digest}`;
 }
 const MAX_CODEX_SETTLED_INTERACTIONS = 512;
-/**
- * The `OPENAI_*` retry env for a codex-lineage app-server spawn, or `undefined`
- * when the budget declares no retry or the runtime is claude. claude applies
- * its retry budget per-run in `buildOptions` (see the claude executor), so it
- * never needs a dedicated app-server.
- */
-export function codexRetryEnv(runtime, budget) {
-    if (runtime === "claude") {
-        return undefined;
-    }
-    const retry = budget?.retry;
-    if (!retry) {
-        return undefined;
-    }
-    const env = {};
-    if (retry.maxRetries != null) {
-        env.OPENAI_MAX_RETRIES = String(retry.maxRetries);
-    }
-    if (retry.timeoutPerRequestSeconds != null) {
-        env.OPENAI_TIMEOUT = String(Math.round(retry.timeoutPerRequestSeconds));
-    }
-    return Object.keys(env).length > 0 ? env : undefined;
+const CODEX_PLAN_IMPLEMENTATION_YES = "Yes, implement this plan";
+const CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT = "Yes, clear context and implement";
+const CODEX_PLAN_IMPLEMENTATION_NO = "No, stay in Plan mode";
+const CODEX_PLAN_IMPLEMENTATION_CODING_MESSAGE = "Implement the plan.";
+const CODEX_PLAN_PROMPT_DISMISS_TIMEOUT_MS = 1_500;
+const CODEX_PLAN_PROMPT_DISMISS_POLL_MS = 50;
+const CODEX_SUBSCRIBE_FLUSH_RETRY_MS = 1_500;
+const CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT_PREFIX = "A previous agent produced the plan below to accomplish the user's task. " +
+    "Implement the plan in a fresh context. Treat the plan as the source of " +
+    "user intent, re-read files as needed, and carry the work through " +
+    "implementation and verification.";
+function codexPlanImplementationRequest(interactionId) {
+    return {
+        interactionId,
+        kind: "question",
+        title: "Plan",
+        fields: [{
+                id: "plan_implementation",
+                type: "select",
+                label: "Implement this plan?",
+                required: true,
+                options: [
+                    {
+                        value: CODEX_PLAN_IMPLEMENTATION_YES,
+                        label: CODEX_PLAN_IMPLEMENTATION_YES,
+                        description: "Switch to Default and start coding.",
+                    },
+                    {
+                        value: CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT,
+                        label: CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT,
+                        description: "Fresh thread with this plan.",
+                    },
+                    {
+                        value: CODEX_PLAN_IMPLEMENTATION_NO,
+                        label: CODEX_PLAN_IMPLEMENTATION_NO,
+                        description: "Continue planning with the model.",
+                    },
+                ],
+            }],
+        actions: [{ id: "submit", label: "Submit", style: "primary", requiresAnswers: true }],
+        createdAt: Date.now(),
+    };
 }
-/**
- * The cache key for a runtime backend. A retry budget on a codex-lineage
- * runtime forks a dedicated app-server (its own retry env) under a composite
- * `${runtime}::${hash}` key; everything else shares the base `${runtime}`
- * backend — so budget-less agents keep today's shared-process behaviour.
- */
-function hashRetryEnv(env) {
-    return Object.keys(env)
-        .sort()
-        .map((key) => `${key}=${env[key]}`)
-        .join("&");
+function codexPlanImplementationPromptVisible(pane) {
+    return pane.includes("Implement this plan?") &&
+        pane.includes(CODEX_PLAN_IMPLEMENTATION_YES) &&
+        pane.includes(CODEX_PLAN_IMPLEMENTATION_NO);
 }
-export function codexBackendKey(runtime, budget) {
-    const env = codexRetryEnv(runtime, budget);
-    return env ? `${runtime}::${hashRetryEnv(env)}` : runtime;
+/** Codex's final Plan picker is owned by the TUI and is not an app-server
+ * request that Web can resolve. Once the synthetic Web form takes ownership,
+ * close only that exact picker with its documented Escape action. The owner
+ * predicate is checked both before and after capture: app-server notifications
+ * cannot interleave between the two synchronous tmux calls, so a newly observed
+ * Turn cannot receive a blind Escape. This is deliberately best-effort — a
+ * cosmetic Terminal redraw failure must not make an otherwise valid Web Plan
+ * decision fail when the structured app-server path can still proceed. */
+async function dismissCodexPlanImplementationPrompt(injector, ownsPrompt) {
+    if (!injector || !ownsPrompt())
+        return "not_visible";
+    try {
+        const pane = injector.capturePane();
+        if (!ownsPrompt())
+            return "superseded";
+        if (!codexPlanImplementationPromptVisible(pane))
+            return "not_visible";
+        injector.interrupt();
+        const deadline = Date.now() + CODEX_PLAN_PROMPT_DISMISS_TIMEOUT_MS;
+        while (ownsPrompt()) {
+            if (!codexPlanImplementationPromptVisible(injector.capturePane()))
+                return "dismissed";
+            if (Date.now() >= deadline)
+                return "failed";
+            await new Promise((resolve) => setTimeout(resolve, CODEX_PLAN_PROMPT_DISMISS_POLL_MS));
+        }
+        return "superseded";
+    }
+    catch {
+        return "failed";
+    }
 }
 export class LocalAgentHost {
     config;
@@ -238,14 +306,19 @@ export class LocalAgentHost {
     // auto-create. The command runner override backs the status probe.
     injectedCommandRunner;
     injectedAppServerClient;
-    clock;
-    backendIdleTtlMs;
     // Builds the SEPARATE forwarder connection for a live codex session (reference implementation's
     // multi-connection model). Defaults to an ExternalWsChannel client attached to
     // the backend's app-server; tests inject a fake.
     forwarderClientFactory;
-    // Keyed by `codexBackendKey` — the bare runtime id for budget-less agents, or
-    // a `${runtime}::${retryHash}` composite for a per-agent retry budget.
+    // Builds reference implementation's short-lived cold-resume preload connection. This must be
+    // distinct from both the app-server owner/injector and the background
+    // observer: the owner's initialize handshake is the readiness probe, then a
+    // freshly initialized connection performs the one resume and closes.
+    preloadClientFactory;
+    /** Builds one short-lived message/interrupt client. */
+    injectionClientFactory;
+    // One backend per runtime. The host belongs to one Session runner, and Codex
+    // retry settings live in that Session's private config rather than process env.
     backends = new Map();
     // The rynx Session this host serves (set from `RYNX_RUNNER_SESSION`).
     sessionId;
@@ -263,9 +336,14 @@ 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();
+    pendingCleanupTasks = new Set();
     // In-flight `ensureLiveCodexSession` calls, so concurrent triggers (a web
     // `live.ensure` racing a `term.open`) share ONE forwarder — never two.
     liveEnsuring = new Map();
@@ -273,7 +351,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, forwarderClientFactory, preloadClientFactory, injectionClientFactory, sessionId, runtimeHomeSessionId, }) {
         this.config = config;
         this.sessionId = sessionId ?? "__default__";
         this.runtimeHomeSessionId = runtimeHomeSessionId ?? this.sessionId;
@@ -282,61 +360,22 @@ export class LocalAgentHost {
         this.defaultRuntime = config.DEFAULT_RUNTIME ?? "codex";
         this.injectedCommandRunner = commandRunner;
         this.injectedAppServerClient = appServerClient;
-        this.clock = now;
-        this.backendIdleTtlMs = backendIdleTtlMs;
-        this.forwarderClientFactory =
-            forwarderClientFactory ??
-                ((appServerUrl) => new CodexAppServerClient({ channel: new ExternalWsChannel(appServerUrl) }));
-    }
-    getBackend(runtime, budget) {
-        this.reapIdleBackends();
-        // In forced exec mode (the default runtime's injected app-server is null) a
-        // retry budget must NOT fork a composite backend: there is no app-server to
-        // carry the retry env, and forking one would spawn a real app-server and
-        // defeat the forced-exec override. Fall back to the base key — codex retry is
-        // then a no-op in exec mode (consistent with the broader codex-retry caveat).
-        const execMode = runtime === this.defaultRuntime && this.injectedAppServerClient === null;
-        const retryEnv = execMode ? undefined : codexRetryEnv(runtime, budget);
-        const key = retryEnv ? `${runtime}::${hashRetryEnv(retryEnv)}` : runtime;
-        const existing = this.backends.get(key);
-        if (existing) {
-            existing.lastUsedAt = this.clock();
+        const defaultAttachedClientFactory = (appServerUrl) => new CodexAppServerClient({ channel: new ExternalWsChannel(appServerUrl) });
+        this.forwarderClientFactory = forwarderClientFactory ?? defaultAttachedClientFactory;
+        this.preloadClientFactory = preloadClientFactory ?? defaultAttachedClientFactory;
+        this.injectionClientFactory = injectionClientFactory ?? defaultAttachedClientFactory;
+    }
+    getBackend(runtime) {
+        const existing = this.backends.get(runtime);
+        if (existing)
             return existing;
-        }
-        const backend = this.createBackend(runtime, retryEnv);
-        backend.lastUsedAt = this.clock();
-        this.backends.set(key, backend);
+        const backend = this.createBackend(runtime);
+        this.backends.set(runtime, backend);
         return backend;
     }
-    /**
-     * Stop + drop per-budget composite backends that have been idle longer than
-     * the TTL and have no in-flight run. Base per-runtime backends (key === the
-     * bare runtime id) are never reaped — they live for the process lifetime, as
-     * before. There are no per-conversation close hooks, so this lazy sweep (run
-     * on every `getBackend`) is how dedicated app-servers get reclaimed.
-     */
-    reapIdleBackends() {
-        const now = this.clock();
-        for (const [key, backend] of this.backends) {
-            if (!key.includes("::")) {
-                continue;
-            }
-            if ((backend.inFlight ?? 0) > 0 || backend.lastUsedAt === undefined) {
-                continue;
-            }
-            if (now - backend.lastUsedAt < this.backendIdleTtlMs) {
-                continue;
-            }
-            void backend.appServerClient?.stop();
-            this.backends.delete(key);
-        }
-    }
-    createBackend(runtime, retryEnv) {
+    createBackend(runtime) {
         const profile = getRuntimeProfile(runtime);
-        // A composite (per-budget) backend is inherently non-default: it gets a
-        // fresh app-server with the retry env, never the test-injected default deps.
-        const isComposite = retryEnv !== undefined;
-        const isDefault = runtime === this.defaultRuntime && !isComposite;
+        const isDefault = runtime === this.defaultRuntime;
         const commandRunner = (isDefault && this.injectedCommandRunner) ||
             new SpawnCodexCommandRunner(resolveRuntimeBinary(runtime));
         // The claude runtime is not codex-lineage: it has no app-server (its live
@@ -351,7 +390,7 @@ export class LocalAgentHost {
             ? this.injectedAppServerClient === null
                 ? null
                 : this.injectedAppServerClient ?? this.createAppServerClient(runtime)
-            : this.createAppServerClient(runtime, retryEnv);
+            : this.createAppServerClient(runtime);
         return { runtime, profile, appServerClient, commandRunner };
     }
     /** This session's private native home, shared by its app-server + TUI. */
@@ -365,7 +404,7 @@ export class LocalAgentHost {
         this.runtimeHomes.set(runtime, prepared);
         return prepared;
     }
-    createAppServerClient(runtime, extraEnv) {
+    createAppServerClient(runtime) {
         const cliPath = resolveRuntimeBinary(runtime);
         // Per-agent knobs (resolved at live-session start) win over the daemon
         // default — the app-server is private to this session's agent.
@@ -381,8 +420,8 @@ export class LocalAgentHost {
         const channel = new WsRpcChannel({
             cliPath,
             baseArgs: buildAppServerBaseArgs(sandbox),
+            stateDir: runtimeSessionStateDir(this.runtimeHomeSessionId),
             extraEnv: {
-                ...(extraEnv ?? {}),
                 [profile.homeEnvVar]: this.runtimeHome(runtime),
             },
         });
@@ -403,36 +442,81 @@ export class LocalAgentHost {
         if (live.settledInteractions.has(interactionId)) {
             return { disposition: "already_resolved" };
         }
-        if (live.interactionRecoveries.has(interactionId)) {
-            return {
-                disposition: "invalid",
-                message: "interaction delivery is recovering; retry shortly",
-            };
+        const synthetic = live.syntheticInteractions.get(interactionId);
+        if (synthetic)
+            return synthetic.resolve(resolution);
+        return live.forwarderClient.resolveInteraction(interactionId, resolution);
+    }
+    /** Apply collaboration mode to an already-loaded Codex-lineage thread. The
+     * caller persists only after this native RPC succeeds. */
+    async updateCollaborationMode(localThreadId, mode) {
+        const live = this.liveSessions.get(localThreadId);
+        if (!live || live.stopped || live.rotationPending) {
+            throw new CodexRuntimeError("Native Session is not live", 409, "native_session_not_live");
         }
-        const submit = (client) => {
-            // Store before entering the client: a transport can report a synchronous
-            // write failure, and failover must already have the exact accepted answer
-            // available for replay. A synchronous terminal event may delete it again.
-            const hadPrevious = live.interactionSubmissions.has(interactionId);
-            const previous = live.interactionSubmissions.get(interactionId);
-            live.interactionSubmissions.set(interactionId, resolution);
-            const result = client.resolveInteraction(interactionId, resolution);
-            if (result.disposition !== "applied") {
-                if (hadPrevious && previous)
-                    live.interactionSubmissions.set(interactionId, previous);
-                else
-                    live.interactionSubmissions.delete(interactionId);
+        const run = live.injectLock.then(async () => {
+            const bound = await this.waitLiveReady(localThreadId, CODEX_BRIDGE_READY_TIMEOUT_MS);
+            const threadId = live.threadId ?? live.forwarder.threadId();
+            if (!bound || !threadId) {
+                throw new CodexRuntimeError("Native thread is not ready", 503, "native_thread_not_ready");
             }
-            return result;
-        };
-        const owner = live.interactionOwners.get(interactionId);
-        if (owner)
-            return submit(owner);
-        const injected = submit(live.injectClient);
-        if (injected.disposition !== "not_found") {
-            return injected;
+            await this.applyLiveCollaborationMode(live, threadId, mode);
+        });
+        live.injectLock = run.then(() => undefined, () => undefined);
+        await run;
+    }
+    /** Apply one explicit collaboration mode to the current native thread and
+     * remember only a successful RPC. A supplied client is already initialized
+     * and remains owned by its caller (used by cold-resume preload). */
+    async applyLiveCollaborationMode(live, threadId, mode, suppliedClient) {
+        await this.applyLiveThreadSettings(live, threadId, mode, suppliedClient);
+    }
+    /** Apply pending explicit model/effort settings and, when requested, one
+     * collaboration mode in a single native update. */
+    async applyLiveThreadSettings(live, threadId, mode, suppliedClient) {
+        const client = suppliedClient ?? this.injectionClientFactory(live.appServerUrl);
+        try {
+            if (!suppliedClient)
+                await client.ensureInitialized();
+            const desiredModel = live.model;
+            const desiredReasoningEffort = live.reasoningEffort;
+            const modelChanged = desiredModel !== live.appliedModel;
+            const effortChanged = desiredReasoningEffort !== live.appliedReasoningEffort;
+            const collaborationMode = mode && live.appliedCollaborationMode !== mode
+                ? await resolveLiveCollaborationMode(client, live, mode, live.runtime === "codex" ? this.runtimeHome(live.runtime) : undefined)
+                : undefined;
+            const settings = {
+                threadId,
+                ...(modelChanged ? { model: desiredModel || null } : {}),
+                ...(effortChanged
+                    ? { effort: desiredReasoningEffort ?? null }
+                    : {}),
+                ...(collaborationMode ? { collaborationMode } : {}),
+            };
+            if (Object.keys(settings).length === 1)
+                return;
+            await client.threadSettingsUpdate(settings);
+            if (collaborationMode) {
+                if (!live.model)
+                    live.model = collaborationMode.settings.model;
+                live.mayUseProviderDefaultModel = false;
+                live.appliedModel = collaborationMode.settings.model;
+                live.appliedReasoningEffort =
+                    collaborationMode.settings.reasoning_effort ?? undefined;
+                live.appliedCollaborationMode = mode;
+                live.execution = { ...live.execution, collaborationMode: mode };
+            }
+            else {
+                if (modelChanged)
+                    live.appliedModel = desiredModel;
+                if (effortChanged)
+                    live.appliedReasoningEffort = desiredReasoningEffort;
+            }
+        }
+        finally {
+            if (!suppliedClient)
+                await client.stop().catch(() => undefined);
         }
-        return submit(live.forwarderClient);
     }
     /**
      * The command to run in a session's live terminal so it co-drives the codex
@@ -455,7 +539,7 @@ export class LocalAgentHost {
             throw new CodexRuntimeError("session snapshots are not live", 409, "session_not_live");
         }
         const runtime = live.runtime;
-        const backend = this.getBackend(runtime, live.execution.budget ?? undefined);
+        const backend = this.getBackend(runtime);
         const client = backend.appServerClient;
         if (!client) {
             throw new CodexRuntimeError(`no app-server for runtime ${runtime}`, 500, "app_server_unavailable");
@@ -475,6 +559,10 @@ export class LocalAgentHost {
         const traexYolo = runtime === "traex" &&
             sandbox === "danger-full-access" &&
             approvalPolicy === "never";
+        // Runner-owned Codex terminals start detached, so nobody can answer the
+        // interactive hook-review prompt. The private CODEX_HOME is provisioned
+        // before launch; use Codex's native bypass flag for this managed TUI.
+        const bypassHookTrust = runtime === "codex" || traexYolo;
         const configOverrides = sandbox === "workspace-write"
             ? ["sandbox_workspace_write.network_access=true"]
             : [];
@@ -492,21 +580,26 @@ export class LocalAgentHost {
         const launchEffort = live.reasoningEffort;
         if (launchEffort)
             configOverrides.push(`model_reasoning_effort=${JSON.stringify(launchEffort)}`);
-        if (live?.instructions) {
+        if (runtime === "traex" && live?.instructions) {
             configOverrides.push(`developer_instructions=${JSON.stringify(live.instructions)}`);
         }
         const profile = getRuntimeProfile(runtime);
         const activeThreadId = live?.threadId ?? record?.codexSessionId;
         return {
+            lifecycle: "auxiliary",
             command: resolveRuntimeBinary(runtime),
             args: buildCodexRemoteArgs({
                 remoteUrl,
                 ...(activeThreadId ? { threadId: activeThreadId } : {}),
                 configOverrides,
-                codexArgs: traexYolo ? ["--dangerously-bypass-hook-trust"] : [],
+                codexArgs: bypassHookTrust ? ["--dangerously-bypass-hook-trust"] : [],
                 additionalDirs: providerAdditionalDirs(live.workspace),
             }),
             cwd: live.workspace.cwd,
+            scrollback: 100_000,
+            tmuxAllowPassthrough: true,
+            tmuxStartOnAttach: false,
+            keepAliveAfterExit: false,
             ...(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
@@ -543,16 +636,21 @@ export class LocalAgentHost {
             return sameSessionSnapshots(existingClaude.workspace, existingClaude.execution, snapshotOpts);
         }
         // Dedupe concurrent triggers so only one forwarder is ever created per
-        // session (two would double-mirror every turn). Check this before the live
-        // map: startLiveCodexSession publishes its partially initialized session
-        // before thread/start completes, so a concurrent Terminal start must await
-        // the thread id instead of launching a bare `codex --remote` pane.
+        // session (two would double-mirror every turn). startLiveCodexSession
+        // publishes its partially initialized session before thread/start completes,
+        // so wait for that startup and then adopt any newer mutable Turn settings.
         const inflight = this.liveEnsuring.get(localThreadId);
-        if (inflight)
-            return inflight;
+        if (inflight) {
+            if (!await inflight)
+                return false;
+            const startedLive = this.liveSessions.get(localThreadId);
+            return startedLive
+                ? updateLiveCodexTurnSettings(startedLive, snapshotOpts)
+                : false;
+        }
         const live = this.liveSessions.get(localThreadId);
         if (live)
-            return sameSessionSnapshots(live.workspace, live.execution, snapshotOpts);
+            return updateLiveCodexTurnSettings(live, snapshotOpts);
         const started = this.startLiveCodexSession(localThreadId, emit, snapshotOpts);
         this.liveEnsuring.set(localThreadId, started);
         try {
@@ -563,6 +661,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
@@ -571,6 +670,7 @@ export class LocalAgentHost {
             this.stopLiveCodexSession(localThreadId);
         }
         const record = await this.sessionStore.get(localThreadId);
+        const coldResume = Boolean(record?.codexSessionId);
         const retargetMirror = opts.retargetMirror;
         const workspace = structuredClone(opts.workspace);
         const execution = structuredClone(opts.execution);
@@ -586,18 +686,34 @@ export class LocalAgentHost {
                 snapshotSkills = await this.prepareExecutionSkills(execution);
             }
             catch (err) {
+                this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_skill_preparation_failed", "skill preparation failed", err));
                 console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
                 return false;
             }
         }
-        // Persist the owner's skills before the app-server boots. Fork targets reuse
-        // the owner's immutable copies and never mutate the shared Provider home.
+        // Persist headless project trust before the app-server boots. Fork targets
+        // reuse the owner's immutable Provider home.
         const liveSkills = snapshotSkills.selectedSkills.map((s) => ({ name: s.name, dir: s.dir }));
+        const runtimeHome = this.runtimeHome(runtime);
+        if (runtime === "codex") {
+            try {
+                trustCodexProject(runtimeHome, workspace.cwd);
+                syncCodexDeveloperInstructions(runtimeHome, nativeAuthoredInstructions(execution));
+                applyCodexProviderRetryPolicy(runtimeHome, execution.budget?.retry);
+            }
+            catch (err) {
+                void snapshotSkills.skillsCleanup();
+                this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_project_trust_failed", "project trust preparation failed", err));
+                console.error(`[session-snapshot] session=${localThreadId} project trust preparation failed: ${err instanceof Error ? err.message : String(err)}`);
+                return false;
+            }
+        }
         try {
-            populateCodexSkills(this.runtimeHome(runtime), liveSkills);
+            populateCodexSkills(runtimeHome, liveSkills);
         }
         catch (err) {
             void snapshotSkills.skillsCleanup();
+            this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_skill_persistence_failed", "skill persistence failed", err));
             console.error(`[session-snapshot] session=${localThreadId} skill persistence failed: ${err instanceof Error ? err.message : String(err)}`);
             return false;
         }
@@ -615,46 +731,99 @@ export class LocalAgentHost {
             void snapshotSkills.skillsCleanup();
             return false;
         };
-        const injectClient = this.getBackend(runtime, execution.budget ?? undefined).appServerClient;
-        if (!injectClient) {
+        reapRuntimeProcessesForStateDir(runtimeSessionStateDir(this.runtimeHomeSessionId));
+        const backend = this.getBackend(runtime);
+        const appServerOwner = backend.appServerClient;
+        if (!appServerOwner) {
+            this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_app_server_unavailable", "app-server is unavailable for this Session"));
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} no app-server client`);
             return abandon();
         }
+        let loginRequired;
+        if (!coldResume &&
+            runtime === "codex" &&
+            codexLaunchRequiresLogin(runtimeHome, createCodexChildEnv({ ...process.env, CODEX_HOME: runtimeHome }))) {
+            loginRequired = new CodexRuntimeError("Codex is not signed in and no configured Provider can run this Session, so the Terminal is waiting at the sign-in screen. Sign in from the Session Terminal, then send the message again.", 401, "login_required");
+        }
         try {
-            await injectClient.ensureInitialized();
+            await appServerOwner.ensureInitialized();
         }
         catch (err) {
+            this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_app_server_start_failed", "app-server initialization failed during its 10s readiness phase", 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();
+        // A fresh remote TUI creates the thread, so Rynx does not receive its
+        // `thread/start` response. Ask the already-initialized app-server for the
+        // effective model instead of parsing Traex's version-dependent YAML/TOML
+        // files or confusing `model/list.isDefault` with this Session's model.
+        let configModel;
+        let configReasoningEffort;
+        if (!coldResume && (!execution.model || !execution.reasoningEffort)) {
+            try {
+                const effective = await appServerOwner.configRead({
+                    includeLayers: false,
+                    cwd: workspace.cwd,
+                });
+                const reportedModel = effective.config.model;
+                if (typeof reportedModel === "string" && reportedModel.trim()) {
+                    configModel = reportedModel.trim();
+                }
+                const reportedEffort = effective.config.model_reasoning_effort;
+                if (typeof reportedEffort === "string" && reportedEffort) {
+                    configReasoningEffort = reportedEffort;
+                }
+            }
+            catch (error) {
+                // Explicit Session settings remain usable on an older Provider. If a
+                // requested collaboration mode later needs an unknown model, that
+                // update fails clearly without mutating the native thread.
+                console.warn(`[codex-live] session=${localThreadId} runtime=${runtime} effective config unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const appServerUrl = appServerOwner.terminalRemoteUrl();
         if (!appServerUrl) {
+            this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_app_server_endpoint_missing", "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)
         }
         // reference implementation multi-connection: a SEPARATE forwarder connection to the SAME
         // app-server, which `thread/resume`s to subscribe to the thread's item/turn
         // notifications (the backend client injects; this one only observes).
+        // Fresh sessions must connect this listener before the TUI launches so its
+        // one-shot `thread/started` cannot race discovery. A known-thread cold resume
+        // already has its durable id: like reference implementation's `_codex_forward_known_thread`,
+        // its observer starts in the background only after the replacement TUI has
+        // launched and is never part of the resume admission boundary.
         const forwarderClient = this.forwarderClientFactory(appServerUrl);
-        try {
-            await forwarderClient.ensureInitialized();
-        }
-        catch (err) {
-            console.error(`[codex-live] session=${localThreadId} runtime=${runtime} forwarder init failed: ${err instanceof Error ? err.message : String(err)}`);
-            return abandon();
+        if (!coldResume) {
+            try {
+                await forwarderClient.ensureInitialized();
+            }
+            catch (err) {
+                this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_fresh_listener_failed", "fresh-thread listener could not attach to the ready app-server", err));
+                console.error(`[codex-live] session=${localThreadId} runtime=${runtime} fresh-thread listener init failed: ${err instanceof Error ? err.message : String(err)}`);
+                return abandon();
+            }
         }
-        const model = execution.model;
-        const reasoningEffort = execution.reasoningEffort ?? undefined;
+        const model = execution.model?.trim() || (!coldResume ? configModel : undefined) || "";
+        const reasoningEffort = execution.reasoningEffort ??
+            (!coldResume ? configReasoningEffort : 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;
         });
         const live = {
-            injectClient,
+            appServerOwner,
+            appServerUrl,
             forwarderClient,
             forwarder: null,
             runtime,
@@ -664,27 +833,37 @@ export class LocalAgentHost {
             approvalPolicy,
             model,
             reasoningEffort,
-            ...(execution.instructions ? { instructions: execution.instructions } : {}),
+            mayUseProviderDefaultModel: !coldResume && !model,
+            appliedModel: coldResume ? "" : model,
+            appliedReasoningEffort: coldResume ? undefined : reasoningEffort,
+            appliedCollaborationMode: undefined,
+            ...(runtime === "traex" && execution.instructions
+                ? { instructions: execution.instructions }
+                : {}),
             threadId: record?.codexSessionId ?? null,
             ready,
             markReady,
+            startupFailed,
+            markStartupFailed,
+            ...(loginRequired ? { startupError: loginRequired } : {}),
             terminalReady,
             markTerminalReady,
             injectLock: Promise.resolve(),
             pendingInjectedInputs: [],
-            publishInjectedInput: () => undefined,
+            publishTurnAdmission: () => undefined,
+            publishTurnAdmissionFailure: () => undefined,
+            publishInterrupted: () => undefined,
+            interruptedResponseId: null,
             subscribing: false,
             rotationPending: false,
             stopped: false,
+            observerAvailable: !coldResume,
+            threadActive: false,
             skillsCleanup: snapshotSkills.skillsCleanup,
-            interactionOwners: new Map(),
-            interactionStandbys: new Map(),
-            interactionSubmissions: new Map(),
             canonicalInteractions: new Set(),
             settledInteractions: new Set(),
-            interactionRecoveries: new Map(),
-            interactionFailedClients: new Map(),
-            disconnectedClients: new Set(),
+            syntheticInteractions: new Map(),
+            cancelSyntheticInteractions: () => undefined,
         };
         let currentSessionId = localThreadId;
         let pendingRotationEvents = null;
@@ -695,11 +874,23 @@ export class LocalAgentHost {
             }
             emit(event);
         };
+        live.publishInterrupted = (responseId) => {
+            if (live.interruptedResponseId === responseId)
+                return;
+            live.interruptedResponseId = responseId;
+            emitCurrent({
+                type: "session.interrupted",
+                sessionId: currentSessionId,
+                responseId,
+            });
+        };
         let normalizer = null;
         let currentResponseId = null;
+        /** State for content-only events, keyed by Provider response so consecutive
+         * late deltas retain one canonical item id without owning lifecycle. */
+        const contentNormalizers = new Map();
         const startNormalizer = (turnId) => {
-            const responseId = live.pendingInjectedInputs.find((entry) => entry.responseId)?.responseId ??
-                (turnId ? `resp_codex_${turnId}` : "resp_codex_native");
+            const responseId = turnId ? `resp_codex_${turnId}` : "resp_codex_native";
             if (normalizer && currentResponseId === responseId)
                 return normalizer;
             currentResponseId = responseId;
@@ -709,26 +900,68 @@ 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;
         };
-        live.publishInjectedInput = (turnId, content) => {
-            const n = startNormalizer(turnId);
-            const pending = live.pendingInjectedInputs.find((entry) => entry.signature === JSON.stringify(content) && entry.responseId === undefined);
-            if (pending && currentResponseId)
-                pending.responseId = currentResponseId;
-            for (const se of n.userInput(content))
-                emitCurrent(se);
+        live.publishTurnAdmission = () => {
+            emitCurrent({
+                type: "session.status",
+                sessionId: currentSessionId,
+                status: "running",
+            });
+        };
+        live.publishTurnAdmissionFailure = (message) => {
+            emitCurrent({
+                type: "session.status",
+                sessionId: currentSessionId,
+                status: "failed",
+                note: message,
+            });
         };
         const clearPendingInputsForResponse = (responseId) => {
             if (!responseId)
                 return;
             live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== responseId);
         };
+        const turnContentEvents = (turnId, produce) => {
+            const responseId = turnId ? `resp_codex_${turnId}` : "resp_codex_native";
+            let contentNormalizer = contentNormalizers.get(responseId);
+            if (!contentNormalizer) {
+                contentNormalizer = new SessionNormalizer({
+                    sessionId: currentSessionId,
+                    responseId,
+                    model: live.model || live.runtime,
+                });
+                contentNormalizers.set(responseId, contentNormalizer);
+            }
+            for (const event of produce(contentNormalizer)) {
+                // Item/transient content is attached to the Turn's response id
+                // independently of lifecycle status. Reuse Rynx's canonical item
+                // normalization but suppress its synthetic lifecycle edges.
+                if (event.type !== "response.created" && event.type !== "session.status") {
+                    emitCurrent(event);
+                }
+            }
+        };
+        const observedUserContent = (content) => {
+            const normalizedContent = typeof content === "string"
+                ? [{ type: "input_text", text: content }]
+                : content;
+            // The Provider does not echo a caller id and may reformat the text, so the
+            // first native user record drains the oldest injected input instead of
+            // comparing message text.
+            const pending = live.pendingInjectedInputs[0];
+            if (pending) {
+                pending.observed = true;
+                if (pending.state === "accepted") {
+                    live.pendingInjectedInputs.shift();
+                }
+            }
+            return normalizedContent;
+        };
         const rememberSettledInteraction = (interactionId) => {
             live.settledInteractions.add(interactionId);
             if (live.settledInteractions.size <= MAX_CODEX_SETTLED_INTERACTIONS)
@@ -737,11 +970,174 @@ export class LocalAgentHost {
             if (oldest)
                 live.settledInteractions.delete(oldest);
         };
+        const cancelSyntheticInteractions = (reason) => {
+            for (const interaction of live.syntheticInteractions.values())
+                interaction.cancel(reason);
+        };
+        live.cancelSyntheticInteractions = cancelSyntheticInteractions;
+        const publishPlanImplementationPrompt = (prompt) => {
+            const suffix = createHash("sha256")
+                .update(`${prompt.threadId}\0${prompt.turnId}`)
+                .digest("hex")
+                .slice(0, 24);
+            const interactionId = `codex_plan_implementation_${suffix}`;
+            if (live.syntheticInteractions.has(interactionId) ||
+                live.settledInteractions.has(interactionId))
+                return;
+            const responseId = `resp_codex_plan_approval_${suffix}`;
+            const request = codexPlanImplementationRequest(interactionId);
+            const interactionNormalizer = new SessionNormalizer({
+                sessionId: currentSessionId,
+                responseId,
+                model: live.model || live.runtime,
+            });
+            let submitted = false;
+            const finish = (kind, resolution, reason) => {
+                if (!live.syntheticInteractions.delete(interactionId))
+                    return;
+                rememberSettledInteraction(interactionId);
+                const event = kind === "resolved"
+                    ? {
+                        type: "interaction_resolved",
+                        interactionId,
+                        resolution: resolution,
+                    }
+                    : {
+                        type: "interaction_cancelled",
+                        interactionId,
+                        ...(reason ? { reason } : {}),
+                    };
+                // This interaction belongs to the Session that produced the Plan. A
+                // clear-context choice can rotate the native thread before turn/start
+                // returns, so never retarget its resolution to the new Session.
+                for (const sessionEvent of interactionNormalizer.next(event))
+                    emit(sessionEvent);
+                for (const sessionEvent of interactionNormalizer.next({ type: "done" })) {
+                    emit(sessionEvent);
+                }
+            };
+            live.syntheticInteractions.set(interactionId, {
+                cancel: (reason) => {
+                    // The selected implementation itself starts a native Turn and the
+                    // clear-context variant also starts a new thread. Their observer
+                    // notifications can beat the short-lived RPC response; they are not
+                    // competing user actions and must not cancel the card being resolved.
+                    if (submitted &&
+                        (reason === "superseded_by_native_turn" || reason === "native_thread_rotated"))
+                        return;
+                    finish("cancelled", undefined, reason);
+                },
+                resolve: async (resolution) => {
+                    if (submitted)
+                        return { disposition: "already_resolved" };
+                    const invalid = validateInteractionResolution(request, resolution);
+                    if (invalid)
+                        return { disposition: "invalid", message: invalid };
+                    const choice = resolution.answers?.plan_implementation;
+                    if (typeof choice !== "string") {
+                        return { disposition: "invalid", message: "plan implementation choice is required" };
+                    }
+                    submitted = true;
+                    const run = live.injectLock.then(async () => {
+                        if (live.stopped || live.rotationPending) {
+                            throw new CodexRuntimeError("Native Session is not available for plan implementation", 409, "native_session_not_live");
+                        }
+                        const promptDismissal = await dismissCodexPlanImplementationPrompt(live.injector, () => !live.stopped &&
+                            !live.rotationPending &&
+                            live.syntheticInteractions.has(interactionId) &&
+                            live.forwarder.threadId() === prompt.threadId &&
+                            !live.forwarder.isTurnOpen());
+                        if (promptDismissal === "failed") {
+                            console.warn(`[codex-live] session=${currentSessionId} native Plan picker remained visible after the Web decision; continuing through the app-server`);
+                        }
+                        if (choice === CODEX_PLAN_IMPLEMENTATION_NO) {
+                            finish("resolved", resolution);
+                            return;
+                        }
+                        const client = this.injectionClientFactory(live.appServerUrl);
+                        try {
+                            await client.ensureInitialized();
+                            const collaborationMode = await resolveLiveCollaborationMode(client, live, "default", live.runtime === "codex" ? this.runtimeHome(live.runtime) : undefined);
+                            let threadId = prompt.threadId;
+                            let text = CODEX_PLAN_IMPLEMENTATION_CODING_MESSAGE;
+                            if (choice === CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT) {
+                                live.nextThreadCollaborationMode = "default";
+                                let startedThread;
+                                try {
+                                    startedThread = await client.threadStart({
+                                        ...(live.model ? { model: live.model } : {}),
+                                        ...threadWorkspaceParams(live.runtime, live.workspace, live.sandbox),
+                                        approvalPolicy: live.approvalPolicy,
+                                        ...(live.instructions ? { developerInstructions: live.instructions } : {}),
+                                        sessionStartSource: "clear",
+                                    });
+                                }
+                                catch (error) {
+                                    live.nextThreadCollaborationMode = undefined;
+                                    throw error;
+                                }
+                                threadId = startedThread.threadId;
+                                text = `${CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT_PREFIX}\n\n${prompt.text}`;
+                            }
+                            else if (choice !== CODEX_PLAN_IMPLEMENTATION_YES) {
+                                throw new CodexRuntimeError("Unknown plan implementation choice", 400, "invalid_interaction_resolution");
+                            }
+                            const started = await client.turnStart({
+                                threadId,
+                                input: [{ type: "text", text }],
+                                ...turnWorkspaceParams(live.runtime, live.workspace, live.sandbox),
+                                approvalPolicy: live.approvalPolicy,
+                                collaborationMode,
+                            });
+                            if (!live.model)
+                                live.model = collaborationMode.settings.model;
+                            live.mayUseProviderDefaultModel = false;
+                            live.appliedModel = collaborationMode.settings.model;
+                            live.appliedReasoningEffort =
+                                collaborationMode.settings.reasoning_effort ?? undefined;
+                            live.execution = { ...live.execution, collaborationMode: "default" };
+                            live.appliedCollaborationMode = "default";
+                            emitCurrent({
+                                type: "session.collaboration_mode",
+                                sessionId: currentSessionId,
+                                mode: "default",
+                            });
+                            live.forwarder.noteTurnAccepted(started.turnId);
+                            finish("resolved", resolution);
+                        }
+                        finally {
+                            await client.stop().catch(() => undefined);
+                        }
+                    });
+                    live.injectLock = run.then(() => undefined, () => undefined);
+                    try {
+                        await run;
+                        return { disposition: "applied" };
+                    }
+                    catch (error) {
+                        submitted = false;
+                        return {
+                            disposition: "invalid",
+                            message: error instanceof Error ? error.message : String(error),
+                        };
+                    }
+                },
+            });
+            for (const sessionEvent of interactionNormalizer.next({
+                type: "interaction_requested",
+                interaction: request,
+            }))
+                emit(sessionEvent);
+        };
         const forwardInteraction = (event) => {
             const interactionId = event.type === "requested"
                 ? event.request.interactionId
                 : event.interactionId;
             if (event.type === "requested") {
+                if (event.request.fields.some((field) => field.id === "plan_implementation")) {
+                    live.forwarder.noteNativePlanImplementationPrompt(event.turnId);
+                    cancelSyntheticInteractions("superseded_by_native_plan_prompt");
+                }
                 if (live.canonicalInteractions.has(interactionId) ||
                     live.settledInteractions.has(interactionId))
                     return;
@@ -773,223 +1169,179 @@ export class LocalAgentHost {
             for (const se of n.next(agentEvent))
                 emitCurrent(se);
         };
-        const clearRecovery = (interactionId) => {
-            live.interactionRecoveries.delete(interactionId);
-        };
-        const clearInteractionRouting = (interactionId) => {
-            clearRecovery(interactionId);
-            live.interactionOwners.delete(interactionId);
-            live.interactionStandbys.delete(interactionId);
-            live.interactionSubmissions.delete(interactionId);
-            live.interactionFailedClients.delete(interactionId);
-        };
-        const markInteractionClientFailed = (interactionId, client) => {
-            const failed = live.interactionFailedClients.get(interactionId) ?? new Set();
-            failed.add(client);
-            live.interactionFailedClients.set(interactionId, failed);
-        };
-        const interactionClientUnavailable = (interactionId, client) => live.disconnectedClients.has(client) ||
-            live.interactionFailedClients.get(interactionId)?.has(client) === true;
-        const allInteractionClientsUnavailable = (interactionId) => [live.injectClient, live.forwarderClient].every((client) => interactionClientUnavailable(interactionId, client));
-        const finishRecovery = (interactionId, event) => {
-            clearInteractionRouting(interactionId);
-            forwardInteraction(event);
-        };
-        const beginRecovery = (interactionId, event) => {
-            live.interactionOwners.delete(interactionId);
-            live.interactionRecoveries.set(interactionId, { event });
-        };
-        const promoteInteractionOwner = (interactionId, replacement) => {
-            const recovery = live.interactionRecoveries.get(interactionId);
-            live.interactionOwners.set(interactionId, replacement);
-            const submission = live.interactionSubmissions.get(interactionId);
-            if (!submission) {
-                clearRecovery(interactionId);
-                return true;
-            }
-            const replayed = replacement.resolveInteraction(interactionId, submission);
-            // A write failure can synchronously re-enter the listener and remove this
-            // owner. Only clear recovery when the replacement still owns the request.
-            if (replayed.disposition === "applied" &&
-                live.interactionOwners.get(interactionId) === replacement) {
-                clearRecovery(interactionId);
-                return true;
-            }
-            if (live.interactionOwners.get(interactionId) === replacement) {
-                live.interactionOwners.delete(interactionId);
-            }
-            if (recovery &&
-                live.canonicalInteractions.has(interactionId) &&
-                !live.settledInteractions.has(interactionId) &&
-                !live.interactionRecoveries.has(interactionId)) {
-                live.interactionRecoveries.set(interactionId, recovery);
-            }
-            return false;
-        };
-        const bindInteractionClient = (client) => {
-            client.setInteractionListener((event) => {
-                const interactionId = event.type === "requested"
-                    ? event.request.interactionId
-                    : event.interactionId;
-                const owner = live.interactionOwners.get(interactionId);
-                if (event.type === "requested") {
-                    // Receiving a native request proves this connection is alive and can
-                    // be retried even if an earlier copy failed on it.
-                    live.disconnectedClients.delete(client);
-                    const failed = live.interactionFailedClients.get(interactionId);
-                    failed?.delete(client);
-                    if (failed?.size === 0)
-                        live.interactionFailedClients.delete(interactionId);
-                    if (live.settledInteractions.has(interactionId))
-                        return;
-                    const recovery = live.interactionRecoveries.get(interactionId);
-                    if (recovery) {
-                        promoteInteractionOwner(interactionId, client);
-                        return;
-                    }
-                    if (owner && owner !== client) {
-                        const standbys = live.interactionStandbys.get(interactionId) ?? new Set();
-                        standbys.add(client);
-                        live.interactionStandbys.set(interactionId, standbys);
-                        return;
-                    }
-                    live.interactionOwners.set(interactionId, client);
-                    forwardInteraction(event);
-                    return;
-                }
-                const recoverableOwnerFailure = event.type === "cancelled" &&
-                    (event.reason === "app_server_disconnected" || event.reason === "response_write_failed");
-                if (recoverableOwnerFailure)
-                    markInteractionClientFailed(interactionId, client);
-                if (!owner || owner !== client) {
-                    const standbys = live.interactionStandbys.get(interactionId);
-                    standbys?.delete(client);
-                    if (standbys?.size === 0)
-                        live.interactionStandbys.delete(interactionId);
-                    const recovery = live.interactionRecoveries.get(interactionId);
-                    if (recoverableOwnerFailure &&
-                        live.canonicalInteractions.has(interactionId) &&
-                        allInteractionClientsUnavailable(interactionId)) {
-                        finishRecovery(interactionId, recovery?.event ?? event);
-                    }
-                    return;
-                }
-                if (recoverableOwnerFailure) {
-                    const standbys = live.interactionStandbys.get(interactionId);
-                    while (standbys && standbys.size > 0) {
-                        const replacement = standbys.values().next().value;
-                        if (!replacement)
-                            break;
-                        standbys.delete(replacement);
-                        if (interactionClientUnavailable(interactionId, replacement))
-                            continue;
-                        if (promoteInteractionOwner(interactionId, replacement)) {
-                            if (standbys.size === 0)
-                                live.interactionStandbys.delete(interactionId);
-                            return;
-                        }
-                        if (live.settledInteractions.has(interactionId))
-                            return;
-                    }
-                    if (!live.settledInteractions.has(interactionId)) {
-                        if (allInteractionClientsUnavailable(interactionId)) {
-                            finishRecovery(interactionId, event);
-                        }
-                        else {
-                            beginRecovery(interactionId, event);
-                        }
-                        return;
-                    }
-                }
-                clearInteractionRouting(interactionId);
-                forwardInteraction(event);
-            });
+        const bindObserverClient = (client) => {
+            client.setInteractionListener(forwardInteraction);
             client.setConnectionListener((state) => {
-                if (state === "connected") {
-                    live.disconnectedClients.delete(client);
+                if (state === "connected" || live.stopped)
                     return;
+                live.observerAvailable = false;
+                for (const interactionId of [...live.canonicalInteractions]) {
+                    forwardInteraction({
+                        type: "cancelled",
+                        interactionId,
+                        reason: "app_server_disconnected",
+                    });
                 }
-                live.disconnectedClients.add(client);
-                for (const [interactionId, recovery] of [...live.interactionRecoveries]) {
-                    if (allInteractionClientsUnavailable(interactionId)) {
-                        finishRecovery(interactionId, recovery.event);
-                    }
-                }
+                this.failObserverLifecycle(localThreadId, live, nativeLiveFailure(runtime, "native_observer_disconnected", "observer connection closed"));
             });
         };
         const closeCanonicalInteractions = () => {
             for (const interactionId of live.canonicalInteractions) {
                 rememberSettledInteraction(interactionId);
-                clearInteractionRouting(interactionId);
             }
             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 interruptCurrentTurn = () => {
+            closeCanonicalInteractions();
+            if (!normalizer)
+                return;
+            const interruptedResponseId = currentResponseId;
+            for (const se of normalizer.interrupt()) {
+                if (se.type === "session.interrupted" &&
+                    live.interruptedResponseId === interruptedResponseId)
+                    continue;
+                emitCurrent(se);
+            }
+            live.interruptedResponseId = null;
+            clearPendingInputsForResponse(interruptedResponseId);
+            normalizer = null;
+            currentResponseId = null;
+        };
         const sink = {
             onTurnStart: (turnId) => startNormalizer(turnId),
-            onUserMessage: (content) => {
-                const normalizedContent = typeof content === "string"
-                    ? [{ type: "input_text", text: content }]
-                    : content;
-                const signature = JSON.stringify(normalizedContent);
-                const pending = live.pendingInjectedInputs.find((entry) => entry.signature === signature);
-                if (pending?.state === "optimistic" || pending?.state === "prepublished") {
-                    live.pendingInjectedInputs.splice(live.pendingInjectedInputs.indexOf(pending), 1);
-                    return;
+            onTurnObserved: (turnId) => {
+                cancelSyntheticInteractions("superseded_by_native_turn");
+                const n = startNormalizer(turnId);
+                for (const event of n.next({ type: "turn_started", ...(turnId ? { turnId } : {}) })) {
+                    emitCurrent(event);
                 }
-                if (pending)
-                    pending.observed = true;
+            },
+            onUserMessage: (content) => {
+                const normalizedContent = observedUserContent(content);
                 const n = normalizer ?? startNormalizer();
                 for (const se of n.userInput(normalizedContent))
                     emitCurrent(se);
             },
+            onTurnContentUserMessage: (turnId, content) => {
+                const normalizedContent = observedUserContent(content);
+                turnContentEvents(turnId, (n) => n.userInput(normalizedContent));
+            },
             onEvent: (event) => {
                 const n = normalizer ?? startNormalizer();
                 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;
+            onTurnContentEvent: (turnId, event) => {
+                turnContentEvents(turnId, (n) => n.next(event));
+            },
+            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,
+            onTurnInterrupted: interruptCurrentTurn,
+            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),
-            onThreadActive: () => live.releaseActive?.(),
+            onThreadActive: () => {
+                live.threadActive = true;
+                live.releaseActive?.();
+            },
+            onCollaborationModeChanged: (mode) => {
+                live.appliedCollaborationMode = mode;
+                live.execution = { ...live.execution, collaborationMode: mode };
+                emitCurrent({
+                    type: "session.collaboration_mode",
+                    sessionId: currentSessionId,
+                    mode,
+                });
+            },
+            onThreadSettingsChanged: ({ model: reportedModel, reasoningEffort: reportedEffort }) => {
+                if (reportedModel) {
+                    live.model = reportedModel;
+                    live.appliedModel = reportedModel;
+                    live.mayUseProviderDefaultModel = false;
+                }
+                if (reportedEffort !== undefined) {
+                    live.reasoningEffort = reportedEffort ?? undefined;
+                    live.appliedReasoningEffort = reportedEffort ?? undefined;
+                }
+            },
+            onPlanImplementationPrompt: publishPlanImplementationPrompt,
         };
         const forwarder = new CodexSessionForwarder(forwarderClient, sink, {
             // Traex 0.200 can publish a final reasoning item immediately after
@@ -1000,6 +1352,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) => {
@@ -1007,12 +1360,20 @@ export class LocalAgentHost {
                 live.stopped = true;
                 return;
             }
+            cancelSyntheticInteractions("native_thread_rotated");
             const previousSessionId = currentSessionId;
             const newSessionId = makeSessionId();
+            const rotationMode = live.nextThreadCollaborationMode;
+            live.nextThreadCollaborationMode = undefined;
+            live.appliedCollaborationMode = undefined;
+            if (rotationMode) {
+                live.execution = { ...live.execution, collaborationMode: rotationMode };
+            }
             live.rotationPending = true;
             currentSessionId = newSessionId;
             normalizer = null;
             currentResponseId = null;
+            contentNormalizers.clear();
             live.pendingInjectedInputs = [];
             pendingRotationEvents = [];
             void this.sessionStore
@@ -1024,6 +1385,9 @@ export class LocalAgentHost {
                 ...(previous?.runtimeHomeOwnerSessionId
                     ? { runtimeHomeOwnerSessionId: previous.runtimeHomeOwnerSessionId }
                     : {}),
+                ...(previous?.bridgeOwnerSessionId
+                    ? { bridgeOwnerSessionId: previous.bridgeOwnerSessionId }
+                    : {}),
                 updatedAt: new Date().toISOString(),
             }))
                 .then(() => {
@@ -1034,6 +1398,7 @@ export class LocalAgentHost {
                     kind,
                 });
                 this.liveSessions.set(newSessionId, live);
+                this.liveSessions.delete(previousSessionId);
                 retargetMirror?.(newSessionId, {
                     kind,
                     workspace: structuredClone(live.workspace),
@@ -1045,7 +1410,15 @@ export class LocalAgentHost {
                 live.rotationPending = false;
                 for (const event of queued)
                     emit(event);
-                void this.subscribeUntilReady(live, threadId);
+                const desiredMode = live.execution.collaborationMode;
+                if (desiredMode) {
+                    const restore = live.injectLock.then(() => this.applyLiveCollaborationMode(live, threadId, desiredMode));
+                    live.injectLock = restore.then(() => undefined, () => undefined);
+                    void restore.catch((error) => {
+                        this.failObserverLifecycle(newSessionId, live, nativeLiveFailure(live.runtime, "native_collaboration_mode_restore_failed", "rotated native thread could not restore the Session collaboration mode", error));
+                    });
+                }
+                void this.subscribeUntilReady(newSessionId, live, threadId);
             })
                 .catch(() => {
                 pendingRotationEvents = null;
@@ -1053,9 +1426,10 @@ export class LocalAgentHost {
                 live.stopped = true;
             });
         };
-        bindInteractionClient(injectClient);
-        bindInteractionClient(forwarderClient);
+        bindObserverClient(forwarderClient);
         this.liveSessions.set(localThreadId, live);
+        if (loginRequired)
+            this.liveStartupErrors.set(localThreadId, loginRequired);
         forwarder.start();
         // Existing bindings resume through the public app-server API. A fresh thread
         // is created by the native remote TUI instead: its `thread/started`
@@ -1064,36 +1438,56 @@ export class LocalAgentHost {
         // turn-less app-server thread resumable by the TUI.
         try {
             if (record?.codexSessionId) {
-                let resumeError;
-                let resumedThreadId;
-                const attempts = 20;
-                for (let attempt = 0; attempt < attempts; attempt += 1) {
+                // Match reference implementation's cold-resume preload exactly: one history-free
+                // `thread/resume` on a short-lived, separately initialized connection.
+                // The backend owner's handshake above is the app-server readiness
+                // probe; reusing that first connection here races Codex's startup state
+                // and can return `Not initialized`. A failure stays attached to the
+                // original binding and is reported by this phase; it is not polled.
+                const preloadClient = this.preloadClientFactory(appServerUrl);
+                try {
+                    let resumed;
                     try {
-                        const resumed = await injectClient.threadResume({
+                        await preloadClient.ensureInitialized();
+                        resumed = await preloadClient.threadResume({
                             threadId: record.codexSessionId,
                             ...threadWorkspaceParams(runtime, workspace, sandbox),
                             approvalPolicy,
                             excludeTurns: true,
                         });
-                        resumedThreadId = resumed.threadId;
-                        break;
+                        adoptResumedThreadSettings(live, resumed);
+                        await this.applyLiveThreadSettings(live, resumed.threadId, execution.collaborationMode, preloadClient);
                     }
-                    catch (error) {
-                        resumeError = error;
-                        if (!isRetryableThreadResumeError(error))
-                            throw error;
-                        if (attempt + 1 < attempts) {
-                            await new Promise((resolve) => setTimeout(resolve, 150));
-                        }
+                    finally {
+                        await preloadClient.stop().catch((error) => {
+                            console.warn(`[codex-live] session=${localThreadId} runtime=${runtime} preload client cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+                        });
                     }
+                    forwarder.noteThreadBound(resumed.threadId);
+                    this.onLiveThreadStarted(live, localThreadId, resumed.threadId);
                 }
-                if (resumedThreadId) {
-                    this.onLiveThreadStarted(live, localThreadId, resumedThreadId);
-                }
-                else {
-                    // Never replace an existing binding. A delayed native index is
-                    // retryable; a genuinely missing thread remains an explicit error.
-                    throw resumeError;
+                catch (error) {
+                    if (!isThreadNotReadyError(error) ||
+                        record.parentSessionId ||
+                        record.runtimeHomeOwnerSessionId) {
+                        throw error;
+                    }
+                    // Preserve the existing turn-less binding recovery without polling:
+                    // an ordinary native id with no rollout/turn has no Provider history
+                    // to retain. Fork bindings remain strict, and `thread not found` is
+                    // not classified here because it does not prove the history is empty.
+                    await this.sessionStore.delete(localThreadId);
+                    live.threadId = null;
+                    live.mayUseProviderDefaultModel = !live.model;
+                    try {
+                        await forwarderClient.ensureInitialized();
+                    }
+                    catch (listenerError) {
+                        throw nativeLiveFailure(runtime, "native_fresh_listener_failed", "fresh-thread listener could not attach after the turn-less binding was replaced", listenerError);
+                    }
+                    live.observerAvailable = true;
+                    live.markTerminalReady(true);
+                    console.warn(`[codex-live] session=${localThreadId} runtime=${runtime} replaced turn-less native binding ${record.codexSessionId} with fresh discovery`);
                 }
             }
             else {
@@ -1108,15 +1502,32 @@ export class LocalAgentHost {
             live.stopped = true;
             forwarder.stop();
             void forwarderClient.stop().catch(() => undefined);
+            const failure = err instanceof CodexRuntimeError
+                ? err
+                : nativeLiveFailure(runtime, "native_resume_failed", "existing native session could not be resumed", err);
+            this.liveStartupErrors.set(localThreadId, failure);
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} thread bind failed: ${err instanceof Error ? err.message : String(err)}`);
             return abandon();
         }
+        if (!loginRequired)
+            this.liveStartupErrors.delete(localThreadId);
         return true;
     }
     /** Bind a session's codex thread id once known (TUI broadcast or store): persist
      *  it, unblock injection, and kick off the resume-subscribe loop (once). */
     onLiveThreadStarted(live, localThreadId, threadId, forkedFromId) {
+        if (live.startupError?.code === "login_required") {
+            delete live.startupError;
+            if (this.liveStartupErrors.get(localThreadId)?.code === "login_required") {
+                this.liveStartupErrors.delete(localThreadId);
+            }
+        }
         const previousThreadId = live.threadId;
+        if (previousThreadId !== threadId) {
+            live.threadActive = false;
+            if (!live.model)
+                live.mayUseProviderDefaultModel = true;
+        }
         if (previousThreadId && previousThreadId !== threadId) {
             live.threadId = threadId;
             live.subscribing = true;
@@ -1141,12 +1552,82 @@ export class LocalAgentHost {
                 ...(existing?.runtimeHomeOwnerSessionId
                     ? { runtimeHomeOwnerSessionId: existing.runtimeHomeOwnerSessionId }
                     : {}),
+                ...(existing?.bridgeOwnerSessionId
+                    ? { bridgeOwnerSessionId: existing.bridgeOwnerSessionId }
+                    : {}),
                 updatedAt: new Date().toISOString(),
             });
         })
             .catch(() => undefined);
-        live.markReady(); // thread id known → injection can turn/start
-        void this.subscribeUntilReady(live, threadId).then(live.markTerminalReady);
+        const finishBinding = () => {
+            if (live.stopped)
+                return;
+            live.markReady(); // thread id + explicit Session mode are ready for turns
+            if (live.observerAvailable) {
+                void this.subscribeUntilReady(localThreadId, live, threadId).then(live.markTerminalReady);
+            }
+            else {
+                // Known-thread cold resume has already completed the dedicated preload. Its
+                // observer is deliberately post-TUI background work, not Terminal
+                // readiness. RunnerSession calls startLiveCodexObserver after launch.
+                live.markTerminalReady(true);
+            }
+        };
+        const desiredMode = live.execution.collaborationMode;
+        if (!desiredMode || live.appliedCollaborationMode === desiredMode) {
+            finishBinding();
+            return;
+        }
+        // A fresh thread does not exist until the TUI broadcasts thread/started.
+        // Apply the Session-owned mode immediately at that boundary, before Web
+        // injection is released. This also narrows the window in which a user can
+        // type into the native pane before its explicit startup mode is installed.
+        const restore = live.injectLock.then(() => this.applyLiveCollaborationMode(live, threadId, desiredMode));
+        live.injectLock = restore.then(() => undefined, () => undefined);
+        void restore.then(finishBinding).catch((error) => {
+            const failure = nativeLiveFailure(live.runtime, "native_collaboration_mode_restore_failed", "native thread could not apply the Session collaboration mode", error);
+            live.startupError = failure;
+            live.markStartupFailed();
+            this.liveStartupErrors.set(localThreadId, failure);
+            this.teardownLiveCodexSession(localThreadId, failure);
+        });
+    }
+    /** Start the known-thread observer after the replacement TUI has launched.
+     * Fresh sessions already connected their discovery listener before launch;
+     * this is therefore an idempotent no-op for them and for a healthy observer. */
+    startLiveCodexObserver(localThreadId) {
+        const live = this.liveSessions.get(localThreadId);
+        if (!live ||
+            live.stopped ||
+            live.observerAvailable ||
+            !live.threadId)
+            return;
+        void (async () => {
+            try {
+                await live.forwarderClient.ensureInitialized();
+                if (live.stopped)
+                    return;
+                live.observerAvailable = true;
+                // reference implementation starts subscription as a sibling task after the transport
+                // connects. A no/empty rollout remains event-driven retryable; any
+                // other subscription rejection is diagnostic only and must not tear
+                // down the otherwise usable Terminal/injection lifecycle.
+                void this.subscribeUntilReady(localThreadId, live, live.threadId);
+            }
+            catch (error) {
+                this.failObserverLifecycle(localThreadId, live, nativeLiveFailure(live.runtime, "native_observer_connect_failed", "observer could not attach to the ready app-server", error));
+            }
+        })();
+    }
+    /** reference implementation treats the forwarder as a required component of one native
+     * lifecycle: if its transport dies, it closes the app-server instead of
+     * accepting turns that can no longer reach the canonical mirror. */
+    failObserverLifecycle(localThreadId, live, error) {
+        if (live.stopped)
+            return;
+        live.startupError = error;
+        this.liveStartupErrors.set(localThreadId, error);
+        this.teardownLiveCodexSession(localThreadId, error);
     }
     shouldIgnoreManagedForkThreadStarted(live, threadId, forkedFromId) {
         const pending = live.managedFork;
@@ -1170,11 +1651,13 @@ 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. Like reference implementation, the first attempt always uses
+     * `excludeTurns`: a known-session cold resume therefore never reconstructs
+     * historical running/completed state. Only a fresh thread whose first attempt
+     * failed as not-ready retries without `excludeTurns`, backfilling the newly
+     * materialized first turn and de-duplicating it against live notifications.
      */
-    async subscribeUntilReady(live, threadId) {
+    async subscribeUntilReady(localThreadId, live, threadId) {
         let sawNotReady = false;
         while (!live.stopped) {
             try {
@@ -1182,30 +1665,43 @@ export class LocalAgentHost {
                     threadId,
                     ...threadWorkspaceParams(live.runtime, live.workspace, live.sandbox),
                     approvalPolicy: live.approvalPolicy,
-                    excludeTurns: !sawNotReady,
+                    ...(!sawNotReady ? { excludeTurns: true } : {}),
                 });
-                if (sawNotReady && Array.isArray(resp.thread.turns) && resp.thread.turns.length > 0) {
-                    live.forwarder.replayBackfill(resp.thread.turns);
+                adoptResumedThreadSettings(live, resp);
+                if (sawNotReady) {
+                    const turns = Array.isArray(resp.thread.turns)
+                        ? resp.thread.turns
+                        : [];
+                    live.forwarder.replayBackfill(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
+                    console.warn(`[codex-live] session=${localThreadId} runtime=${live.runtime} observer failed to subscribe to thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+                    return false;
                 }
                 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) => {
-                    live.releaseActive = resolve;
-                    setTimeout(resolve, 1500);
-                });
-                live.releaseActive = undefined;
+                if (!live.threadActive) {
+                    // An idle fresh thread has no rollout until its first Turn. Wait only
+                    // for live activity instead of polling the app-server indefinitely.
+                    await new Promise((resolve) => {
+                        live.releaseActive = resolve;
+                    });
+                    live.releaseActive = undefined;
+                }
+                else {
+                    // Activity can precede rollout persistence by a short interval.
+                    await new Promise((resolve) => {
+                        setTimeout(resolve, CODEX_SUBSCRIBE_FLUSH_RETRY_MS);
+                    });
+                }
             }
         }
         return false;
     }
-    /** Await a live session's thread binding (bounded). Returns false on timeout /
+    /** 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);
@@ -1214,18 +1710,22 @@ 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;
     }
-    /** Await the stronger Terminal gate: another app-server connection has
-     * successfully resumed the thread, so the detached TUI cannot race rollout
-     * discovery or indexing. */
+    /** Await the observer subscription diagnostic. Codex/Traex Terminal startup
+     * deliberately does not gate on this promise: the dedicated preload owns resume,
+     * while the independent observer attaches in the background. */
     async waitTerminalReady(localThreadId, timeoutMs = 20_000) {
         const claude = this.liveClaudeSessions.get(localThreadId);
         // Claude has no separate app-server indexing gate. Its TUI must launch first;
@@ -1235,6 +1735,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);
@@ -1246,7 +1748,40 @@ 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?.message
+            ?? this.liveStartupErrors.get(localThreadId)?.message;
+    }
+    /** Structured phase + concrete cause used by the runner wire protocol. */
+    liveSessionFailure(localThreadId) {
+        const failure = this.liveSessions.get(localThreadId)?.startupError
+            ?? this.liveStartupErrors.get(localThreadId);
+        if (failure) {
+            return {
+                message: failure.message,
+                code: failure.code,
+                statusCode: failure.statusCode,
+            };
+        }
+        const claudeError = this.liveClaudeSessions.get(localThreadId)?.error;
+        return claudeError
+            ? { message: claudeError, code: "claude_native_start_failed", statusCode: 503 }
+            : 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, error) {
+        const live = this.liveSessions.get(localThreadId);
+        if (!live || live.threadId || live.stopped)
+            return false;
+        const failure = error instanceof CodexRuntimeError
+            ? error
+            : new CodexRuntimeError(error.message, 503, "native_thread_discovery_failed");
+        live.startupError = failure;
+        this.liveStartupErrors.set(localThreadId, failure);
+        live.markStartupFailed();
+        return true;
     }
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
@@ -1255,13 +1790,13 @@ export class LocalAgentHost {
      * resumed from the persisted native id. Serialized per session so two
      * injects can't double-open a turn.
      *
-     * Returns an {@link InjectOutcome}: `notLive` when this session has no live
+     * Returns an {@link InjectResult}: `notLive` when this session has no live
      * forwarder (caller may use the run path); `notReady`/`failed` are hard errors
      * the caller reports WITHOUT re-running (re-running double-writes alongside the
      * forwarder). Park-until-ready (~60s), aligning reference implementation's executor waiting for
      * the bridge instead of a short race that falls back to a second output path.
      */
-    async injectMessage(localThreadId, input) {
+    async injectMessage(localThreadId, input, options) {
         const runtimeInput = typeof input === "string"
             ? { content: [{ type: "text", text: input }] }
             : input;
@@ -1270,11 +1805,8 @@ export class LocalAgentHost {
             const text = claudeInputText(runtimeInput);
             const content = runtimeUserContent(runtimeInput);
             const pendingInput = {
-                content,
-                signature: JSON.stringify(content),
-                state: runtimeInput.responseId ? "prepublished" : "awaiting",
+                state: "awaiting",
                 observed: false,
-                ...(runtimeInput.responseId ? { responseId: runtimeInput.responseId } : {}),
             };
             claude.pendingInjectedInputs.push(pendingInput);
             const forgetPendingInput = () => {
@@ -1288,98 +1820,183 @@ export class LocalAgentHost {
                 const expiry = setTimeout(() => claude.pendingImageInputs.delete(token), 5 * 60_000);
                 expiry.unref?.();
             }
-            const outcome = await this.injectClaude(claude, localThreadId, text);
-            if (outcome !== "injected") {
+            let result;
+            try {
+                result = await this.injectClaude(claude, localThreadId, text, pendingInput);
+            }
+            catch (error) {
                 forgetPendingInput();
                 if (token)
                     claude.pendingImageInputs.delete(token);
+                throw error;
             }
-            else if (pendingInput.observed) {
+            if (result.outcome !== "injected" && result.outcome !== "steered") {
                 forgetPendingInput();
+                if (token)
+                    claude.pendingImageInputs.delete(token);
+            }
+            else {
+                if (result.responseId)
+                    pendingInput.responseId = result.responseId;
+                if (pendingInput.observed)
+                    forgetPendingInput();
+                else
+                    pendingInput.state = "accepted";
             }
-            return outcome;
+            return result;
         }
         const live = this.liveSessions.get(localThreadId);
         if (!live)
-            return "notLive";
+            return { outcome: "notLive" };
+        if (live.startupError?.code === "login_required")
+            return { outcome: "notReady" };
         const run = live.injectLock.then(async () => {
             if (live.rotationPending || live.stopped)
-                return "failed";
+                return { outcome: "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";
+                return { outcome: "notReady" };
             const nativeInput = buildRuntimeUserInput(runtimeInput);
-            const content = runtimeUserContent(runtimeInput);
             const pendingInput = {
-                content,
-                signature: JSON.stringify(content),
-                state: runtimeInput.responseId ? "prepublished" : "awaiting",
+                state: "awaiting",
                 observed: false,
-                ...(runtimeInput.responseId ? { responseId: runtimeInput.responseId } : {}),
             };
             live.pendingInjectedInputs.push(pendingInput);
+            let injectionMethod = "turn/start";
+            let admissionPublished = false;
+            const publishAdmission = () => {
+                if (admissionPublished)
+                    return;
+                admissionPublished = true;
+                live.publishTurnAdmission();
+            };
             const forgetPendingInput = () => {
                 const index = live.pendingInjectedInputs.indexOf(pendingInput);
                 if (index >= 0)
                     live.pendingInjectedInputs.splice(index, 1);
             };
+            const injectionClient = this.injectionClientFactory(live.appServerUrl);
             try {
-                // Inject via the BACKEND client (the forwarder connection only observes).
+                // reference implementation publishes codex-native running only after the native Terminal
+                // is ready and the runner has accepted the message, but before the
+                // short-lived app-server client initializes and starts the Turn. Claude
+                // deliberately has no matching synthesized edge.
+                if (!live.forwarder.isTurnOpen())
+                    publishAdmission();
+                await injectionClient.ensureInitialized();
+                // Match reference implementation's executor: each message uses one initialized client
+                // that closes as soon as turn/start or turn/steer is acknowledged.
                 if (live.forwarder.isTurnOpen()) {
                     const turnId = live.forwarder.currentTurnId();
                     if (turnId) {
-                        const steered = await live.injectClient.turnSteer({
+                        injectionMethod = "turn/steer";
+                        const steered = await injectionClient.turnSteer({
                             threadId,
                             expectedTurnId: turnId,
                             input: nativeInput,
                         });
-                        if (pendingInput.state === "prepublished") {
-                            // The caller already persisted and published this user input
-                            // before waiting for the native Terminal to become ready.
-                        }
-                        else if (pendingInput.observed) {
+                        pendingInput.responseId = `resp_codex_${steered.turnId}`;
+                        if (pendingInput.observed)
                             forgetPendingInput();
-                        }
-                        else {
-                            live.publishInjectedInput(steered.turnId, pendingInput.content);
-                            pendingInput.state = "optimistic";
-                        }
-                        return "injected";
+                        else
+                            pendingInput.state = "accepted";
+                        live.forwarder.noteTurnAccepted(steered.turnId);
+                        return { outcome: "steered", responseId: `resp_codex_${steered.turnId}` };
                     }
                 }
-                // Carry the agent-spec model on the turn so a web-injected turn runs the
-                // agent's model even if the TUI's config default differs.
-                const started = await live.injectClient.turnStart({
+                // Match reference implementation's turn boundary: change the native thread settings
+                // under the same lock immediately before starting the next Turn. Never
+                // put settings on turn/start or mutate a Turn that is already open.
+                const desiredModel = live.model;
+                const desiredReasoningEffort = live.reasoningEffort;
+                // A Session-owned mode survives runner restarts. Normal Web messages do
+                // not carry per-Turn options, so a cold-resumed native thread must fall
+                // back to the persisted execution snapshot before its first new Turn.
+                // An explicit session.run option still wins for that invocation.
+                const desiredCollaborationMode = options?.collaborationMode ?? live.execution.collaborationMode;
+                const collaborationMode = desiredCollaborationMode &&
+                    desiredCollaborationMode !== live.appliedCollaborationMode
+                    ? await resolveLiveCollaborationMode(injectionClient, live, desiredCollaborationMode, live.runtime === "codex" ? this.runtimeHome(live.runtime) : undefined)
+                    : undefined;
+                const settings = {
+                    threadId,
+                    ...(desiredModel !== live.appliedModel
+                        ? { model: desiredModel || null }
+                        : {}),
+                    ...(desiredReasoningEffort !== live.appliedReasoningEffort
+                        ? { effort: desiredReasoningEffort ?? null }
+                        : {}),
+                    ...(collaborationMode ? { collaborationMode } : {}),
+                };
+                if (Object.keys(settings).length > 1) {
+                    await injectionClient.threadSettingsUpdate(settings);
+                    // Record exactly what this RPC carried. A concurrent settings save may
+                    // already have advanced the desired fields and must remain pending for
+                    // the following new Turn.
+                    if (collaborationMode && !live.model) {
+                        live.model = collaborationMode.settings.model;
+                    }
+                    if (collaborationMode)
+                        live.mayUseProviderDefaultModel = false;
+                    live.appliedModel = collaborationMode?.settings.model ?? desiredModel;
+                    live.appliedReasoningEffort = collaborationMode
+                        ? collaborationMode.settings.reasoning_effort ?? undefined
+                        : desiredReasoningEffort;
+                    if (desiredCollaborationMode) {
+                        live.appliedCollaborationMode = desiredCollaborationMode;
+                        live.execution = {
+                            ...live.execution,
+                            collaborationMode: desiredCollaborationMode,
+                        };
+                    }
+                }
+                publishAdmission();
+                const started = await injectionClient.turnStart({
                     threadId,
                     input: nativeInput,
                     ...turnWorkspaceParams(live.runtime, live.workspace, live.sandbox),
                     approvalPolicy: live.approvalPolicy,
-                    ...(live.model ? { model: live.model } : {}),
-                    ...(live.reasoningEffort ? { effort: live.reasoningEffort } : {}),
                 });
-                if (pendingInput.state === "prepublished") {
-                    // The caller already persisted and published this user input before
-                    // waiting for the native Terminal to become ready.
-                }
-                else if (pendingInput.observed) {
+                pendingInput.responseId = `resp_codex_${started.turnId}`;
+                if (pendingInput.observed)
                     forgetPendingInput();
-                }
-                else {
-                    live.publishInjectedInput(started.turnId, pendingInput.content);
-                    pendingInput.state = "optimistic";
-                }
-                return "injected";
+                else
+                    pendingInput.state = "accepted";
+                // 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);
+                return { outcome: "injected", responseId: `resp_codex_${started.turnId}` };
             }
             catch (error) {
                 forgetPendingInput();
+                if (error instanceof CodexRuntimeError &&
+                    (error.code === "collaboration_mode_model_unknown" ||
+                        error.code === "collaboration_mode_instructions_unknown")) {
+                    throw error;
+                }
                 // 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;
+                // A turn may open on the observer while this short-lived client is
+                // initializing, converting the submission to steer. A rejected steer
+                // does not fail that already-running Turn; only a new-Turn admission
+                // owns the terminal failed edge.
+                if (admissionPublished && injectionMethod === "turn/start") {
+                    live.publishTurnAdmissionFailure(detail);
+                }
                 console.error(`[codex-live] session=${localThreadId} runtime=${live.runtime} injection failed: ${detail}`);
-                throw new Error(detail, { cause: error });
+                throw nativeLiveFailure(live.runtime, "native_message_injection_failed", `message injection via ${injectionMethod} failed`, detail);
+            }
+            finally {
+                await injectionClient.stop().catch((stopError) => {
+                    console.warn(`[codex-live] session=${localThreadId} runtime=${live.runtime} injection client cleanup failed: ${stopError instanceof Error ? stopError.message : String(stopError)}`);
+                });
             }
         });
         live.injectLock = run.then(() => undefined, () => undefined);
@@ -1422,20 +2039,42 @@ 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;
+        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;
+        const interruptClient = this.injectionClientFactory(live.appServerUrl);
         try {
-            await live.injectClient.turnInterrupt({ threadId, turnId });
-            return true;
+            await interruptClient.ensureInitialized();
+            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 interruptClient.turnInterrupt({ threadId, turnId: "" });
+                }
+                catch (error) {
+                    console.warn(`[codex-live] session=${localThreadId} runtime=${live.runtime} MCP startup interrupt failed: ${codexRpcError(error, "turn/interrupt")}`);
+                }
+            }
+            if (turnId) {
+                try {
+                    await interruptClient.turnInterrupt({ threadId, turnId });
+                    live.publishInterrupted(`resp_codex_${turnId}`);
+                    handled = true;
+                }
+                catch {
+                    // The startup cancellation above is still a handled Stop operation.
+                }
+            }
+            return handled;
         }
-        catch {
-            return false;
+        finally {
+            await interruptClient.stop().catch(() => undefined);
         }
     }
     /** Stop + drop a session's live forwarder and its dedicated connection (session
@@ -1446,6 +2085,7 @@ export class LocalAgentHost {
             this.liveClaudeSessions.delete(localThreadId);
             claude.stopped = true;
             claude.forwarder.stop();
+            this.trackCleanup(claude.forwarder.waitForStop());
             if (opts.deferClaudeInteractionCleanup) {
                 this.pendingClaudeFinalizers.add(claude.forwarder);
             }
@@ -1453,8 +2093,6 @@ export class LocalAgentHost {
                 claude.forwarder.finalizeStop();
             }
             removeManagedClaudeSettings(claude.bridgeDir);
-            // Remove the throwaway skills --plugin-dir temp so it doesn't leak per launch.
-            void claude.skillCleanup?.();
             return;
         }
         const live = this.liveSessions.get(localThreadId);
@@ -1462,29 +2100,56 @@ export class LocalAgentHost {
             return;
         this.liveSessions.delete(localThreadId);
         live.stopped = true;
+        if (!live.threadId) {
+            live.startupError ??= nativeLiveFailure(live.runtime, "native_thread_discovery_stopped", "Session stopped before native thread discovery completed");
+            live.markStartupFailed();
+        }
         live.releaseActive?.();
-        live.injectClient.cancelInteractions("session_stopped");
+        live.cancelSyntheticInteractions("session_stopped");
+        live.appServerOwner.cancelInteractions("session_stopped");
         live.forwarderClient.cancelInteractions("session_stopped");
-        live.injectClient.setInteractionListener(null);
+        live.appServerOwner.setInteractionListener(null);
         live.forwarderClient.setInteractionListener(null);
-        live.injectClient.setConnectionListener(null);
+        live.appServerOwner.setConnectionListener(null);
         live.forwarderClient.setConnectionListener(null);
-        live.interactionOwners.clear();
-        live.interactionStandbys.clear();
-        live.interactionSubmissions.clear();
         live.forwarder.stop();
-        live.interactionRecoveries.clear();
-        live.interactionFailedClients.clear();
-        live.disconnectedClients.clear();
         live.canonicalInteractions.clear();
         live.settledInteractions.clear();
-        void live.forwarderClient.stop().catch(() => undefined);
+        live.syntheticInteractions.clear();
+        this.trackCleanup(live.forwarderClient.stop().catch(() => undefined));
         // Remove the session-scoped skills dir — the machine keeps zero task residue.
-        void live.skillsCleanup?.();
+        if (live.skillsCleanup)
+            this.trackCleanup(live.skillsCleanup());
+    }
+    /** Tear down one codex-lineage native runtime without deleting its durable
+     * session-store binding. reference implementation couples its auxiliary Terminal, observer,
+     * forwarder and per-session app-server as one disposable runtime envelope;
+     * the next message recreates that envelope and cold-resumes the native id. */
+    teardownLiveCodexSession(localThreadId, error) {
+        const live = this.liveSessions.get(localThreadId);
+        if (!live)
+            return false;
+        const turnFailed = error ? live.forwarder.failOpenTurn(error) : false;
+        const backendKey = live.runtime;
+        const backend = this.backends.get(backendKey);
+        const appServerOwner = live.appServerOwner;
+        this.stopLiveCodexSession(localThreadId);
+        if (backend?.appServerClient === appServerOwner) {
+            this.backends.delete(backendKey);
+        }
+        this.trackCleanup(appServerOwner.stop().catch((stopError) => {
+            console.warn(`[codex-live] session=${localThreadId} runtime=${live.runtime} app-server teardown failed: ${stopError instanceof Error ? stopError.message : String(stopError)}`);
+        }));
+        return turnFailed;
+    }
+    async teardownAuxiliaryTerminalRuntime(localThreadId) {
+        const owner = this.liveSessions.get(localThreadId)?.appServerOwner;
+        this.teardownLiveCodexSession(localThreadId);
+        await owner?.stop().catch(() => undefined);
     }
     /** Complete the second shutdown phase after the runner has killed all native
      * terminals and hook subprocesses. Must run before the runner process exits. */
-    finalizeStoppedLiveSessions() {
+    async finalizeStoppedLiveSessions() {
         for (const forwarder of this.pendingClaudeFinalizers)
             forwarder.finalizeStop();
         this.pendingClaudeFinalizers.clear();
@@ -1493,10 +2158,20 @@ export class LocalAgentHost {
         // that can only reconnect to a dead session. `stop()` sends SIGTERM before
         // its returned promise yields, so this remains safe in the synchronous
         // runner shutdown path.
-        for (const backend of this.backends.values()) {
-            void backend.appServerClient?.stop().catch(() => undefined);
-        }
+        const backendStops = [...this.backends.values()].map((backend) => backend.appServerClient?.stop().catch(() => undefined));
         this.backends.clear();
+        await Promise.all([
+            ...backendStops,
+            ...this.pendingCleanupTasks,
+        ]);
+        this.pendingCleanupTasks.clear();
+    }
+    trackCleanup(task) {
+        const guarded = task.catch((error) => {
+            console.warn(`[native-runtime] cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        this.pendingCleanupTasks.add(guarded);
+        void guarded.then(() => this.pendingCleanupTasks.delete(guarded));
     }
     // --- claude-native live session (parallel to the codex methods above) -----
     /** The interactive `claude` TUI spec for a claude-native live session: the real
@@ -1520,14 +2195,14 @@ export class LocalAgentHost {
         const effectiveSettings = applyClaudePermissionModeSnapshot(inheritedSettings, live.permissionMode);
         const hookPermissionMode = live.permissionMode;
         const hookSettings = buildClaudeHookSettings({
-            bridgeDir: claudeBridgeDir(localThreadId),
+            bridgeDir: live.bridgeDir,
             ...(hookPermissionMode ? { permissionMode: hookPermissionMode } : {}),
             messageDisplay: true,
             statusLine: true,
         });
         const settings = { ...effectiveSettings, ...hookSettings };
-        const settingsPath = writeManagedClaudeSettings(claudeBridgeDir(localThreadId), settings);
-        // The live session carries the immutable execution snapshot used by Chat.
+        const settingsPath = writeManagedClaudeSettings(live.bridgeDir, settings);
+        // 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
@@ -1535,26 +2210,32 @@ 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.instructions
-                ? { appendSystemPrompt: live.execution.instructions }
+            ...(live.execution.model ? { model: live.execution.model } : {}),
+            ...(live.execution.reasoningEffort
+                ? { reasoningEffort: live.execution.reasoningEffort }
+                : {}),
+            ...(nativeAuthoredInstructions(live.execution)
+                ? { appendSystemPrompt: nativeAuthoredInstructions(live.execution) }
                 : {}),
             additionalDirs: providerAdditionalDirs(live.workspace),
             ...(live.forkIntent
-                ? {
-                    resume: live.forkIntent.sourceClaudeSessionId,
-                    forkSession: true,
-                    sessionId: live.forkIntent.targetClaudeSessionId,
-                }
+                ? live.forkTranscriptPrepared
+                    ? { resume: live.forkIntent.targetClaudeSessionId }
+                    : { sessionId: live.forkIntent.targetClaudeSessionId }
                 : record?.codexSessionId
                     ? { resume: record.codexSessionId }
                     : {}),
             ...(live.launchExtraArgs.length ? { extraArgs: live.launchExtraArgs } : {}),
         });
         return {
+            lifecycle: "required",
             command: resolveRuntimeBinary("claude"),
             args,
             cwd,
+            scrollback: 50_000,
+            tmuxAllowPassthrough: false,
+            tmuxStartOnAttach: false,
+            keepAliveAfterExit: true,
             // Same env the pane would inherit by default, plus the session scope for
             // agent-run CLIs (rynx-emulator resolves device-less commands via it).
             env: { ...process.env, RYNX_SESSION_ID: localThreadId },
@@ -1656,30 +2337,117 @@ export class LocalAgentHost {
             throw error;
         }
     }
+    /** Repair the only cross-process crash window in native rotation. A target
+     * started through the Session registry proves that logical publication is
+     * durable; a published target in turn proves its source must no longer own
+     * the shared live bridge. */
+    async reconcileClaudeNativeRotation(localThreadId, record) {
+        const records = await this.sessionStore.listAll();
+        let current = record;
+        const ownTarget = current?.nativeRotationSourceSessionId
+            ? current
+            : undefined;
+        let promotedOwnTarget = false;
+        const ownTargetSharedBridgeOwner = ownTarget?.bridgeOwnerSessionId;
+        if (ownTarget && !ownTarget.nativeRotationPublished) {
+            promotedOwnTarget = true;
+            current = {
+                ...ownTarget,
+                // Recovery cannot resume the interrupted physical handoff. Give the
+                // visible target its own bridge before publishing it, so a source that
+                // was reopened first can never share hooks/cursors with this process.
+                // The persisted initial transcript offset remains the replay boundary.
+                bridgeOwnerSessionId: ownTarget.localThreadId,
+                nativeRotationPublished: true,
+                updatedAt: new Date().toISOString(),
+            };
+            await this.sessionStore.set(current);
+        }
+        const linkedTarget = current?.nativeRotationTargetSessionId
+            ? records.find((candidate) => candidate.localThreadId === current?.nativeRotationTargetSessionId &&
+                candidate.nativeRotationPublished &&
+                candidate.nativeRotationSourceSessionId === localThreadId)
+            : undefined;
+        const legacyLatestTarget = records
+            .filter((candidate) => candidate.nativeRotationPublished &&
+            candidate.nativeRotationSourceSessionId === localThreadId)
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) ||
+            b.localThreadId.localeCompare(a.localThreadId))[0];
+        // A Session can be both an inbound target (A→B) and later an outbound
+        // source (B→C). Its latest outbound edge is authoritative for reopening B;
+        // choosing B's older inbound marker would reopen the bridge now owned by C.
+        const publishedTarget = linkedTarget ?? legacyLatestTarget ??
+            (current?.nativeRotationSourceSessionId && current.nativeRotationPublished
+                ? current
+                : undefined);
+        if (publishedTarget) {
+            const source = await this.sessionStore.get(publishedTarget.nativeRotationSourceSessionId);
+            const kind = publishedTarget.nativeRotationKind ?? "clear";
+            const retiredBridgeOwner = `${source?.localThreadId ?? localThreadId}-${kind}-retired-${publishedTarget.localThreadId}`;
+            // A source can rotate more than once after its old conversation is
+            // reopened. Never let opening an historical target roll the source's
+            // authoritative outbound link back from S->T2 to the older S->T1 edge.
+            // Records written before nativeRotationTargetSessionId existed are only
+            // repairable when source and target still prove they share one bridge.
+            const sharedBridgeProof = promotedOwnTarget && publishedTarget.localThreadId === current?.localThreadId
+                ? ownTargetSharedBridgeOwner
+                : publishedTarget.bridgeOwnerSessionId;
+            const isAuthoritativeTarget = source && (source.nativeRotationTargetSessionId === publishedTarget.localThreadId ||
+                (!source.nativeRotationTargetSessionId &&
+                    source.bridgeOwnerSessionId === sharedBridgeProof));
+            if (isAuthoritativeTarget && source.bridgeOwnerSessionId !== retiredBridgeOwner) {
+                const retired = {
+                    ...source,
+                    bridgeOwnerSessionId: retiredBridgeOwner,
+                    nativeRotationTargetSessionId: publishedTarget.localThreadId,
+                    updatedAt: new Date().toISOString(),
+                };
+                await this.sessionStore.set(retired);
+                if (source.localThreadId === localThreadId)
+                    current = retired;
+            }
+        }
+        return current;
+    }
     async startLiveClaudeSession(localThreadId, emit, record, opts) {
         const retargetMirror = opts.retargetMirror;
+        record = await this.reconcileClaudeNativeRotation(localThreadId, record);
         const forkIntent = await this.sessionStore.getClaudeForkIntent?.(localThreadId) ?? null;
         if (forkIntent && forkIntent.targetSessionId !== localThreadId) {
             throw new CodexRuntimeError("Claude fork intent targets a different Session", 409, "invalid_fork_intent");
         }
-        const bridgeDir = prepareClaudeBridgeDir(localThreadId);
+        const runtimeHomeOwnerSessionId = record?.runtimeHomeOwnerSessionId ?? localThreadId;
+        const bridgeOwnerSessionId = record?.bridgeOwnerSessionId ?? runtimeHomeOwnerSessionId;
+        const bridgeDir = prepareClaudeBridgeDir(bridgeOwnerSessionId);
         const workspace = structuredClone(opts.workspace);
         const execution = structuredClone(opts.execution);
         if (execution.provider !== "claude") {
             throw new CodexRuntimeError(`cannot launch Claude from ${execution.provider} execution snapshot`, 422, "invalid_execution_snapshot");
         }
         const cwd = workspace.cwd;
-        let snapshotSkills;
-        try {
-            snapshotSkills = await this.prepareExecutionSkills(execution);
-        }
-        catch (err) {
-            console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
-            return false;
+        const forkResumePrefixBytes = forkIntent?.forkTranscriptPrefixBytes;
+        const forkTranscriptPrepared = Boolean(forkIntent?.forkTranscriptPath);
+        const hasSkillSnapshot = execution.skills.length > 0 || execution.pluginSkills.length > 0;
+        let skillPlugin = hasSkillSnapshot
+            ? await reuseClaudePlugin(localThreadId)
+            : null;
+        if (!skillPlugin && hasSkillSnapshot) {
+            let snapshotSkills;
+            try {
+                snapshotSkills = await this.prepareExecutionSkills(execution);
+            }
+            catch (err) {
+                console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
+                return false;
+            }
+            try {
+                skillPlugin = await materializeClaudePlugin(localThreadId, snapshotSkills.selectedSkills);
+            }
+            finally {
+                await snapshotSkills.skillsCleanup();
+            }
         }
-        const model = execution.model;
-        const skillPlugin = await materializeSkillPlugin(snapshotSkills.selectedSkills);
-        void snapshotSkills.skillsCleanup();
+        const model = execution.model ?? "";
         const permissionMode = execution.permissionMode;
         const launchExtraArgs = [
             ...(skillPlugin?.pluginDir ? ["--plugin-dir", skillPlugin.pluginDir] : []),
@@ -1690,28 +2458,118 @@ export class LocalAgentHost {
         let currentSessionId = localThreadId;
         let normalizer = null;
         let currentResponseId;
+        const subagentParentResponseIds = new Map();
+        const lateSubagentNormalizers = new Map();
         let pendingRotationEvents = null;
-        const emitCurrent = (event) => {
+        let rotationPublication = null;
+        let transcriptDelivery = null;
+        const emitRotationAware = (event, delivery) => {
             if (pendingRotationEvents) {
-                pendingRotationEvents.push(event);
+                pendingRotationEvents.push({ event, ...(delivery ? { delivery } : {}) });
                 return;
             }
-            emit(event);
+            return emit(event, delivery);
+        };
+        const publishForwarderFailure = (reason, responseId) => {
+            void Promise.resolve().then(() => emitRotationAware({
+                type: "session.status",
+                sessionId: currentSessionId,
+                ...(responseId ? { responseId } : {}),
+                status: "failed",
+                backgroundTaskCount: 0,
+                note: reason,
+            }, { policy: "best-effort", lane: "claude-forwarder-failure" })).catch((error) => {
+                console.error("[claude-forwarder] failed to publish poison-item status:", error);
+            });
+        };
+        const emitCurrent = (event, delivery) => {
+            if (pendingRotationEvents) {
+                pendingRotationEvents.push({ event, ...(delivery ? { delivery } : {}) });
+                return;
+            }
+            const source = transcriptDelivery;
+            if (source && isDurableSessionEvent(event)) {
+                const sourceId = `${source.sourceBase}:${source.nextItemIndex}:${event.item.type}`;
+                source.nextItemIndex += 1;
+                source.sourceIds.push(sourceId);
+                if (source.isHandled(sourceId))
+                    return;
+                const policy = delivery?.policy ?? "ordinary";
+                const pending = Promise.resolve(emit(event, {
+                    policy,
+                    sourceId,
+                    lane: delivery?.lane ?? source.lane,
+                    ...(policy === "ordinary"
+                        ? { deadLetterPath: delivery?.deadLetterPath ?? source.deadLetterPath }
+                        : {}),
+                    onOutcome: (outcome) => {
+                        delivery?.onOutcome?.(outcome);
+                        if (policy === "ordinary" &&
+                            outcome === "dropped" &&
+                            !source.lane.startsWith("claude-subagent:")) {
+                            publishForwarderFailure(`transcript item ${sourceId} rejected`, event.item.responseId);
+                        }
+                    },
+                })).then(() => {
+                    source.onHandled?.(sourceId);
+                });
+                source.pending.push(pending);
+                return pending;
+            }
+            return emit(event, delivery ?? { policy: "best-effort" });
         };
         const startNormalizer = (turnId) => {
             // turnId unknown → fixed literal (never random), aligning reference implementation `_response_id`.
-            const responseId = live.pendingInjectedInputs.find((entry) => entry.responseId)?.responseId ??
-                (turnId ? `resp_claude_${turnId}` : "resp_claude_native");
+            const responseId = turnId ? `resp_claude_${turnId}` : "resp_claude_native";
             if (normalizer && currentResponseId === responseId)
                 return normalizer;
             currentResponseId = responseId;
             normalizer = new SessionNormalizer({
                 sessionId: currentSessionId,
                 responseId,
-                model,
+                model: model || "claude",
             });
             return normalizer;
         };
+        const rememberSubagentParentResponse = (parentToolCallId, responseId) => {
+            if (subagentParentResponseIds.has(parentToolCallId))
+                return;
+            subagentParentResponseIds.set(parentToolCallId, responseId);
+            while (subagentParentResponseIds.size > 2_000) {
+                const oldest = subagentParentResponseIds.keys().next().value;
+                if (!oldest)
+                    break;
+                subagentParentResponseIds.delete(oldest);
+                lateSubagentNormalizers.delete(oldest);
+            }
+        };
+        const subagentNormalizer = (parentToolCallId) => {
+            let value = lateSubagentNormalizers.get(parentToolCallId);
+            if (!value) {
+                const responseId = subagentParentResponseIds.get(parentToolCallId) ??
+                    `resp_claude_parent_${createHash("sha256")
+                        .update(parentToolCallId)
+                        .digest("hex")
+                        .slice(0, 20)}`;
+                value = new SessionNormalizer({
+                    sessionId: currentSessionId,
+                    responseId,
+                    model: model || "claude",
+                });
+                lateSubagentNormalizers.set(parentToolCallId, value);
+            }
+            return value;
+        };
+        const emitSubagentEvents = (events) => {
+            for (const event of events) {
+                // Rynx keeps native child items nested in the parent Session, but its
+                // child normalizer remains
+                // lifecycle-isolated and must never open/reopen a parent Response.
+                if ((event.type === "response.created" || event.type === "session.status"))
+                    continue;
+                emitCurrent(event);
+            }
+        };
         const forwardInteraction = (event) => {
             const n = normalizer ?? startNormalizer(event.turnId);
             const agentEvent = event.type === "requested"
@@ -1727,8 +2585,20 @@ export class LocalAgentHost {
                         interactionId: event.interactionId,
                         ...(event.reason ? { reason: event.reason } : {}),
                     };
-            for (const se of n.next(agentEvent))
-                emitCurrent(se);
+            // Permission/question elicitation stays on a separate live hook
+            // side-channel rather than the durable transcript forwarder. Rynx stores
+            // a delivered card for UI replay, but intentionally does not make this
+            // bridge spool advance or block the transcript cursor.
+            for (const se of n.next(agentEvent)) {
+                try {
+                    void Promise.resolve(emitRotationAware(se, { policy: "best-effort", lane: "claude-interaction" })).catch((error) => {
+                        console.error("[claude-forwarder] interaction mirror failed:", error);
+                    });
+                }
+                catch (error) {
+                    console.error("[claude-forwarder] interaction mirror failed:", error);
+                }
+            }
         };
         let markReady;
         const ready = new Promise((resolve) => {
@@ -1743,9 +2613,14 @@ export class LocalAgentHost {
             workspace,
             execution,
             bridgeDir,
+            runtimeHomeOwnerSessionId,
+            bridgeOwnerSessionId,
             injectLock: Promise.resolve(),
+            rotationPending: false,
             pendingImageInputs: new Map(),
             pendingInjectedInputs: [],
+            currentResponseId: () => currentResponseId,
+            publishInterrupted: () => undefined,
             ready,
             markReady,
             failed,
@@ -1755,9 +2630,93 @@ export class LocalAgentHost {
             launchExtraArgs,
             permissionMode,
             ...(forkIntent ? { forkIntent } : {}),
-            ...(skillPlugin?.cleanup ? { skillCleanup: skillPlugin.cleanup } : {}),
+            ...(forkResumePrefixBytes !== undefined ? { forkResumePrefixBytes } : {}),
+            ...(forkTranscriptPrepared ? { forkTranscriptPrepared: true } : {}),
+        };
+        live.publishInterrupted = (responseId) => {
+            if (live.interruptedResponseId === responseId)
+                return;
+            live.interruptedResponseId = responseId;
+            emitCurrent({
+                type: "session.interrupted",
+                sessionId: currentSessionId,
+                responseId,
+            });
+        };
+        const settleClaudeTurn = (interrupted, usage, backgroundTaskCount, reason) => {
+            if (!normalizer)
+                return;
+            const settlementDelivery = reason === "rotation"
+                ? { policy: "best-effort", lane: "control" }
+                : undefined;
+            const publishSettlement = (event) => {
+                void emitCurrent(event, settlementDelivery);
+            };
+            const rid = currentResponseId;
+            if (interrupted) {
+                for (const se of normalizer.interrupt()) {
+                    if (se.type === "session.interrupted" &&
+                        live.interruptedResponseId === rid)
+                        continue;
+                    publishSettlement(se);
+                }
+                live.interruptedResponseId = undefined;
+            }
+            else {
+                // statusLine usage (context/cost) rides the turn's response.completed.
+                if (usage) {
+                    for (const se of normalizer.next({ type: "turn_completed", usage })) {
+                        publishSettlement(se);
+                    }
+                }
+                for (const se of normalizer.next({ type: "done" })) {
+                    publishSettlement(se.type === "session.status" && backgroundTaskCount !== undefined
+                        ? { ...se, backgroundTaskCount }
+                        : se);
+                }
+            }
+            live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
+            normalizer = null;
+            currentResponseId = undefined;
+            // One-time context-window banner past CONTEXT_WARN_RATIO (a transient note,
+            // cleared by the next turn's first item). statusLine pre-computes the %.
+            const pct = usage && typeof usage.used_percentage === "number" ? usage.used_percentage : undefined;
+            if (!interrupted && rid && pct !== undefined && !live.contextWarned && pct >= CONTEXT_WARN_RATIO * 100) {
+                live.contextWarned = true;
+                publishSettlement({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    responseId: rid,
+                    status: "idle",
+                    note: `context ${Math.round(pct)}% full — consider /compact`,
+                });
+            }
         };
         const sink = {
+            onTranscriptRecordStart: (sourceBase, isHandled, delivery) => {
+                if (transcriptDelivery) {
+                    throw new Error("Claude transcript delivery record overlapped");
+                }
+                transcriptDelivery = {
+                    sourceBase,
+                    nextItemIndex: 0,
+                    isHandled,
+                    sourceIds: [],
+                    pending: [],
+                    lane: delivery?.lane ?? "claude-main",
+                    deadLetterPath: delivery?.deadLetterPath ??
+                        path.join(bridgeDir, "dead_letter.jsonl"),
+                    ...(delivery?.onHandled ? { onHandled: delivery.onHandled } : {}),
+                };
+            },
+            onTranscriptRecordEnd: async () => {
+                const source = transcriptDelivery;
+                if (!source)
+                    return [];
+                transcriptDelivery = null;
+                await Promise.all(source.pending);
+                return source.sourceIds;
+            },
             onTurnStart: (turnId) => startNormalizer(turnId),
             onUserMessage: (text) => {
                 const n = normalizer ?? startNormalizer();
@@ -1766,141 +2725,361 @@ export class LocalAgentHost {
                 if (token && content)
                     live.pendingImageInputs.delete(token);
                 const normalizedContent = content ?? [{ type: "input_text", text }];
-                const signature = JSON.stringify(normalizedContent);
-                const pending = live.pendingInjectedInputs.find((entry) => entry.signature === signature);
-                if (pending?.state === "prepublished" || pending?.state === "optimistic") {
-                    live.pendingInjectedInputs.splice(live.pendingInjectedInputs.indexOf(pending), 1);
-                    return;
-                }
-                if (pending)
+                const pending = live.pendingInjectedInputs[0];
+                if (pending) {
+                    pending.responseId = currentResponseId;
                     pending.observed = true;
+                    if (pending.state === "accepted") {
+                        live.pendingInjectedInputs.shift();
+                    }
+                }
                 for (const se of n.userInput(normalizedContent))
                     emitCurrent(se);
             },
+            onMetaUserMessage: (text, sourceKey, parentToolCallId) => {
+                const responseId = parentToolCallId
+                    ? subagentParentResponseIds.get(parentToolCallId) ??
+                        `resp_claude_parent_${createHash("sha256")
+                            .update(parentToolCallId)
+                            .digest("hex")
+                            .slice(0, 20)}`
+                    : `resp_claude_meta_${createHash("sha256")
+                        .update(sourceKey ?? text)
+                        .digest("hex")
+                        .slice(0, 20)}`;
+                const metaNormalizer = new SessionNormalizer({
+                    sessionId: currentSessionId,
+                    responseId,
+                    model: model || "claude",
+                });
+                for (const event of metaNormalizer.userInput(text, parentToolCallId)) {
+                    if (event.type !== "session.input.consumed" || event.item.type !== "message")
+                        continue;
+                    emitCurrent({
+                        ...event,
+                        item: {
+                            ...event.item,
+                            data: { ...event.item.data, isMeta: true },
+                        },
+                    });
+                }
+            },
+            onSubagentUserMessage: (text, parentToolCallId) => {
+                const nested = subagentNormalizer(parentToolCallId);
+                emitSubagentEvents(nested.userInput(text, parentToolCallId));
+            },
+            onSubagentTerminalCommand: (command, parentToolCallId) => {
+                const nested = subagentNormalizer(parentToolCallId);
+                emitSubagentEvents(nested.terminalCommand(command, parentToolCallId));
+            },
+            resolveSubagentParentResponseId: (parentToolCallId) => subagentParentResponseIds.get(parentToolCallId),
+            onSubagentParentResponse: (parentToolCallId, responseId) => {
+                rememberSubagentParentResponse(parentToolCallId, responseId);
+            },
             onTerminalCommand: (cmd) => {
                 const n = normalizer ?? startNormalizer();
                 for (const se of n.terminalCommand(cmd))
                     emitCurrent(se);
             },
             onTodos: (todos) => emitCurrent({ type: "session.todos", sessionId: currentSessionId, todos }),
+            onCompactionStatus: (status) => {
+                void emitCurrent({
+                    type: `response.compaction.${status}`,
+                    sessionId: currentSessionId,
+                    ...(currentResponseId ? { responseId: currentResponseId } : {}),
+                }, { policy: "best-effort", lane: "claude-compaction" });
+            },
+            onCompactionBoundary: (summary, sequence, source) => {
+                let outcome;
+                const responseId = currentResponseId ?? "resp_claude_native";
+                const delivery = emitCurrent({
+                    type: "response.output_item.done",
+                    responseId,
+                    item: {
+                        id: newSessionItemId("compaction"),
+                        sessionId: currentSessionId,
+                        position: 0,
+                        responseId,
+                        status: "completed",
+                        createdAt: Date.now(),
+                        type: "compaction",
+                        data: { summary, sequence },
+                    },
+                }, {
+                    policy: source === "transcript" ? "compaction" : "compaction-hook",
+                    // A transcript compaction is still one ordered transcript record.
+                    // Only the independent hook boundary gets its own delivery lane.
+                    lane: source === "transcript" ? "claude-main" : "claude-compaction",
+                    onOutcome: (value) => { outcome = value; },
+                });
+                return Promise.resolve(delivery).then(() => outcome === undefined || outcome === "confirmed" || outcome === "ambiguous");
+            },
             onEvent: (event) => {
+                const parentToolCallId = "parentToolUseId" in event &&
+                    typeof event.parentToolUseId === "string"
+                    ? event.parentToolUseId
+                    : undefined;
+                if (parentToolCallId) {
+                    const nested = subagentNormalizer(parentToolCallId);
+                    emitSubagentEvents(nested.next(event));
+                    return;
+                }
                 const n = normalizer ?? startNormalizer();
+                if (currentResponseId &&
+                    event.type === "tool" &&
+                    event.event === "on_tool_start") {
+                    const input = typeof event.input === "object" && event.input !== null
+                        ? event.input
+                        : {};
+                    const data = typeof event.data === "object" && event.data !== null
+                        ? event.data
+                        : {};
+                    const parentId = typeof input.id === "string"
+                        ? input.id
+                        : typeof data.id === "string"
+                            ? data.id
+                            : undefined;
+                    if (parentId)
+                        rememberSubagentParentResponse(parentId, currentResponseId);
+                }
                 for (const se of n.next(event))
                     emitCurrent(se);
             },
             onInteraction: forwardInteraction,
-            onTurnEnd: (usage) => {
-                if (!normalizer)
-                    return;
-                const rid = currentResponseId;
-                // statusLine usage (context/cost) rides the turn's response.completed.
-                if (usage) {
-                    for (const se of normalizer.next({ type: "turn_completed", usage }))
-                        emitCurrent(se);
-                }
-                for (const se of normalizer.next({ type: "done" }))
-                    emitCurrent(se);
-                live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
-                normalizer = null;
-                currentResponseId = undefined;
-                // One-time context-window banner past CONTEXT_WARN_RATIO (a transient note,
-                // cleared by the next turn's first item). statusLine pre-computes the %.
-                const pct = usage && typeof usage.used_percentage === "number" ? usage.used_percentage : undefined;
-                if (rid && pct !== undefined && !live.contextWarned && pct >= CONTEXT_WARN_RATIO * 100) {
-                    live.contextWarned = true;
-                    emitCurrent({
-                        type: "session.status",
-                        sessionId: currentSessionId,
-                        responseId: rid,
-                        status: "idle",
-                        note: `context ${Math.round(pct)}% full — consider /compact`,
-                    });
-                }
+            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 } : {}),
+                });
             },
-            onIdle: () => {
-                // Surface idle on the current turn WITHOUT finalizing it (see the sink's
-                // onIdle doc): a late assistant record still joins this response.
-                if (currentResponseId) {
-                    emitCurrent({
+            onTurnEnd: (usage, backgroundTaskCount, reason) => settleClaudeTurn(false, usage, backgroundTaskCount, reason),
+            onTurnInterrupted: (usage) => settleClaudeTurn(true, usage),
+            onTurnInterruptRequested: () => {
+                const responseId = currentResponseId;
+                if (responseId)
+                    live.publishInterrupted(responseId);
+            },
+            onIdle: (backgroundTaskCount, sourceId) => {
+                // Surface Stop even after its Turn has already closed: a later
+                // authoritative zero is what clears a sticky background-shell tally.
+                // When the Turn is still open, retain its identity without finalizing it
+                // so a late assistant record continues to join the same Response.
+                return emitCurrent({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    ...(currentResponseId ? { responseId: currentResponseId } : {}),
+                    status: "idle",
+                    ...(backgroundTaskCount === undefined ? {} : { backgroundTaskCount }),
+                }, {
+                    policy: "terminal-status",
+                    lane: "claude-status",
+                    ...(sourceId ? { sourceId } : {}),
+                    onOutcome: (outcome) => {
+                        if (outcome === "dropped") {
+                            publishForwarderFailure(`hook status idle rejected`, currentResponseId);
+                        }
+                    },
+                });
+            },
+            onTurnError: (error, sourceId) => {
+                const message = error.message || "Agent turn failed";
+                if (!normalizer) {
+                    // Native pane/forwarder death is Session-level even when Claude is
+                    // between Turns. Emit a bare failed edge; the
+                    // explicit zero also retires any sticky background-shell tally.
+                    return emitCurrent({
                         type: "session.status",
                         sessionId: currentSessionId,
-                        responseId: currentResponseId,
-                        status: "idle",
+                        status: "failed",
+                        backgroundTaskCount: 0,
+                        note: message,
+                    }, {
+                        policy: "terminal-status",
+                        lane: "claude-status",
+                        ...(sourceId ? { sourceId } : {}),
                     });
                 }
-            },
-            onTurnError: () => {
-                if (!normalizer)
-                    return;
                 const rid = currentResponseId;
+                const deliveries = [];
+                let itemIndex = 0;
                 for (const se of normalizer.fail({
                     code: "agent_error",
-                    message: "Agent turn failed",
+                    message,
                     source: "execution",
-                }))
-                    emitCurrent(se);
+                })) {
+                    const event = se.type === "session.status"
+                        ? { ...se, status: "failed", note: message }
+                        : se;
+                    const durable = isDurableSessionEvent(event);
+                    const eventSourceId = sourceId
+                        ? `${sourceId}:${itemIndex++}:${durable && "item" in event ? event.item.type : event.type}`
+                        : undefined;
+                    const delivered = emitCurrent(event, {
+                        policy: durable ? "ordinary" : "terminal-status",
+                        lane: "claude-status",
+                        ...(eventSourceId ? { sourceId: eventSourceId } : {}),
+                        ...(durable
+                            ? { deadLetterPath: path.join(bridgeDir, "dead_letter.jsonl") }
+                            : {}),
+                    });
+                    if (delivered)
+                        deliveries.push(Promise.resolve(delivered));
+                }
                 live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
                 normalizer = null;
                 currentResponseId = undefined;
+                return Promise.all(deliveries).then(() => undefined);
             },
             onSessionDiscovered: (claudeSessionId) => this.onClaudeDiscovered(live, localThreadId, claudeSessionId),
             onSessionResumeError: (error) => {
                 live.error = error.message;
                 live.markFailed();
             },
-            onSessionRotated: (kind, claudeSessionId) => {
-                if (pendingRotationEvents) {
-                    live.error = "Claude reported another Session rotation before publication completed";
-                    live.markFailed();
-                    return;
+            onSessionRotated: (kind, claudeSessionId, _transcriptPath, initialTranscriptOffset) => {
+                let publication = rotationPublication?.claudeSessionId === claudeSessionId &&
+                    rotationPublication.kind === kind
+                    ? rotationPublication
+                    : null;
+                if (publication?.operation)
+                    return publication.operation;
+                if (publication?.completed)
+                    return Promise.resolve();
+                if (!publication && pendingRotationEvents) {
+                    return Promise.reject(new Error("Claude reported another Session rotation before publication completed"));
                 }
-                // The forwarder already closed the old turn (onTurnEnd) + re-pointed to the
-                // new transcript. Persist the Provider binding first, then announce on
-                // the OLD session and re-target the mirror. Events produced during the
-                // file-store commit are buffered so none can land under the old identity.
-                const previousSessionId = currentSessionId;
-                const newSessionId = makeSessionId();
-                currentSessionId = newSessionId;
-                normalizer = null;
-                currentResponseId = undefined;
-                live.contextWarned = false;
-                pendingRotationEvents = [];
-                this.liveClaudeSessions.set(newSessionId, live);
-                void this.sessionStore
-                    .set({
-                    localThreadId: newSessionId,
-                    codexSessionId: claudeSessionId,
-                    ...(kind === "fork" ? { parentSessionId: previousSessionId } : {}),
-                    updatedAt: new Date().toISOString(),
-                })
-                    .then(() => {
-                    emit({
-                        type: "session.rotated",
-                        sessionId: previousSessionId,
-                        newSessionId,
+                // Persist the Provider binding, then wait for the runner manager to
+                // publish and ACK the new alias. The parent announces the rotation on
+                // the OLD Session only after that target publication succeeds.
+                // The forwarder does not consume the SessionStart hook or switch source
+                // state until this operation resolves.
+                if (!publication) {
+                    // Claude has already crossed its physical clear/fork boundary by the
+                    // time this hook arrives. Fence injection synchronously, before the
+                    // first asynchronous target-store operation or IPC publication.
+                    live.rotationPending = true;
+                    publication = {
+                        claudeSessionId,
                         kind,
+                        initialTranscriptOffset,
+                        previousSessionId: currentSessionId,
+                        newSessionId: makeSessionId(),
+                    };
+                    rotationPublication = publication;
+                }
+                const { previousSessionId } = publication;
+                // An exact publication retry keeps events buffered during the failed
+                // attempt; they already belong to this same post-rotation target.
+                pendingRotationEvents ??= [];
+                const operation = this.sessionStore
+                    .findByCodexSessionId(claudeSessionId)
+                    .then(async (existingTarget) => {
+                    if (existingTarget &&
+                        existingTarget.localThreadId !== previousSessionId) {
+                        publication.newSessionId = existingTarget.localThreadId;
+                    }
+                    if (existingTarget?.nativeRotationInitialTranscriptOffset !== undefined) {
+                        publication.initialTranscriptOffset =
+                            existingTarget.nativeRotationInitialTranscriptOffset;
+                    }
+                    await this.sessionStore.set({
+                        localThreadId: publication.newSessionId,
+                        codexSessionId: claudeSessionId,
+                        ...(kind === "fork" ? { parentSessionId: previousSessionId } : {}),
+                        runtimeHomeOwnerSessionId: live.runtimeHomeOwnerSessionId,
+                        bridgeOwnerSessionId: live.bridgeOwnerSessionId,
+                        nativeRotationSourceSessionId: previousSessionId,
+                        nativeRotationKind: kind,
+                        nativeRotationInitialTranscriptOffset: publication.initialTranscriptOffset,
+                        ...(existingTarget?.nativeRotationPublished
+                            ? { nativeRotationPublished: true }
+                            : {}),
+                        updatedAt: new Date().toISOString(),
                     });
-                    retargetMirror?.(newSessionId, {
+                })
+                    .then(async () => {
+                    const applyHostTarget = async () => {
+                        if (publication.hostApplied)
+                            return;
+                        const newSessionId = publication.newSessionId;
+                        const targetBinding = await this.sessionStore.get(newSessionId);
+                        if (targetBinding && !targetBinding.nativeRotationPublished) {
+                            await this.sessionStore.set({
+                                ...targetBinding,
+                                nativeRotationPublished: true,
+                                updatedAt: new Date().toISOString(),
+                            });
+                        }
+                        const sourceBinding = await this.sessionStore.get(previousSessionId);
+                        const retiredBridgeOwner = `${previousSessionId}-${kind}-retired-${newSessionId}`;
+                        if (sourceBinding &&
+                            sourceBinding.bridgeOwnerSessionId !== retiredBridgeOwner) {
+                            await this.sessionStore.set({
+                                ...sourceBinding,
+                                bridgeOwnerSessionId: retiredBridgeOwner,
+                                nativeRotationTargetSessionId: newSessionId,
+                                updatedAt: new Date().toISOString(),
+                            });
+                        }
+                        currentSessionId = newSessionId;
+                        normalizer = null;
+                        currentResponseId = undefined;
+                        live.contextWarned = false;
+                        this.liveClaudeSessions.set(newSessionId, live);
+                        this.liveClaudeSessions.delete(previousSessionId);
+                        const queued = pendingRotationEvents ?? [];
+                        pendingRotationEvents = null;
+                        live.rotationPending = false;
+                        publication.hostApplied = true;
+                        for (const entry of queued) {
+                            emit(retargetSessionEvent(entry.event, newSessionId), entry.delivery);
+                        }
+                    };
+                    await Promise.resolve(retargetMirror?.(publication.newSessionId, {
                         kind,
                         workspace: structuredClone(live.workspace),
                         execution: structuredClone(live.execution),
                         ...(kind === "fork" ? { parentSessionId: previousSessionId } : {}),
-                    });
-                    const queued = pendingRotationEvents ?? [];
-                    pendingRotationEvents = null;
-                    for (const event of queued)
-                        emit(event);
+                        beforeApplied: applyHostTarget,
+                    }));
+                    if (!publication.hostApplied) {
+                        throw new Error("Claude retarget completed without applying the host target");
+                    }
+                    publication.completed = true;
                 })
                     .catch((error) => {
-                    pendingRotationEvents = null;
+                    // Keep the fence and buffered events across an exact publication
+                    // retry. Re-opening either here would leak post-clear work back to
+                    // the retired logical Session.
                     live.error = error instanceof Error ? error.message : String(error);
                     live.markFailed();
+                    if (typeof error === "object" &&
+                        error !== null &&
+                        "classification" in error &&
+                        error.classification === "permanent") {
+                        // A deterministic target-publication rejection cannot recover by
+                        // polling the same hook forever. Keep injection fenced and stop
+                        // the forwarder so restart/operator action is explicit.
+                        queueMicrotask(() => live.forwarder.stop());
+                    }
+                    throw error;
+                })
+                    .finally(() => {
+                    if (rotationPublication === publication) {
+                        delete publication.operation;
+                    }
                 });
+                publication.operation = operation;
+                return operation;
             },
         };
-        // Claude itself resolves `--resume <id>`. The SessionStart hook is the
-        // authoritative source for the actual transcript path; do not infer or
-        // generate Claude's private on-disk format here.
+        // Claude itself resolves `--resume <id>`. A managed fork pre-writes and
+        // measures its target prefix, but SessionStart remains authoritative for
+        // the transcript path the forwarder actually tails.
         live.forwarder = new ClaudeLiveSession({
             bridgeDir,
             sink,
@@ -1909,7 +3088,16 @@ export class LocalAgentHost {
                 : record?.codexSessionId
                     ? { claudeSessionId: record.codexSessionId }
                     : {}),
-            ...((forkIntent || record?.codexSessionId) ? { resumeAtEndOnDiscovery: true } : {}),
+            ...((record?.codexSessionId || forkTranscriptPrepared)
+                ? { resumeAtEndOnDiscovery: true }
+                : {}),
+            ...(forkResumePrefixBytes !== undefined
+                ? { initialTranscriptOffsetOnDiscovery: forkResumePrefixBytes }
+                : record?.nativeRotationInitialTranscriptOffset !== undefined
+                    ? {
+                        initialTranscriptOffsetOnDiscovery: record.nativeRotationInitialTranscriptOffset,
+                    }
+                    : {}),
         });
         this.liveClaudeSessions.set(localThreadId, live);
         live.forwarder.start();
@@ -1929,12 +3117,16 @@ export class LocalAgentHost {
         }
         live.discoveredReady = true;
         void this.sessionStore
-            .set({
+            .get(localThreadId)
+            .then((existing) => this.sessionStore.set({
+            ...existing,
             localThreadId,
             codexSessionId: claudeSessionId,
             ...(forkIntent ? { parentSessionId: forkIntent.sourceSessionId } : {}),
+            runtimeHomeOwnerSessionId: live.runtimeHomeOwnerSessionId,
+            bridgeOwnerSessionId: live.bridgeOwnerSessionId,
             updatedAt: new Date().toISOString(),
-        })
+        }))
             .then(() => this.sessionStore.deleteClaudeForkIntent?.(localThreadId))
             .then(() => live.markReady())
             .catch((error) => {
@@ -1946,17 +3138,27 @@ export class LocalAgentHost {
      *  serialized per session. Parks until the thread is ready AND the tmux injector
      *  is (re)attached, then pastes; `injectViaTerminal` RAISES if the prompt never
      *  appears (reference implementation RAISE), so a not-ready pane is a hard error — NOT a
-     *  fall-through-to-run signal. Returns {@link InjectOutcome}. */
-    injectClaude(live, localThreadId, text) {
+     *  fall-through-to-run signal. Returns {@link InjectResult}. */
+    injectClaude(live, localThreadId, text, pendingInput) {
+        if (live.rotationPending || live.stopped) {
+            return Promise.resolve({ outcome: "notReady" });
+        }
         const run = live.injectLock.then(async () => {
+            if (live.rotationPending || live.stopped)
+                return { outcome: "notReady" };
             const ready = await this.waitLiveReady(localThreadId, 60_000);
             if (!ready)
-                return "notReady";
+                return { outcome: "notReady" };
+            if (live.rotationPending || live.stopped)
+                return { outcome: "notReady" };
             // Pane may have just relaunched — park until its injector re-attaches
             // (attachTerminalInjector resets it) instead of returning false → fallback.
             const injector = await this.waitInjector(live, 60_000);
             if (!injector)
-                return "notReady";
+                return { outcome: "notReady" };
+            if (live.rotationPending || live.stopped)
+                return { outcome: "notReady" };
+            const steered = live.forwarder.isTurnOpen();
             // Abortable: the web Stop button cancels an in-flight paste/submit (before
             // the message reaches claude) via interruptLive → injectAbort.abort().
             const abort = new AbortController();
@@ -1967,10 +3169,17 @@ export class LocalAgentHost {
                     signal: abort.signal,
                     submissionObserved: () => live.forwarder.hasObservedSubmissionAfter(submissionCheckpoint, text),
                 });
-                return ok ? "injected" : "failed";
+                if (!ok)
+                    return { outcome: "failed" };
+                const responseId = pendingInput.responseId ?? live.currentResponseId();
+                return {
+                    outcome: steered ? "steered" : "injected",
+                    ...(responseId ? { responseId } : {}),
+                };
             }
-            catch {
-                return "failed";
+            catch (error) {
+                live.error = error instanceof Error ? error.message : String(error);
+                return { outcome: "failed" };
             }
             finally {
                 if (live.injectAbort === abort)
@@ -1992,12 +3201,31 @@ export class LocalAgentHost {
         return live.injector ?? null;
     }
     /** Attach a session's tmux pane injector (from the runner-child, which owns the
-     *  terminal registry — the host does not hold tmux). Ignored for codex sessions
-     *  (they inject via the app-server). Idempotent. */
+     *  terminal registry — the host does not hold tmux). Claude uses it for normal
+     *  message injection; Codex uses it only to dismiss the exact TUI-local Plan
+     *  picker after its synthetic Web form is submitted. 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?.() });
+            return;
+        }
+        const codex = this.liveSessions.get(localThreadId);
+        if (codex)
+            codex.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.noteTerminalExit(error);
+        const codex = this.liveSessions.get(localThreadId);
+        if (!codex)
+            return false;
+        return codex.forwarder.failOpenTurn(error);
     }
     /** List the models a runtime exposes (App Server for codex/traex; static for claude). */
     async listModels(runtime) {
@@ -2027,7 +3255,7 @@ export class LocalAgentHost {
             return { ok: false, reason: "unsupported" };
         }
         try {
-            return { ok: true, data: await fn(live.injectClient, record.codexSessionId) };
+            return { ok: true, data: await fn(live.appServerOwner, record.codexSessionId) };
         }
         catch (error) {
             return {
@@ -2099,8 +3327,8 @@ export class LocalAgentHost {
                 return { ok: true, data: undefined };
             }
             const runtime = execution.provider;
-            const client = live?.injectClient ??
-                this.getBackend(runtime, execution.budget ?? undefined).appServerClient;
+            const client = live?.appServerOwner ??
+                this.getBackend(runtime).appServerClient;
             if (!client) {
                 return { ok: false, reason: "unsupported" };
             }
@@ -2126,7 +3354,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,6 +3383,9 @@ export class LocalAgentHost {
                 codexSessionId: forkedThreadId,
                 parentSessionId: currentLocalThreadId,
                 runtimeHomeOwnerSessionId: sourceHomeOwner,
+                ...(record.bridgeOwnerSessionId
+                    ? { bridgeOwnerSessionId: record.bridgeOwnerSessionId }
+                    : {}),
                 updatedAt: new Date().toISOString(),
             });
             return { ok: true, data: undefined };
@@ -2168,11 +3399,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();
@@ -2197,20 +3428,100 @@ 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);
     });
 }
+/** Record the authoritative settings returned while binding an existing
+ * native thread. A Session-level explicit selection remains a pending desired
+ * override; otherwise the resumed thread itself is the source of truth. */
+function adoptResumedThreadSettings(live, settings) {
+    const model = settings.model?.trim();
+    if (model) {
+        live.mayUseProviderDefaultModel = false;
+        live.appliedModel = model;
+        if (!live.execution.model)
+            live.model = model;
+    }
+    if (settings.reasoningEffort !== undefined) {
+        live.appliedReasoningEffort = settings.reasoningEffort ?? undefined;
+        if (!live.execution.reasoningEffort) {
+            live.reasoningEffort = settings.reasoningEffort ?? undefined;
+        }
+    }
+}
+/** Resolve the model required by a full collaboration-mode snapshot. Only a
+ * fresh thread with no explicit/config model may use the catalog default; a
+ * resumed thread must report its own authoritative model. */
+async function resolveLiveCollaborationMode(client, live, mode, codexHome) {
+    let model = live.model.trim();
+    if (!model && live.mayUseProviderDefaultModel) {
+        let catalog;
+        try {
+            catalog = await client.modelList();
+        }
+        catch (error) {
+            throw new CodexRuntimeError(`collaboration mode requires the Provider default model: ${error instanceof Error ? error.message : String(error)}`, 503, "collaboration_mode_model_unknown");
+        }
+        const defaults = [...new Set(catalog.data
+                .filter((candidate) => candidate.isDefault === true)
+                .map((candidate) => (candidate.model || candidate.id).trim())
+                .filter(Boolean))];
+        if (defaults.length !== 1) {
+            throw new CodexRuntimeError(`collaboration mode requires exactly one Provider default model; Provider advertised ${defaults.length}`, 503, "collaboration_mode_model_unknown");
+        }
+        model = defaults[0];
+    }
+    let developerInstructions = null;
+    if (live.runtime === "codex") {
+        const state = codexHome
+            ? readCodexDeveloperInstructionsState(codexHome)
+            : { state: "unreadable" };
+        if (state.state === "unreadable") {
+            throw new CodexRuntimeError("collaboration mode requires the current developer instructions, but the private Codex config could not be read", 503, "collaboration_mode_instructions_unknown");
+        }
+        developerInstructions = state.state === "present" ? state.value : null;
+    }
+    return buildCollaborationMode(mode, model, live.reasoningEffort, developerInstructions);
+}
+/** Expand the public mode enum into the App Server's required settings
+ * snapshot using the Session's tracked effective model. */
+function buildCollaborationMode(mode, desiredModel, desiredReasoningEffort, developerInstructions) {
+    const model = desiredModel.trim();
+    if (!model) {
+        throw new CodexRuntimeError("collaboration mode requires the current model, but the Provider did not report one", 503, "collaboration_mode_model_unknown");
+    }
+    return {
+        mode,
+        settings: {
+            model,
+            reasoning_effort: desiredReasoningEffort ?? null,
+            developer_instructions: developerInstructions,
+        },
+    };
+}
+/** New snapshots distinguish authored Agent text from framework-rendered
+ * instructions. Older persisted snapshots fall back to their only available
+ * field so existing sessions preserve their launch behavior. */
+function nativeAuthoredInstructions(execution) {
+    const value = execution.authoredInstructions === undefined
+        ? execution.instructions
+        : execution.authoredInstructions;
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 function sameSessionSnapshots(workspace, execution, opts) {
     return JSON.stringify(stableValue({
         workspace,
@@ -2220,6 +3531,40 @@ function sameSessionSnapshots(workspace, execution, opts) {
         execution: opts.execution,
     }));
 }
+function sameImmutableSessionSnapshots(workspace, execution, opts) {
+    const current = {
+        ...execution,
+        model: null,
+        reasoningEffort: null,
+        collaborationMode: undefined,
+    };
+    const requested = {
+        ...opts.execution,
+        model: null,
+        reasoningEffort: null,
+        collaborationMode: undefined,
+    };
+    return JSON.stringify(stableValue({ workspace, execution: current })) ===
+        JSON.stringify(stableValue({ workspace: opts.workspace, execution: requested }));
+}
+function updateLiveCodexTurnSettings(live, opts) {
+    if (!sameImmutableSessionSnapshots(live.workspace, live.execution, opts)) {
+        return false;
+    }
+    const previousModel = live.execution.model;
+    const previousReasoningEffort = live.execution.reasoningEffort;
+    live.execution = structuredClone(opts.execution);
+    // Repeated calls normally carry the same immutable Session snapshot. Preserve
+    // a newer native `/model` or effort change unless Core explicitly changed the
+    // corresponding Session setting between calls.
+    if (opts.execution.model !== previousModel) {
+        live.model = opts.execution.model?.trim() ?? "";
+    }
+    if (opts.execution.reasoningEffort !== previousReasoningEffort) {
+        live.reasoningEffort = opts.execution.reasoningEffort ?? undefined;
+    }
+    return true;
+}
 /** Freeze the Session's permission choice into the explicit managed settings.
  * Host/project settings may still contribute allow/deny rules, but changing
  * their defaultMode cannot silently mutate an existing Session on resume. */
@@ -2233,6 +3578,12 @@ function applyClaudePermissionModeSnapshot(settings, permissionMode) {
         permissions.defaultMode = permissionMode;
     else
         delete permissions.defaultMode;
+    if (permissionMode === "bypassPermissions") {
+        next.skipDangerousModePermissionPrompt = true;
+    }
+    else {
+        delete next.skipDangerousModePermissionPrompt;
+    }
     if (Object.keys(permissions).length > 0)
         next.permissions = permissions;
     else
@@ -2272,10 +3623,13 @@ export function isThreadNotReadyError(error) {
     const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
     return message.includes("no rollout found") || (message.includes("rollout") && message.includes("empty"));
 }
-/** A persisted thread id that a freshly started app-server cannot load yet.
- * During startup, both errors can be transient while the rollout index catches
- * up. Retry the same id; never use either error as permission to replace it. */
-export function isRetryableThreadResumeError(error) {
-    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
-    return message.includes("thread not found") || isThreadNotReadyError(error);
+/** Build the user-facing native lifecycle failure once, at the phase that owns
+ * it. Downstream layers preserve this code/message verbatim instead of replacing
+ * it with a generic "failed to start; see logs" wrapper. */
+function nativeLiveFailure(runtime, code, phase, cause, statusCode = 503) {
+    const provider = runtime === "traex" ? "Traex" : "Codex";
+    const detail = cause === undefined
+        ? ""
+        : `: ${cause instanceof Error ? cause.message : String(cause)}`;
+    return new CodexRuntimeError(`${provider} ${phase}${detail}`, statusCode, code);
 }