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

package/dist/runner/manager.js

@@ -22,9 +22,11 @@ import { fileURLToPath } from "node:url";
 import { AgentRuntimeError, } from "@rynx-ai/core";
 import { listRuntimeModels } from "../models-catalog.js";
 import { probeRuntimeStatus } from "../runtime-status.js";
-import { terminateTmuxServer } from "../terminal/tmux.js";
-import { fromWireError, } from "./protocol.js";
+import { terminateTmuxServer, tmuxHasAttachedClient, tmuxWindowActivityAt, } from "../terminal/tmux.js";
+import { RUNNER_IMAGE_CHUNK_CHARS, RUNNER_IMAGE_MAX_RESULT_CHARS, fromWireError, } from "./protocol.js";
+import { isCodexLineageProvider, isManagedNativeProvider } from "./startup-policy.js";
 import { StdioRunnerTransport } from "./transport.js";
+import { cloneClaudeTranscript } from "../claude/transcript-clone.js";
 /** Routing key for the shared capability runner (slash-command RPCs). */
 const CAP_KEY = "__cap__";
 /** Max stderr lines retained per handle for the crash exit-report tail. */
@@ -33,23 +35,30 @@ const STDERR_TAIL_LINES = 40;
 const DEFAULT_SHUTDOWN_GRACE_MS = 5_000;
 /** Time allowed for exit after SIGKILL before shutdown reports failure. */
 const DEFAULT_SHUTDOWN_KILL_GRACE_MS = 5_000;
-/** Setup-pane launch should acknowledge quickly; never pin its HTTP request. */
-const DEFAULT_LIVE_START_TIMEOUT_MS = 10_000;
-/** Thread readiness may legitimately wait through Provider startup. */
+/** Legacy setup-pane acknowledgement deadline for providers that do not own
+ * phase-specific startup errors. Codex/Traex are deliberately excluded. */
+const DEFAULT_LIVE_START_TIMEOUT_MS = 30_000;
+/** Legacy fallback for a provider without a native startup policy. */
 const DEFAULT_LIVE_READY_TIMEOUT_MS = 25_000;
+/** Claude has no app-server bridge and keeps a parent-owned SessionStart
+ * deadline. Codex-lineage startup instead acknowledges pane/observer startup
+ * and lets thread discovery race injection. */
+const DEFAULT_NATIVE_LIVE_START_TIMEOUT_MS = 60_000;
 /** A submitted TUI command should become a mirrored turn or native rotation
  * quickly. If it does not, the runner is fenced by a verified process-tree
  * shutdown before maintenance may treat the submission as settled. */
 const DEFAULT_TERMINAL_INPUT_HANDOFF_TIMEOUT_MS = 30_000;
-/** Retry transient terminal-server cleanup without spinning forever. */
-const DEFAULT_TERMINAL_INPUT_CLEANUP_RETRY_MS = 1_000;
-const MAX_TERMINAL_INPUT_CLEANUP_RETRY_MS = 30_000;
+/** Full idle window before an inactive native pane becomes reapable. */
+const DEFAULT_NATIVE_PANE_IDLE_TTL_MS = 60 * 60_000;
+/** tmux output this recent independently proves that a native pane is busy. */
+const DEFAULT_NATIVE_PANE_OUTPUT_BUSY_WINDOW_MS = 120_000;
 /** Keep per-Session spawn context small enough to remain an environment handoff,
  * not an unbounded transport. */
 const MAX_SESSION_CONTEXT_ENV_ENTRIES = 32;
 const MAX_SESSION_CONTEXT_ENV_KEY_BYTES = 128;
 const MAX_SESSION_CONTEXT_ENV_VALUE_BYTES = 8_192;
 const MAX_SESSION_CONTEXT_ENV_TOTAL_BYTES = 32_768;
+const MAX_TERMINAL_RESPONSE_IDS = 2_000;
 /** A typed attach failure so transport adapters can distinguish an expected
  * absent pane from an infrastructure failure without matching error strings. */
 export class TerminalOpenError extends Error {
@@ -65,11 +74,16 @@ class ManagedTerminal {
     sendMsg;
     onClose;
     ready;
-    dataListener;
-    exitListener;
+    readerDone;
+    resizeListener;
+    dimensions;
+    role = "read-only";
+    seedBytes = 0;
     resolveReady;
     rejectReady;
+    resolveReaderDone;
     state = "opening";
+    pending = new Map();
     constructor(attachId, sendMsg, onClose) {
         this.attachId = attachId;
         this.sendMsg = sendMsg;
@@ -78,20 +92,75 @@ class ManagedTerminal {
             this.resolveReady = resolve;
             this.rejectReady = reject;
         });
+        this.readerDone = new Promise((resolve) => {
+            this.resolveReaderDone = resolve;
+        });
         // Never surface an unhandled rejection if no caller awaits `ready`.
         void this.ready.catch(() => undefined);
     }
-    onData(listener) {
-        this.dataListener = listener;
+    onResize(listener) {
+        this.resizeListener = listener;
+        if (this.dimensions)
+            queueMicrotask(() => listener(this.dimensions));
+    }
+    readSeed(offset, maxBytes) {
+        if (this.state !== "prepared")
+            return Promise.reject(new Error("terminal is not prepared"));
+        return this.requestRead("seed", {
+            t: "term.seed.read",
+            attachId: this.attachId,
+            reqId: randomUUID(),
+            offset,
+            maxBytes,
+        });
     }
-    onExit(listener) {
-        this.exitListener = listener;
+    start() {
+        if (this.state !== "prepared")
+            return Promise.reject(new Error("terminal is not prepared"));
+        this.state = "starting";
+        const reqId = randomUUID();
+        return this.request("start", { t: "term.start", attachId: this.attachId, reqId })
+            .then(() => {
+            if (this.state === "starting")
+                this.state = "started";
+        });
+    }
+    read(offset, maxBytes) {
+        if (this.state !== "started")
+            return Promise.reject(new Error("terminal has not started"));
+        return this.requestRead("read", {
+            t: "term.read",
+            attachId: this.attachId,
+            reqId: randomUUID(),
+            offset,
+            maxBytes,
+        });
     }
     write(data) {
-        this.sendMsg({ t: "term.input", attachId: this.attachId, dataB64: Buffer.from(data, "utf8").toString("base64") });
+        if (this.state !== "started" || this.role !== "owner")
+            return Promise.resolve();
+        const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+        if (bytes.byteLength === 0)
+            return Promise.resolve();
+        const reqId = randomUUID();
+        return this.request("input", {
+            t: "term.input",
+            attachId: this.attachId,
+            reqId,
+            dataB64: bytes.toString("base64"),
+        }).then(() => undefined);
     }
     resize(cols, rows) {
-        this.sendMsg({ t: "term.resize", attachId: this.attachId, cols, rows });
+        if (this.state !== "started")
+            return Promise.resolve();
+        const reqId = randomUUID();
+        return this.request("resize", {
+            t: "term.resize",
+            attachId: this.attachId,
+            reqId,
+            cols,
+            rows,
+        }).then(() => undefined);
     }
     close() {
         if (this.state === "closed")
@@ -100,43 +169,96 @@ class ManagedTerminal {
         this.state = "closed";
         this.sendMsg({ t: "term.close", attachId: this.attachId });
         this.onClose();
+        this.rejectPending(new Error("terminal attachment was closed"));
         if (wasOpening) {
             this.rejectReady(new TerminalOpenError("terminal attachment was closed while opening", "terminal_open_failed"));
         }
+        this.resolveReaderDone({ finalOffset: 0, reason: "client_closed", exitCode: 0 });
     }
     // ── internal (driven by onChildMessage) ──
-    _opened(role) {
+    _prepared(role, seedBytes, cols, rows) {
         if (this.state !== "opening")
             return;
-        this.state = "opened";
-        this.resolveReady({ role });
-    }
-    _data(dataB64) {
-        this.dataListener?.(Buffer.from(dataB64, "base64").toString("utf8"));
+        this.state = "prepared";
+        this.role = role;
+        this.seedBytes = seedBytes;
+        this.dimensions = cols !== undefined && rows !== undefined ? { cols, rows } : undefined;
+        this.resolveReady({
+            role,
+            seedBytes,
+            ...(this.dimensions ? { dimensions: this.dimensions } : {}),
+        });
     }
-    _exit(exitCode) {
+    _dimensions(cols, rows) {
         if (this.state === "closed")
             return;
-        const wasOpening = this.state === "opening";
-        this.state = "closed";
-        if (wasOpening) {
-            this.rejectReady(new TerminalOpenError(`terminal exited before opening (code=${exitCode})`, "terminal_open_failed"));
-        }
-        else {
-            this.exitListener?.({ exitCode });
-        }
+        this.dimensions = { cols, rows };
+        this.resizeListener?.(this.dimensions);
+    }
+    _started(reqId) {
+        this.resolvePending(reqId, "start", undefined);
+    }
+    _chunk(reqId, operation, dataB64, nextOffset, done, finalOffset) {
+        this.resolvePending(reqId, operation, {
+            data: Uint8Array.from(Buffer.from(dataB64, "base64")),
+            nextOffset,
+            done,
+            ...(finalOffset === undefined ? {} : { finalOffset }),
+        });
+    }
+    _ack(reqId, operation) {
+        this.resolvePending(reqId, operation, undefined);
+    }
+    _readerDone(info) {
+        this.resolveReaderDone(info);
     }
-    _fail(message, code = "terminal_open_failed") {
+    _fail(message, code = "terminal_open_failed", reqId) {
         if (this.state === "closed")
             return;
+        if (reqId) {
+            const pending = this.pending.get(reqId);
+            if (pending) {
+                this.pending.delete(reqId);
+                pending.reject(new TerminalOpenError(message, code));
+                return;
+            }
+        }
         const wasOpening = this.state === "opening";
         this.state = "closed";
+        this.rejectPending(new TerminalOpenError(message, code));
         if (wasOpening) {
             this.rejectReady(new TerminalOpenError(message, code));
         }
-        else {
-            this.exitListener?.({ exitCode: 1 });
+        this.resolveReaderDone({ finalOffset: 0, reason: "internal", exitCode: 1 });
+    }
+    requestRead(operation, message) {
+        return this.request(operation, message);
+    }
+    request(operation, message) {
+        return new Promise((resolve, reject) => {
+            this.pending.set(message.reqId, { operation, resolve, reject });
+            try {
+                this.sendMsg(message);
+            }
+            catch (error) {
+                this.pending.delete(message.reqId);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    resolvePending(reqId, operation, value) {
+        const pending = this.pending.get(reqId);
+        if (!pending || pending.operation !== operation) {
+            this._fail(`terminal response ${reqId} is duplicate or out of order`);
+            return;
         }
+        this.pending.delete(reqId);
+        pending.resolve(value);
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
     }
 }
 export class RunnerManager {
@@ -144,6 +266,8 @@ export class RunnerManager {
     sessionStore;
     runnerEntry;
     idleTtlMs;
+    nativePaneIdleTtlMs;
+    nativePaneOutputBusyWindowMs;
     spawn;
     childEnv;
     sessionContextProvider;
@@ -160,15 +284,28 @@ export class RunnerManager {
     shutdownKillGraceMs;
     signalChild;
     terminateTerminalServer;
+    terminalWindowActivityAt;
+    terminalHasAttachedClient;
+    wallNow;
     liveStartTimeoutMs;
     liveReadyTimeoutMs;
+    nativeLiveStartTimeoutMs;
     liveInterruptTimeoutMs;
     terminalInputHandoffTimeoutMs;
-    terminalInputCleanupRetryMs;
+    reapPromise = null;
     stopping = false;
     stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
     mirrorListener = null;
+    /** Settles process-local projections only when an ordinary durable item has
+     * exhausted its permanent retry budget. */
+    mirrorAbandonListener = null;
+    /** Clears process-live optimistic state when /clear permanently moves the
+     * native pane away from the old Session. */
+    mirrorSupersedeListener = null;
+    /** Synchronous persistence hook for native collaboration-mode reflection.
+     * It runs before the event reaches the Session bus. */
+    collaborationModeListener = null;
     /** Sink for session rotations (claude `/clear`·`/fork`) — server records meta. */
     rotateListener = null;
     /** Session keys with a live codex forwarder — never reaped while present. */
@@ -198,25 +335,33 @@ export class RunnerManager {
         this.sessionStore = opts.sessionStore;
         this.runnerEntry = opts.runnerEntry ?? defaultRunnerEntry();
         this.idleTtlMs = opts.idleTtlMs ?? 300_000;
+        this.nativePaneIdleTtlMs = opts.nativePaneIdleTtlMs ?? DEFAULT_NATIVE_PANE_IDLE_TTL_MS;
+        this.nativePaneOutputBusyWindowMs = Math.max(0, opts.nativePaneOutputBusyWindowMs ?? DEFAULT_NATIVE_PANE_OUTPUT_BUSY_WINDOW_MS);
         this.spawn = opts.spawn ?? nodeSpawn;
         this.childEnv = opts.childEnv ?? {};
         this.sessionContextProvider = opts.sessionContextProvider;
         this.admissionOpen = opts.admissionOpen ?? (() => true);
         this.admissionReserve = opts.admissionReserve;
         this.now = opts.now ?? (() => Date.now());
+        this.wallNow = opts.wallNow ?? (() => Date.now());
         this.defaultRuntime = opts.config.DEFAULT_RUNTIME ?? "codex";
         this.shutdownGraceMs = Math.max(0, opts.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS);
         this.shutdownKillGraceMs = Math.max(0, opts.shutdownKillGraceMs ?? DEFAULT_SHUTDOWN_KILL_GRACE_MS);
         this.signalChild = opts.signalChild ?? signalRunnerChild;
-        this.terminateTerminalServer = opts.terminateTerminalServer ?? terminateTmuxServer;
+        this.terminateTerminalServer = opts.terminateTerminalServer ??
+            ((name, ownerPid) => terminateTmuxServer(name, undefined, ownerPid));
+        this.terminalWindowActivityAt = opts.terminalWindowActivityAt ??
+            ((name, ownerPid) => tmuxWindowActivityAt(name, undefined, ownerPid));
+        this.terminalHasAttachedClient = opts.terminalHasAttachedClient ??
+            ((name, ownerPid) => tmuxHasAttachedClient(name, undefined, ownerPid));
         this.liveStartTimeoutMs = Math.max(1, opts.liveStartTimeoutMs ?? DEFAULT_LIVE_START_TIMEOUT_MS);
         this.liveReadyTimeoutMs = Math.max(1, opts.liveReadyTimeoutMs ?? DEFAULT_LIVE_READY_TIMEOUT_MS);
+        this.nativeLiveStartTimeoutMs = Math.max(1, opts.nativeLiveStartTimeoutMs ?? DEFAULT_NATIVE_LIVE_START_TIMEOUT_MS);
         this.liveInterruptTimeoutMs = Math.max(1, opts.liveInterruptTimeoutMs ?? 10_000);
         this.terminalInputHandoffTimeoutMs = Math.max(1, opts.terminalInputHandoffTimeoutMs ?? DEFAULT_TERMINAL_INPUT_HANDOFF_TIMEOUT_MS);
-        this.terminalInputCleanupRetryMs = Math.max(1, opts.terminalInputCleanupRetryMs ?? DEFAULT_TERMINAL_INPUT_CLEANUP_RETRY_MS);
         const reapIntervalMs = opts.reapIntervalMs ?? 60_000;
         if (reapIntervalMs > 0) {
-            this.reapTimer = setInterval(() => this.reapIdle(), reapIntervalMs);
+            this.reapTimer = setInterval(() => void this.reapIdle(), reapIntervalMs);
             this.reapTimer.unref?.();
         }
         else {
@@ -227,9 +372,8 @@ export class RunnerManager {
     /**
      * Open a live terminal on the session's runner child (spawning it if needed).
      * Phase C hosts one terminal ("main") per session; the returned handle is a
-     * single attach client — `owner` (read-write) or a downgraded `read-only`
-     * viewer per the child's ownership rule. Not part of `AgentExecutor`; the WS
-     * bridge calls it directly.
+     * single attach client with the requested `owner` (read-write) or `read-only`
+     * role. Not part of `AgentExecutor`; the WS bridge calls it directly.
      */
     openTerminal(localThreadId, opts) {
         const handle = this.getOrSpawn(localThreadId);
@@ -261,6 +405,8 @@ export class RunnerManager {
             pendingEscape: "",
         };
         const terminal = new ManagedTerminal(attachId, (msg) => {
+            if (msg.t === "term.input")
+                handle.lastUsedAt = this.now();
             const handoffs = msg.t === "term.input" && opts.role === "owner"
                 ? this.beginTerminalInputHandoffs(handle, this.currentTerminalSessionId(handle, localThreadId), trackedTerminalSubmissions(inputTracker, Buffer.from(msg.dataB64, "base64").toString("utf8")))
                 : [];
@@ -329,6 +475,15 @@ export class RunnerManager {
     onMirror(listener) {
         this.mirrorListener = listener;
     }
+    onMirrorAbandon(listener) {
+        this.mirrorAbandonListener = listener;
+    }
+    onMirrorSupersede(listener) {
+        this.mirrorSupersedeListener = listener;
+    }
+    onCollaborationMode(listener) {
+        this.collaborationModeListener = listener;
+    }
     /** Register the sink for session rotations (claude `/clear`·`/fork`): the server
      *  records the new session's meta (carry-over agent/model/title). */
     onRotate(listener) {
@@ -412,7 +567,7 @@ export class RunnerManager {
             if (candidate === handle && this.liveSessionKeys.has(sessionId))
                 return sessionId;
         }
-        return fallback;
+        return handle.activeSessionId || fallback;
     }
     finishTerminalInputHandoff(handle, handoff) {
         if (handoff.timer) {
@@ -431,11 +586,6 @@ export class RunnerManager {
             this.terminalInputHandoffs.delete(handle);
     }
     finishAllTerminalInputHandoffs(handle) {
-        if (handle.terminalCleanupRetryTimer) {
-            clearTimeout(handle.terminalCleanupRetryTimer);
-            delete handle.terminalCleanupRetryTimer;
-        }
-        handle.terminalCleanupRetryFailures = 0;
         for (const handoff of [...(this.terminalInputHandoffs.get(handle) ?? [])]) {
             this.finishTerminalInputHandoff(handle, handoff);
         }
@@ -450,22 +600,6 @@ export class RunnerManager {
             handoff.reservation = undefined;
         }
     }
-    scheduleTerminalInputCleanupRetry(handle) {
-        if (handle.terminalCleanupRetryTimer ||
-            !this.terminalInputHandoffs.has(handle))
-            return;
-        const exponent = Math.min(handle.terminalCleanupRetryFailures - 1, 10);
-        const delay = Math.min(this.terminalInputCleanupRetryMs * (2 ** Math.max(0, exponent)), MAX_TERMINAL_INPUT_CLEANUP_RETRY_MS);
-        handle.terminalCleanupRetryTimer = setTimeout(() => {
-            delete handle.terminalCleanupRetryTimer;
-            if (!this.terminalInputHandoffs.has(handle))
-                return;
-            void this.terminateHandle(handle, "retrying unproven terminal input cleanup").catch((error) => {
-                logTerminationFailure(handle, error);
-            });
-        }, delay);
-        handle.terminalCleanupRetryTimer.unref?.();
-    }
     expireTerminalInputHandoffs(handle) {
         const handoffs = this.terminalInputHandoffs.get(handle);
         if (!handoffs?.length)
@@ -483,8 +617,10 @@ export class RunnerManager {
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if
-     * needed. Idempotent. Resolves true once the codex thread is bound; false for a
-     * non-codex / non-live session (the caller then uses the normal run path).
+     * needed. Idempotent. For Codex-lineage sessions, resolves after backend
+     * preload and pane launch; known-thread observer attach and fresh-thread
+     * discovery continue in the background. Other providers retain their
+     * readiness gate.
      */
     ensureLiveSession(localThreadId, opts) {
         const admission = this.reserveAdmission();
@@ -523,42 +659,66 @@ export class RunnerManager {
         this.liveSessionKeys.add(localThreadId);
         const reqId = randomUUID();
         return new Promise((resolve) => {
-            const timeoutMs = waitForReady ? this.liveReadyTimeoutMs : this.liveStartTimeoutMs;
-            const timeout = setTimeout(() => {
-                if (!handle.live.delete(reqId))
-                    return;
-                const finishTimeout = () => {
-                    const reason = `runner did not acknowledge ${waitForReady ? "live readiness" : "terminal start"} within ${timeoutMs}ms`;
-                    this.liveErrors.set(localThreadId, reason);
-                    this.liveSessionKeys.delete(localThreadId);
-                    // A child that cannot answer a bounded control round-trip is unsafe
-                    // to reuse. Reap it so the next click gets a fresh runner.
-                    void this.terminateHandle(handle, reason).catch((error) => {
-                        logTerminationFailure(handle, error);
-                    });
-                    return false;
-                };
-                const reservation = allowReservedForkTarget
-                    ? undefined
-                    : this.forkReservations.get(localThreadId);
-                if (reservation) {
-                    void reservation
-                        .then(() => finishTimeout())
-                        .then(resolve, () => resolve(false));
-                    return;
-                }
-                resolve(finishTimeout());
-            }, timeoutMs);
-            timeout.unref?.();
+            const provider = opts.execution.provider;
+            const timeoutMs = isCodexLineageProvider(provider)
+                ? null
+                : !waitForReady
+                    ? this.liveStartTimeoutMs
+                    : provider === "claude"
+                        ? this.nativeLiveStartTimeoutMs
+                        : this.liveReadyTimeoutMs;
+            const timeout = timeoutMs === null
+                ? undefined
+                : setTimeout(() => {
+                    if (!handle.live.delete(reqId))
+                        return;
+                    const finishTimeout = () => {
+                        const reason = !waitForReady
+                            ? `runner did not acknowledge terminal start within ${timeoutMs}ms`
+                            : provider === "claude"
+                                ? `Claude SessionStart was not observed within ${Math.round(timeoutMs / 1_000)}s; the runner process was reset before retry`
+                                : `runner did not acknowledge live readiness within ${timeoutMs}ms`;
+                        this.liveErrors.set(localThreadId, {
+                            message: reason,
+                            code: provider === "claude"
+                                ? "claude_session_start_timeout"
+                                : "native_runner_ack_timeout",
+                            statusCode: 503,
+                        });
+                        this.liveSessionKeys.delete(localThreadId);
+                        // Legacy providers without phase-owned startup errors retain the
+                        // bounded control guard. Codex/Traex never enter this branch.
+                        void this.terminateHandle(handle, reason).catch((error) => {
+                            logTerminationFailure(handle, error);
+                        });
+                        return false;
+                    };
+                    const reservation = allowReservedForkTarget
+                        ? undefined
+                        : this.forkReservations.get(localThreadId);
+                    if (reservation) {
+                        void reservation
+                            .then(() => finishTimeout())
+                            .then(resolve, () => resolve(false));
+                        return;
+                    }
+                    resolve(finishTimeout());
+                }, timeoutMs);
+            timeout?.unref?.();
             handle.live.set(reqId, (res) => {
-                clearTimeout(timeout);
+                if (timeout)
+                    clearTimeout(timeout);
                 const ok = res.ok ?? false;
                 const finish = () => {
                     if (ok) {
                         this.liveErrors.delete(localThreadId);
                     }
                     else {
-                        this.liveErrors.set(localThreadId, res.error ?? "live session did not become ready");
+                        this.liveErrors.set(localThreadId, res.error ?? {
+                            message: "live session did not become ready",
+                            code: "native_readiness_failed",
+                            statusCode: 503,
+                        });
                     }
                     return ok;
                 };
@@ -586,7 +746,11 @@ export class RunnerManager {
         });
     }
     lastLiveSessionError(localThreadId) {
-        return this.liveErrors.get(localThreadId);
+        return this.liveErrors.get(localThreadId)?.message;
+    }
+    lastLiveSessionFailure(localThreadId) {
+        const failure = this.liveErrors.get(localThreadId);
+        return failure ? { ...failure } : undefined;
     }
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
@@ -594,47 +758,63 @@ export class RunnerManager {
      * all output. Resolves true when the app-server accepted the turn, false when
      * the session has no live forwarder (caller falls back to the run path).
      */
-    injectMessage(localThreadId, input) {
+    injectMessage(localThreadId, input, options) {
         const admission = this.reserveAdmission();
-        return this.injectMessageAdmitted(localThreadId, input)
+        return this.injectMessageAdmitted(localThreadId, input, options)
             .finally(() => admission.release());
     }
-    injectMessageAdmitted(localThreadId, input) {
+    injectMessageAdmitted(localThreadId, input, options) {
+        const rotatingHandle = this.handles.get(localThreadId);
+        if (rotatingHandle?.pendingRotation?.from === localThreadId &&
+            !rotatingHandle.dead) {
+            // Reject input addressed to the old active Session during
+            // cutover. Do not wait and then silently reopen the retired Session: the
+            // user can retry after the client follows session.rotated.
+            return Promise.resolve({ outcome: "notReady" });
+        }
         const sourceReservation = this.sourceForkReservations.get(localThreadId);
         if (sourceReservation) {
-            return sourceReservation.then(() => this.injectMessageAdmitted(localThreadId, input));
+            return sourceReservation.then(() => this.injectMessageAdmitted(localThreadId, input, options));
         }
         const reservation = this.forkReservations.get(localThreadId);
         if (reservation) {
-            return reservation.then(() => this.injectMessageAdmitted(localThreadId, input));
+            return reservation.then(() => this.injectMessageAdmitted(localThreadId, input, options));
         }
         const handle = this.getOrSpawn(localThreadId);
         handle.lastUsedAt = this.now();
         const reqId = randomUUID();
         return new Promise((resolve) => {
             handle.live.set(reqId, (res) => {
-                const outcome = res.outcome ?? "failed";
+                const result = res.result ?? { outcome: "failed" };
                 const finish = () => {
-                    if (outcome === "injected") {
+                    if (result.outcome === "injected" || result.outcome === "steered") {
                         this.liveErrors.delete(localThreadId);
                     }
                     else {
-                        this.liveErrors.set(localThreadId, res.error ?? `live injection ${outcome}`);
+                        this.liveErrors.set(localThreadId, res.error ?? {
+                            message: `live injection ${result.outcome}`,
+                            code: result.outcome === "notReady"
+                                ? "native_thread_not_ready"
+                                : result.outcome === "notLive"
+                                    ? "native_session_not_live"
+                                    : "native_message_injection_failed",
+                            statusCode: 503,
+                        });
                     }
-                    return outcome;
+                    return result;
                 };
                 const reservation = this.forkReservations.get(localThreadId);
                 if (reservation) {
                     void reservation
                         .then(() => finish())
-                        .then(resolve, () => resolve("failed"));
+                        .then(resolve, () => resolve({ outcome: "failed" }));
                     return;
                 }
                 resolve(finish());
             });
             handle.transport.send(typeof input === "string"
-                ? { t: "inject", reqId, localThreadId, text: input }
-                : { t: "inject", reqId, localThreadId, input });
+                ? { t: "inject", reqId, localThreadId, text: input, ...(options ? { options } : {}) }
+                : { t: "inject", reqId, localThreadId, input, ...(options ? { options } : {}) });
         });
     }
     /**
@@ -674,7 +854,7 @@ export class RunnerManager {
             handle.live.set(reqId, (reply) => {
                 resolve(reply.interactionResult ?? {
                     disposition: "invalid",
-                    message: reply.error ?? "runner did not return an interaction result",
+                    message: reply.error?.message ?? "runner did not return an interaction result",
                 });
             });
             handle.transport.send({
@@ -686,6 +866,34 @@ export class RunnerManager {
             });
         });
     }
+    /** Update a loaded Codex-lineage native thread without spawning a runner. */
+    updateCollaborationMode(localThreadId, mode) {
+        const handle = this.handles.get(localThreadId);
+        if (!handle || handle.dead || !this.liveSessionKeys.has(localThreadId)) {
+            return Promise.reject(new AgentRuntimeError("Native Session is not live", 409, "native_session_not_live"));
+        }
+        handle.lastUsedAt = this.now();
+        const reqId = randomUUID();
+        return new Promise((resolve, reject) => {
+            handle.live.set(reqId, (reply) => {
+                if (reply.collaborationUpdated) {
+                    resolve();
+                    return;
+                }
+                reject(fromWireError(reply.error ?? {
+                    message: "Native collaboration mode update failed",
+                    code: "collaboration_mode_update_failed",
+                    statusCode: 503,
+                }));
+            });
+            handle.transport.send({
+                t: "collaboration.update",
+                reqId,
+                localThreadId,
+                mode,
+            });
+        });
+    }
     // ── AgentCapabilities ──────────────────────────────────────────────────────
     async listModels(runtime) {
         return listRuntimeModels(this.config, runtime ?? this.defaultRuntime);
@@ -824,6 +1032,7 @@ export class RunnerManager {
             this.liveErrors.clear();
             this.liveOptions.clear();
             this.mirrorListener = null;
+            this.mirrorAbandonListener = null;
             this.rotateListener = null;
             const errors = results
                 .filter((result) => result.status === "rejected")
@@ -869,7 +1078,6 @@ export class RunnerManager {
                 !allowReservedForkTarget) {
                 throw new AgentRuntimeError("Session fork is still being committed", 409, "session_fork_pending");
             }
-            this.reapIdle();
             const existing = this.handles.get(key);
             if (existing && !existing.dead) {
                 existing.lastUsedAt = this.now();
@@ -946,29 +1154,67 @@ export class RunnerManager {
     }
     async performClaudeManagedFork(currentLocalThreadId, newLocalThreadId, options) {
         const source = await this.sessionStore.get(currentLocalThreadId);
+        const getIntent = this.sessionStore.getClaudeForkIntent?.bind(this.sessionStore);
         const setIntent = this.sessionStore.setClaudeForkIntent?.bind(this.sessionStore);
         const deleteIntent = this.sessionStore.deleteClaudeForkIntent?.bind(this.sessionStore);
-        if (!source?.codexSessionId || !setIntent || !deleteIntent) {
+        if (!source?.codexSessionId || !getIntent || !setIntent || !deleteIntent) {
             return {
                 ok: false,
                 reason: "unsupported",
                 message: "Claude fork persistence is unavailable",
             };
         }
-        const targetClaudeSessionId = randomUUID();
+        const persistedIntent = await getIntent(newLocalThreadId);
+        if (persistedIntent &&
+            persistedIntent.sourceSessionId !== currentLocalThreadId) {
+            return {
+                ok: false,
+                reason: "error",
+                message: "target Session already has a different Claude fork intent",
+            };
+        }
+        // A durable fork operation may be replayed after clone+intent persistence
+        // but before SessionStart commits the Provider binding. Reuse that exact
+        // target id/path/prefix: re-cloning would move the fork boundary if the
+        // source advanced (or silently lose history if it disappeared).
+        const targetClaudeSessionId = persistedIntent?.targetClaudeSessionId ?? randomUUID();
         try {
-            await setIntent({
-                targetSessionId: newLocalThreadId,
-                sourceSessionId: currentLocalThreadId,
-                sourceClaudeSessionId: source.codexSessionId,
-                targetClaudeSessionId,
-                updatedAt: new Date().toISOString(),
-            });
-            const ready = await this.requestLiveSession(newLocalThreadId, {
+            if (!persistedIntent) {
+                let clonedTranscript = null;
+                try {
+                    clonedTranscript = await cloneClaudeTranscript({
+                        sourceClaudeSessionId: source.codexSessionId,
+                        targetClaudeSessionId,
+                        targetCwd: options.workspace.cwd,
+                    });
+                }
+                catch (error) {
+                    console.error(`[claude-fork] could not clone source transcript for ${newLocalThreadId}; target will start without Provider history: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                await setIntent({
+                    targetSessionId: newLocalThreadId,
+                    sourceSessionId: currentLocalThreadId,
+                    sourceClaudeSessionId: source.codexSessionId,
+                    targetClaudeSessionId,
+                    ...(clonedTranscript
+                        ? {
+                            forkTranscriptPath: clonedTranscript.transcriptPath,
+                            ...(clonedTranscript.prefixBytes === undefined
+                                ? {}
+                                : { forkTranscriptPrefixBytes: clonedTranscript.prefixBytes }),
+                        }
+                        : {}),
+                    updatedAt: new Date().toISOString(),
+                });
+            }
+            await this.requestLiveSession(newLocalThreadId, {
                 workspace: structuredClone(options.workspace),
                 execution: structuredClone(options.execution),
             }, true, true);
-            const target = ready ? await this.sessionStore.get(newLocalThreadId) : null;
+            // SessionStart commits the binding before the child reports live.ready.
+            // If that final ACK is lost (or the child exits in between), the durable
+            // binding is authoritative and must not be rolled back.
+            const target = await this.sessionStore.get(newLocalThreadId);
             if (!target ||
                 target.parentSessionId !== currentLocalThreadId ||
                 target.codexSessionId !== targetClaudeSessionId) {
@@ -978,10 +1224,8 @@ export class RunnerManager {
             return { ok: true, data: undefined };
         }
         catch (error) {
-            await deleteIntent(newLocalThreadId).catch(() => undefined);
-            const target = await this.sessionStore.get(newLocalThreadId).catch(() => null);
-            if (target?.parentSessionId === currentLocalThreadId) {
-                await this.sessionStore.delete(newLocalThreadId).catch(() => undefined);
+            if (!persistedIntent) {
+                await deleteIntent(newLocalThreadId).catch(() => undefined);
             }
             const handle = this.handles.get(newLocalThreadId);
             if (handle && !handle.dead) {
@@ -1011,103 +1255,550 @@ export class RunnerManager {
         if (handle.dead)
             return;
         if (message.t === "mirror") {
-            this.mirrorListener?.(message.sessionId, message.event);
-            if (message.event.type === "response.created") {
-                this.settleTerminalInputHandoff(handle, message.sessionId, "turn");
-            }
+            this.deliverMirrorMessage(handle, message);
             return;
         }
         this.deliverRotateMessage(handle, message);
     }
-    deliverRotateMessage(handle, message) {
-        if (this.forkReservations.has(message.to) ||
-            this.sourceForkReservations.has(message.from)) {
-            void this.terminateHandle(handle, "conflicting Session rotation").catch((error) => logTerminationFailure(handle, error));
+    deliverMirrorMessage(handle, message) {
+        if (handle.dead)
             return;
+        if (this.isStaleMirrorGeneration(handle, message.generation)) {
+            if ("deliveryId" in message) {
+                handle.transport.send({
+                    t: "mirror.ack",
+                    deliveryId: message.deliveryId,
+                    generation: message.generation,
+                });
+            }
+            else {
+                handle.imageTransfers.delete(message.transferId);
+                handle.transport.send({
+                    t: "mirror.image.ack",
+                    transferId: message.transferId,
+                    seq: message.seq,
+                    generation: message.generation,
+                });
+            }
+            return;
+        }
+        if ("deliveryId" in message) {
+            const existing = handle.mirrorDeliveries.get(message.deliveryId);
+            if (existing && existing.sessionId !== message.sessionId) {
+                void this.terminateHandle(handle, "conflicting ordinary mirror delivery replay").catch((error) => logTerminationFailure(handle, error));
+                return;
+            }
+            if (!existing) {
+                handle.mirrorDeliveries.set(message.deliveryId, {
+                    sessionId: message.sessionId,
+                    abandonRequested: false,
+                });
+            }
         }
+        let observationCommitted = false;
+        const commitObservation = () => {
+            if (observationCommitted)
+                return;
+            observationCommitted = true;
+            if (this.isStaleMirrorGeneration(handle, message.generation))
+                return;
+            if (message.event.type === "session.collaboration_mode") {
+                this.collaborationModeListener?.(message.sessionId, message.event.mode);
+            }
+            this.observeHandleRuntimeEvent(handle, message.event);
+            if (message.event.type === "response.created") {
+                this.settleTerminalInputHandoff(handle, message.sessionId, "turn");
+            }
+        };
+        const commitDeliveredObservation = () => {
+            commitObservation();
+            if (handle.dead) {
+                // The listener may have persisted/observed this event before its
+                // Promise settled, while failHandle still saw no committed active id.
+                // Close that newly visible response instead of leaving server runtime
+                // state permanently running.
+                this.failActiveResponses(handle, "runner_crashed", handle.failureReason ?? "runner exited during mirror publication");
+            }
+        };
+        let delivered;
         try {
-            // Rotate the runtime-local context before publishing the new Session
-            // alias to routing or observers. This prevents the new identity from
-            // briefly inheriting stale context after `/clear` or `/fork`.
-            handle.sessionContext?.rotate(message.to);
+            const result = this.mirrorListener?.(message.sessionId, message.event);
+            if (result && typeof result.then === "function") {
+                delivered = Promise.resolve(result);
+            }
+            else {
+                commitObservation();
+                delivered = Promise.resolve();
+            }
         }
         catch (error) {
-            const reason = `runner Session context rotation failed: ${errorMessage(error)}`;
-            void this.terminateHandle(handle, reason).catch((terminationError) => {
-                logTerminationFailure(handle, terminationError);
+            delivered = Promise.reject(error);
+        }
+        if ("transferId" in message) {
+            const transfer = handle.imageTransfers.get(message.transferId);
+            if (transfer)
+                transfer.publication = delivered;
+            void delivered.then(() => {
+                commitDeliveredObservation();
+                if (!handle.dead) {
+                    if (handle.imageTransfers.get(message.transferId) === transfer) {
+                        handle.imageTransfers.delete(message.transferId);
+                    }
+                    handle.transport.send({
+                        t: "mirror.image.ack",
+                        transferId: message.transferId,
+                        seq: message.seq,
+                        generation: message.generation,
+                    });
+                }
+            }, (error) => {
+                if (handle.dead)
+                    return;
+                if (handle.imageTransfers.get(message.transferId) === transfer && transfer) {
+                    delete transfer.publication;
+                    delete transfer.commitSeq;
+                }
+                handle.transport.send({
+                    t: "mirror.image.nack",
+                    transferId: message.transferId,
+                    seq: message.seq,
+                    generation: message.generation,
+                    classification: mirrorNackClassification(error),
+                    message: errorMessage(error),
+                });
             });
-            return;
         }
-        let releaseTarget;
-        const targetReservation = new Promise((resolve) => {
-            releaseTarget = resolve;
-        });
-        let releaseSource;
-        const sourceReservation = new Promise((resolve) => {
-            releaseSource = resolve;
+        else {
+            void delivered.then(() => {
+                commitDeliveredObservation();
+                this.releaseMirrorDelivery(handle, message.deliveryId);
+                if (!handle.dead) {
+                    handle.transport.send({
+                        t: "mirror.ack",
+                        deliveryId: message.deliveryId,
+                        generation: message.generation,
+                    });
+                }
+            }, (error) => {
+                const abandonToken = mirrorAbandonToken(error);
+                if (handle.dead) {
+                    // The child can disappear while SQLite publication is still in
+                    // flight. A later exact pending-input failure still owns cleanup;
+                    // only the wire NACK is impossible after process death.
+                    if (abandonToken) {
+                        this.mirrorAbandonListener?.(message.sessionId, abandonToken);
+                    }
+                    return;
+                }
+                {
+                    const classification = mirrorNackClassification(error);
+                    const delivery = handle.mirrorDeliveries.get(message.deliveryId);
+                    if (delivery && abandonToken)
+                        delivery.abandonToken = abandonToken;
+                    if (classification === "permanent" &&
+                        message.attempt >= 3 &&
+                        abandonToken) {
+                        this.mirrorAbandonListener?.(message.sessionId, abandonToken);
+                        this.releaseMirrorDelivery(handle, message.deliveryId);
+                    }
+                    else if (delivery?.abandonRequested && abandonToken) {
+                        this.mirrorAbandonListener?.(delivery.sessionId, abandonToken);
+                        this.releaseMirrorDelivery(handle, message.deliveryId);
+                    }
+                    else if (!abandonToken) {
+                        this.releaseMirrorDelivery(handle, message.deliveryId);
+                    }
+                    else if (delivery && !delivery.cleanupTimer) {
+                        // A timely NACK may be retried with a fresh delivery id. Retain
+                        // the old association briefly for the timeout/NACK race, then
+                        // release it if the child never reports an ambiguous outcome.
+                        const timer = setTimeout(() => {
+                            this.releaseMirrorDelivery(handle, message.deliveryId);
+                        }, 60_000);
+                        timer.unref?.();
+                        delivery.cleanupTimer = timer;
+                    }
+                    handle.transport.send({
+                        t: "mirror.nack",
+                        deliveryId: message.deliveryId,
+                        generation: message.generation,
+                        classification,
+                        message: errorMessage(error),
+                    });
+                }
+            });
+        }
+    }
+    releaseMirrorDelivery(handle, deliveryId) {
+        const delivery = handle.mirrorDeliveries.get(deliveryId);
+        if (!delivery)
+            return;
+        if (delivery.cleanupTimer)
+            clearTimeout(delivery.cleanupTimer);
+        handle.mirrorDeliveries.delete(deliveryId);
+    }
+    failMirrorImageTransfer(handle, reason) {
+        handle.imageTransfers.clear();
+        void this.terminateHandle(handle, reason).catch((error) => {
+            logTerminationFailure(handle, error);
         });
-        this.forkReservations.set(message.to, targetReservation);
-        this.sourceForkReservations.set(message.from, sourceReservation);
-        this.forkBufferedMessages.set(message.to, []);
-        this.forkBufferedTerminalInputs.set(message.to, []);
-        // The physical pane has already rotated. Remove every old routing alias now:
-        // a later request for the source must spawn a fresh runner that resumes the
-        // source Provider binding, while existing terminal attachments continue to
-        // follow the transferred pane.
-        for (const [key, candidate] of this.handles) {
-            if (candidate !== handle)
-                continue;
-            this.handles.delete(key);
-            this.liveSessionKeys.delete(key);
-            this.liveOptions.delete(key);
-        }
-        const rotation = {
-            from: message.from,
-            to: message.to,
-            kind: message.kind,
-            workspace: message.workspace,
-            execution: message.execution,
-            ...(message.parentSessionId ? { parentSessionId: message.parentSessionId } : {}),
-        };
-        void Promise.resolve(this.rotateListener?.(rotation))
-            .then(() => {
-            // The server's rotation listener resolves only after the target Session
-            // is published. Release the terminal admission handoff afterwards so a
-            // maintenance snapshot cannot observe a gap with neither source work
-            // nor the target Session.
-            this.settleTerminalRotationHandoff(handle, message.from, message.to);
-            if (handle.dead)
+    }
+    deliverRotateMessage(handle, message) {
+        const generation = message.generation;
+        if (handle.completedRotation?.rotationId === message.rotationId &&
+            handle.completedRotation.generation === generation &&
+            handle.completedRotation.from === message.from &&
+            handle.completedRotation.to === message.to) {
+            handle.transport.send({
+                t: "rotate.ack",
+                rotationId: message.rotationId,
+                generation,
+            });
+            return;
+        }
+        let pending = handle.pendingRotation;
+        if (pending) {
+            if (pending.rotationId !== message.rotationId ||
+                pending.generation !== generation ||
+                pending.from !== message.from ||
+                pending.to !== message.to ||
+                pending.kind !== message.kind) {
+                void this.terminateHandle(handle, "conflicting Session rotation replay").catch((error) => logTerminationFailure(handle, error));
+                return;
+            }
+            if (pending.publicationComplete) {
+                handle.transport.send({
+                    t: "rotate.ack",
+                    rotationId: pending.rotationId,
+                    generation: pending.generation,
+                });
+                return;
+            }
+            if (pending.inFlight)
+                return;
+        }
+        else {
+            if (this.forkReservations.has(message.to) ||
+                this.sourceForkReservations.has(message.from)) {
+                void this.terminateHandle(handle, "conflicting Session rotation").catch((error) => logTerminationFailure(handle, error));
+                return;
+            }
+            try {
+                // Rotate the runtime-local context before publishing the new Session
+                // alias to routing or observers. This prevents the new identity from
+                // briefly inheriting stale context after `/clear` or `/fork`.
+                handle.sessionContext?.rotate(message.to);
+            }
+            catch (error) {
+                const reason = `runner Session context rotation failed: ${errorMessage(error)}`;
+                void this.terminateHandle(handle, reason).catch((terminationError) => {
+                    logTerminationFailure(handle, terminationError);
+                });
                 return;
-            this.handles.set(message.to, handle);
-            this.liveSessionKeys.add(message.to);
-            this.liveOptions.set(message.to, {
-                workspace: structuredClone(message.workspace),
-                execution: structuredClone(message.execution),
+            }
+            let releaseTarget;
+            const targetReservation = new Promise((resolve) => {
+                releaseTarget = resolve;
             });
-            for (const entry of this.forkBufferedMessages.get(message.to) ?? []) {
-                this.deliverForkBufferedMessage(entry.handle, entry.message);
+            let releaseSource;
+            const sourceReservation = new Promise((resolve) => {
+                releaseSource = resolve;
+            });
+            pending = {
+                rotationId: message.rotationId,
+                generation,
+                from: message.from,
+                to: message.to,
+                kind: message.kind,
+                rotation: {
+                    from: message.from,
+                    to: message.to,
+                    kind: message.kind,
+                    workspace: structuredClone(message.workspace),
+                    execution: structuredClone(message.execution),
+                    ...(message.parentSessionId ? { parentSessionId: message.parentSessionId } : {}),
+                },
+                targetReservation,
+                sourceReservation,
+                releaseTarget,
+                releaseSource,
+                inFlight: false,
+                logicalTargetPublished: false,
+                publicationComplete: false,
+            };
+            handle.pendingRotation = pending;
+            this.forkReservations.set(pending.to, targetReservation);
+            this.sourceForkReservations.set(pending.from, sourceReservation);
+            this.forkBufferedMessages.set(pending.to, []);
+            this.forkBufferedTerminalInputs.set(pending.to, []);
+        }
+        pending.inFlight = true;
+        void Promise.resolve().then(async () => {
+            if (pending.logicalTargetPublished)
+                return;
+            await this.rotateListener?.(pending.rotation);
+            if (handle.dead || handle.pendingRotation !== pending)
+                return false;
+            pending.logicalTargetPublished = true;
+            return true;
+        })
+            .then((current) => {
+            if (current === false || handle.dead || handle.pendingRotation !== pending)
+                return false;
+            return this.publishNativeRotationBinding(pending).then(() => true);
+        })
+            .then((current) => {
+            if (current === false || handle.dead || handle.pendingRotation !== pending) {
+                if (handle.pendingRotation === pending) {
+                    this.releasePendingNativeRotation(handle, pending);
+                }
+                return;
             }
-            for (const entry of this.forkBufferedTerminalInputs.get(message.to) ?? []) {
-                if (!entry.handle.dead)
-                    entry.handle.transport.send(entry.message);
+            pending.inFlight = false;
+            pending.publicationComplete = true;
+            // Durable publication grants the child permission to move ownership.
+            // Keep both logical ids fenced until rotate.applied proves that the
+            // child has actually transferred its terminal/runtime registries.
+            try {
+                handle.transport.send({
+                    t: "rotate.ack",
+                    rotationId: pending.rotationId,
+                    generation: pending.generation,
+                });
+            }
+            catch (error) {
+                this.releasePendingNativeRotation(handle, pending);
+                void this.terminateHandle(handle, `runner Session rotation commit failed: ${errorMessage(error)}`).catch((terminationError) => {
+                    logTerminationFailure(handle, terminationError);
+                });
             }
         })
             .catch((error) => {
-            void this.terminateHandle(handle, `Session rotation publication failed: ${errorMessage(error)}`).catch((terminationError) => logTerminationFailure(handle, terminationError));
-        })
-            .finally(() => {
-            if (this.forkReservations.get(message.to) === targetReservation) {
-                this.forkReservations.delete(message.to);
+            if (handle.pendingRotation !== pending)
+                return;
+            pending.inFlight = false;
+            if (handle.dead) {
+                this.releasePendingNativeRotation(handle, pending);
+                return;
             }
-            if (this.sourceForkReservations.get(message.from) === sourceReservation) {
-                this.sourceForkReservations.delete(message.from);
+            try {
+                handle.transport.send({
+                    t: "rotate.nack",
+                    rotationId: pending.rotationId,
+                    generation: pending.generation,
+                    classification: mirrorNackClassification(error),
+                    message: errorMessage(error),
+                });
             }
-            this.forkBufferedMessages.delete(message.to);
-            this.forkBufferedTerminalInputs.delete(message.to);
-            releaseTarget();
-            releaseSource();
+            catch (sendError) {
+                this.releasePendingNativeRotation(handle, pending);
+                void this.terminateHandle(handle, `runner Session rotation NACK failed: ${errorMessage(sendError)}`).catch((terminationError) => {
+                    logTerminationFailure(handle, terminationError);
+                });
+            }
+        });
+    }
+    /** Bridge ownership is a child-local binding, but the parent is the only
+     * process that knows logical target publication committed. Mark that fact
+     * durably before allowing the child to apply and expose the alias. */
+    async publishNativeRotationBinding(pending) {
+        await this.publishNativeRotationRecords(pending.from, pending.to, pending.kind);
+    }
+    async publishNativeRotationRecords(from, to, kind) {
+        const target = await this.sessionStore.get(to);
+        const source = await this.sessionStore.get(from);
+        if (!target) {
+            throw new AgentRuntimeError("native rotation target binding is missing", 422, "native_rotation_target_missing");
+        }
+        const publishedTarget = {
+            ...target,
+            nativeRotationSourceSessionId: from,
+            nativeRotationKind: kind,
+            nativeRotationPublished: true,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.sessionStore.set(publishedTarget);
+        if (!source)
+            return;
+        await this.sessionStore.set({
+            ...source,
+            bridgeOwnerSessionId: `${from}-${kind}-retired-${to}`,
+            nativeRotationTargetSessionId: to,
+            updatedAt: new Date().toISOString(),
         });
     }
+    deliverRotateAppliedMessage(handle, message) {
+        const pending = handle.pendingRotation;
+        if (pending &&
+            pending.publicationComplete &&
+            pending.rotationId === message.rotationId &&
+            pending.generation === message.generation &&
+            pending.from === message.from &&
+            pending.to === message.to) {
+            void this.finalizeNativeRotation(handle, pending);
+            return;
+        }
+        if (handle.completedRotation?.rotationId === message.rotationId &&
+            handle.completedRotation.generation === message.generation &&
+            handle.completedRotation.from === message.from &&
+            handle.completedRotation.to === message.to) {
+            this.acknowledgeRotateApplied(handle, message.rotationId, message.generation);
+            return;
+        }
+        void this.terminateHandle(handle, "invalid Session rotation applied confirmation").catch((error) => logTerminationFailure(handle, error));
+    }
+    finalizeNativeRotation(handle, pending) {
+        if (pending.finalization)
+            return pending.finalization;
+        const operation = (async () => {
+            if (handle.pendingRotation !== pending)
+                return false;
+            pending.inFlight = true;
+            try {
+                // Change the active Session only after ownership transfer. In
+                // this IPC topology rotate.applied is the child-owned equivalent proof.
+                this.settleTerminalRotationHandoff(handle, pending.from, pending.to);
+                handle.activeResponseIds.clear();
+                for (const [key, candidate] of this.handles) {
+                    if (candidate !== handle)
+                        continue;
+                    this.handles.delete(key);
+                    this.liveSessionKeys.delete(key);
+                    this.liveOptions.delete(key);
+                }
+                handle.activeSessionId = pending.to;
+                this.handles.set(pending.to, handle);
+                this.liveSessionKeys.add(pending.to);
+                this.liveOptions.set(pending.to, {
+                    workspace: structuredClone(pending.rotation.workspace),
+                    execution: structuredClone(pending.rotation.execution),
+                });
+                handle.completedRotation = {
+                    rotationId: pending.rotationId,
+                    generation: pending.generation,
+                    from: pending.from,
+                    to: pending.to,
+                };
+                // Old-Session presentation is ordered internally but must not hold the
+                // ownership-transfer ACK. Each notice still receives the server queue's
+                // bounded result window; the rotated target can proceed immediately.
+                const noticePublication = this.publishNativeRotationNotice(pending);
+                if (handle.dead)
+                    return false;
+                this.acknowledgeRotateApplied(handle, pending.rotationId, pending.generation);
+                for (const entry of this.forkBufferedMessages.get(pending.to) ?? []) {
+                    this.deliverForkBufferedMessage(entry.handle, entry.message);
+                }
+                for (const entry of this.forkBufferedTerminalInputs.get(pending.to) ?? []) {
+                    if (!entry.handle.dead)
+                        entry.handle.transport.send(entry.message);
+                }
+                void noticePublication.catch((error) => {
+                    console.error(`Session rotation notice sequence failed for ${pending.from} -> ${pending.to}: ${errorMessage(error)}`);
+                });
+                return true;
+            }
+            catch (error) {
+                void this.terminateHandle(handle, `runner Session rotation finalization failed: ${errorMessage(error)}`).catch((terminationError) => {
+                    logTerminationFailure(handle, terminationError);
+                });
+                return false;
+            }
+            finally {
+                pending.inFlight = false;
+                this.releasePendingNativeRotation(handle, pending);
+            }
+        })();
+        pending.finalization = operation;
+        return operation;
+    }
+    acknowledgeRotateApplied(handle, rotationId, generation) {
+        try {
+            handle.transport.send({ t: "rotate.applied.ack", rotationId, generation });
+        }
+        catch (error) {
+            void this.terminateHandle(handle, `runner Session rotation applied ACK failed: ${errorMessage(error)}`).catch((terminationError) => {
+                logTerminationFailure(handle, terminationError);
+            });
+        }
+    }
+    releasePendingNativeRotation(handle, pending) {
+        if (handle.pendingRotation !== pending)
+            return;
+        delete handle.pendingRotation;
+        if (this.forkReservations.get(pending.to) === pending.targetReservation) {
+            this.forkReservations.delete(pending.to);
+        }
+        if (this.sourceForkReservations.get(pending.from) === pending.sourceReservation) {
+            this.sourceForkReservations.delete(pending.from);
+        }
+        this.forkBufferedMessages.delete(pending.to);
+        this.forkBufferedTerminalInputs.delete(pending.to);
+        pending.releaseTarget();
+        pending.releaseSource();
+    }
+    async publishNativeRotationNotice(pending) {
+        // Only /clear supersedes the old Session. A /fork keeps
+        // both conversations live and therefore emits no old-session redirect.
+        if (pending.kind !== "clear" || pending.from === pending.to)
+            return;
+        this.mirrorSupersedeListener?.(pending.from);
+        const noticeId = `msg_clear_${randomUUID().replaceAll("-", "")}`;
+        const notice = {
+            type: "response.output_item.done",
+            responseId: noticeId,
+            item: {
+                id: noticeId,
+                sessionId: pending.from,
+                position: 0,
+                responseId: noticeId,
+                status: "completed",
+                createdAt: Date.now(),
+                type: "message",
+                data: {
+                    role: "assistant",
+                    content: [{
+                            type: "output_text",
+                            text: "This session was ended by `/clear`. " +
+                                `Continue in [the new session](../${encodeURIComponent(pending.to)}). ` +
+                                "You can also send a message here to resume this session.",
+                        }],
+                },
+            },
+        };
+        const transient = {
+            type: "session.rotated",
+            sessionId: pending.from,
+            newSessionId: pending.to,
+            kind: "clear",
+        };
+        // Preserve the post-clear order: stop the old spinner, append a
+        // durable assistant notice, then tell a live viewer to follow the target.
+        const publications = [];
+        for (const event of [
+            {
+                type: "session.status",
+                sessionId: pending.from,
+                status: "idle",
+                backgroundTaskCount: 0,
+            },
+            notice,
+            transient,
+        ]) {
+            try {
+                // The server-side SessionMirrorQueue owns the per-record
+                // per-record result deadline. A second enqueue-time timer here would
+                // expire later records before they reach the head of that queue.
+                publications.push(Promise.resolve(this.mirrorListener?.(pending.from, event)).catch((error) => {
+                    console.error(`Session rotation notice failed for ${pending.from} -> ${pending.to}: ${errorMessage(error)}`);
+                }));
+            }
+            catch (error) {
+                console.error(`Session rotation notice failed for ${pending.from} -> ${pending.to}: ${errorMessage(error)}`);
+            }
+        }
+        await Promise.all(publications);
+    }
     spawnHandle(key) {
         const args = this.runnerEntry.endsWith(".ts")
             ? ["--import", "tsx", this.runnerEntry]
@@ -1140,18 +1831,22 @@ export class RunnerManager {
         const transport = new StdioRunnerTransport(child.stdout, child.stdin);
         const handle = {
             key,
+            activeSessionId: key,
             child,
             transport,
             stderr: [],
             lastUsedAt: this.now(),
+            activeResponseIds: new Set(),
+            terminalResponseIds: new Set(),
             dead: false,
             completion,
-            terminalCleanupRetryFailures: 0,
             processGroup,
             ...(sessionContext ? { sessionContext } : {}),
             caps: new Map(),
             terminals: new Map(),
             live: new Map(),
+            imageTransfers: new Map(),
+            mirrorDeliveries: new Map(),
         };
         this.childHandles.add(handle);
         void completion.then(() => this.childHandles.delete(handle));
@@ -1165,8 +1860,14 @@ export class RunnerManager {
                 }
             });
         }
-        child.on("error", (error) => this.failHandle(handle, error.message));
-        child.on("exit", (code, signal) => this.failHandle(handle, `runner exited (code=${code ?? "null"}${signal ? `, signal=${signal}` : ""})`));
+        const failAndReap = (reason) => {
+            this.failHandle(handle, reason);
+            void this.terminateHandle(handle, reason).catch((error) => {
+                logTerminationFailure(handle, error);
+            });
+        };
+        child.on("error", (error) => failAndReap(error.message));
+        child.on("exit", (code, signal) => failAndReap(`runner exited (code=${code ?? "null"}${signal ? `, signal=${signal}` : ""})`));
         return handle;
     }
     onChildMessage(handle, msg) {
@@ -1187,55 +1888,287 @@ export class RunnerManager {
                 }
                 return;
             }
-            case "term.opened":
-                handle.terminals.get(msg.attachId)?._opened(msg.role);
+            case "term.prepared":
+                handle.terminals.get(msg.attachId)?._prepared(msg.role, msg.seedBytes, msg.cols, msg.rows);
                 return;
-            case "term.data":
-                handle.terminals.get(msg.attachId)?._data(msg.dataB64);
+            case "term.seed.chunk":
+                handle.terminals.get(msg.attachId)?._chunk(msg.reqId, "seed", msg.dataB64, msg.nextOffset, msg.done, msg.finalOffset);
                 return;
-            case "term.exit": {
-                const terminal = handle.terminals.get(msg.attachId);
-                handle.terminals.delete(msg.attachId);
-                terminal?._exit(msg.exitCode);
+            case "term.started":
+                handle.terminals.get(msg.attachId)?._started(msg.reqId);
+                return;
+            case "term.chunk":
+                handle.terminals.get(msg.attachId)?._chunk(msg.reqId, "read", msg.dataB64, msg.nextOffset, msg.done, msg.finalOffset);
+                return;
+            case "term.dimensions":
+                handle.terminals.get(msg.attachId)?._dimensions(msg.cols, msg.rows);
+                return;
+            case "term.reader.done":
+                handle.terminals.get(msg.attachId)?._readerDone({
+                    finalOffset: msg.finalOffset,
+                    reason: msg.reason,
+                    exitCode: msg.exitCode,
+                });
+                return;
+            case "term.ack":
+                handle.terminals.get(msg.attachId)?._ack(msg.reqId, msg.operation);
                 return;
-            }
             case "term.error": {
                 const terminal = handle.terminals.get(msg.attachId);
-                handle.terminals.delete(msg.attachId);
-                terminal?._fail(msg.message, msg.code);
+                if (!msg.reqId)
+                    handle.terminals.delete(msg.attachId);
+                terminal?._fail(msg.message, msg.code, msg.reqId);
                 return;
             }
             case "mirror":
                 if (handle.dead)
                     return;
+                if (!msg.deliveryId ||
+                    !Number.isSafeInteger(msg.generation) ||
+                    !Number.isSafeInteger(msg.attempt) ||
+                    msg.attempt < 1) {
+                    void this.terminateHandle(handle, "invalid durable mirror delivery frame").catch((error) => logTerminationFailure(handle, error));
+                    return;
+                }
                 if (this.bufferForkTargetMessage(handle, msg))
                     return;
-                this.mirrorListener?.(msg.sessionId, msg.event);
-                if (msg.event.type === "response.created") {
-                    // The listener projects response.created into SessionRuntimeIndex
-                    // synchronously. Only then may the accepted terminal reservation
-                    // drain into a maintenance activity snapshot.
-                    this.settleTerminalInputHandoff(handle, msg.sessionId, "turn");
+                this.deliverMirrorMessage(handle, msg);
+                return;
+            case "mirror.abandon": {
+                if (!msg.deliveryId || !Number.isSafeInteger(msg.generation)) {
+                    void this.terminateHandle(handle, "invalid mirror abandon frame").catch((error) => logTerminationFailure(handle, error));
+                    return;
+                }
+                const delivery = handle.mirrorDeliveries.get(msg.deliveryId);
+                if (!delivery)
+                    return;
+                delivery.abandonRequested = true;
+                if (delivery.abandonToken) {
+                    this.mirrorAbandonListener?.(delivery.sessionId, delivery.abandonToken);
+                    this.releaseMirrorDelivery(handle, msg.deliveryId);
+                }
+                return;
+            }
+            case "mirror.image.begin": {
+                if (!Number.isSafeInteger(msg.generation)) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer generation");
+                    return;
+                }
+                if (this.isStaleMirrorGeneration(handle, msg.generation)) {
+                    handle.transport.send({
+                        t: "mirror.image.ack",
+                        transferId: msg.transferId,
+                        seq: 0,
+                        generation: msg.generation,
+                    });
+                    return;
+                }
+                const existing = handle.imageTransfers.get(msg.transferId);
+                if (existing) {
+                    const exactReplay = existing.sessionId === msg.sessionId &&
+                        existing.generation === msg.generation &&
+                        existing.totalChars === msg.totalChars &&
+                        JSON.stringify(existing.event) === JSON.stringify(msg.event);
+                    if (!exactReplay) {
+                        this.failMirrorImageTransfer(handle, "conflicting generated image transfer replay");
+                        return;
+                    }
+                    handle.transport.send({
+                        t: "mirror.image.ack",
+                        transferId: msg.transferId,
+                        seq: 0,
+                        generation: msg.generation,
+                    });
+                    return;
+                }
+                if (handle.dead ||
+                    !Number.isSafeInteger(msg.totalChars) ||
+                    msg.totalChars <= 0 ||
+                    msg.totalChars > RUNNER_IMAGE_MAX_RESULT_CHARS ||
+                    !isDetachedGeneratedImageEvent(msg.event)) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer start");
+                    return;
+                }
+                handle.imageTransfers.set(msg.transferId, {
+                    sessionId: msg.sessionId,
+                    generation: msg.generation,
+                    event: msg.event,
+                    totalChars: msg.totalChars,
+                    receivedChars: 0,
+                    nextSeq: 1,
+                    chunks: [],
+                });
+                handle.transport.send({
+                    t: "mirror.image.ack",
+                    transferId: msg.transferId,
+                    seq: 0,
+                    generation: msg.generation,
+                });
+                return;
+            }
+            case "mirror.image.chunk": {
+                if (!Number.isSafeInteger(msg.generation)) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer generation");
+                    return;
+                }
+                if (this.isStaleMirrorGeneration(handle, msg.generation)) {
+                    handle.transport.send({
+                        t: "mirror.image.ack",
+                        transferId: msg.transferId,
+                        seq: msg.seq,
+                        generation: msg.generation,
+                    });
+                    return;
+                }
+                const transfer = handle.imageTransfers.get(msg.transferId);
+                if (transfer &&
+                    msg.seq > 0 &&
+                    msg.seq < transfer.nextSeq &&
+                    transfer.chunks[msg.seq - 1] === msg.data) {
+                    handle.transport.send({
+                        t: "mirror.image.ack",
+                        transferId: msg.transferId,
+                        seq: msg.seq,
+                        generation: transfer.generation,
+                    });
+                    return;
+                }
+                if (handle.dead ||
+                    !transfer ||
+                    msg.seq !== transfer.nextSeq ||
+                    !msg.data ||
+                    msg.data.length > RUNNER_IMAGE_CHUNK_CHARS ||
+                    transfer.receivedChars + msg.data.length > transfer.totalChars) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer chunk");
+                    return;
+                }
+                transfer.chunks.push(msg.data);
+                transfer.receivedChars += msg.data.length;
+                transfer.nextSeq += 1;
+                handle.transport.send({
+                    t: "mirror.image.ack",
+                    transferId: msg.transferId,
+                    seq: msg.seq,
+                    generation: transfer.generation,
+                });
+                return;
+            }
+            case "mirror.image.commit": {
+                if (!Number.isSafeInteger(msg.generation)) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer generation");
+                    return;
+                }
+                if (this.isStaleMirrorGeneration(handle, msg.generation)) {
+                    handle.imageTransfers.delete(msg.transferId);
+                    handle.transport.send({
+                        t: "mirror.image.ack",
+                        transferId: msg.transferId,
+                        seq: msg.seq,
+                        generation: msg.generation,
+                    });
+                    return;
+                }
+                const transfer = handle.imageTransfers.get(msg.transferId);
+                if (handle.dead ||
+                    !transfer ||
+                    msg.seq !== transfer.nextSeq ||
+                    transfer.receivedChars !== transfer.totalChars) {
+                    this.failMirrorImageTransfer(handle, "invalid generated image transfer commit");
+                    return;
+                }
+                if (transfer.commitSeq !== undefined) {
+                    if (transfer.commitSeq !== msg.seq) {
+                        this.failMirrorImageTransfer(handle, "conflicting generated image transfer commit");
+                    }
+                    // The original publication owns the eventual ACK/NACK. A replay can
+                    // arrive after its ACK timer elapsed; that eventual result resolves
+                    // the replacement waiter because transferId+seq are stable.
+                    return;
+                }
+                transfer.commitSeq = msg.seq;
+                const event = attachGeneratedImageResult(transfer.event, transfer.chunks.join(""));
+                if (!event) {
+                    this.failMirrorImageTransfer(handle, "generated image transfer target changed");
+                    return;
+                }
+                const mirrored = {
+                    t: "mirror",
+                    sessionId: transfer.sessionId,
+                    event,
+                    transferId: msg.transferId,
+                    seq: msg.seq,
+                    generation: transfer.generation,
+                };
+                if (this.bufferForkTargetMessage(handle, mirrored)) {
+                    handle.transport.send({
+                        t: "mirror.image.hold",
+                        transferId: msg.transferId,
+                        seq: msg.seq,
+                        generation: transfer.generation,
+                    });
+                    return;
+                }
+                this.deliverMirrorMessage(handle, mirrored);
+                return;
+            }
+            case "mirror.image.abandon": {
+                if (!Number.isSafeInteger(msg.generation))
+                    return;
+                const transfer = handle.imageTransfers.get(msg.transferId);
+                if (transfer && transfer.generation === msg.generation) {
+                    handle.imageTransfers.delete(msg.transferId);
                 }
                 return;
+            }
             case "rotate": {
                 if (handle.dead)
                     return;
+                if (!msg.rotationId || !Number.isSafeInteger(msg.generation)) {
+                    void this.terminateHandle(handle, "invalid Session rotation frame").catch((error) => logTerminationFailure(handle, error));
+                    return;
+                }
                 if (this.bufferForkTargetMessage(handle, msg))
                     return;
                 this.deliverRotateMessage(handle, msg);
                 return;
             }
+            case "rotate.applied": {
+                if (handle.dead)
+                    return;
+                this.deliverRotateAppliedMessage(handle, msg);
+                return;
+            }
+            case "terminal.lifecycle.ended": {
+                if (msg.lifecycle === "required") {
+                    void this.terminateHandle(handle, `required Terminal exited with status ${msg.status}`).catch((error) => logTerminationFailure(handle, error));
+                }
+                return;
+            }
+            case "terminal.reaped": {
+                const resolve = handle.live.get(msg.reqId);
+                handle.live.delete(msg.reqId);
+                resolve?.({ ok: msg.ok, error: msg.error });
+                return;
+            }
             case "live.ready":
             case "interrupted":
             case "injected": {
                 const resolve = handle.live.get(msg.reqId);
                 handle.live.delete(msg.reqId);
                 resolve?.(msg.t === "injected"
-                    ? { outcome: msg.outcome, error: msg.error }
+                    ? { result: msg.result, error: msg.error }
                     : { ok: msg.ok, error: msg.error });
                 return;
             }
+            case "collaboration.updated": {
+                const resolve = handle.live.get(msg.reqId);
+                handle.live.delete(msg.reqId);
+                resolve?.({
+                    collaborationUpdated: msg.ok,
+                    ...(msg.error ? { error: msg.error } : {}),
+                });
+                return;
+            }
             case "interaction.resolved": {
                 const resolve = handle.live.get(msg.reqId);
                 handle.live.delete(msg.reqId);
@@ -1245,11 +2178,12 @@ export class RunnerManager {
         }
     }
     /** Mark a handle dead and reject every pending run/cap with the exit reason. */
-    failHandle(handle, reason) {
+    failHandle(handle, reason, opts = {}) {
         if (handle.dead) {
             return;
         }
         handle.dead = true;
+        handle.failureReason = reason;
         closeOwnedSessionContext(handle);
         // Drop every key mapping to this handle — its launch key AND any rotation
         // aliases (claude `/clear`·`/fork` terminal transfer).
@@ -1262,8 +2196,20 @@ export class RunnerManager {
                 }
             }
         }
+        if (handle.pendingRotation) {
+            // A publication already inside its durable binding write owns both
+            // reservations until that Promise settles. Releasing here would let a
+            // replacement source child open against the old binding while the stale
+            // chain can still commit target/source ownership records.
+            if (!handle.pendingRotation.inFlight) {
+                this.releasePendingNativeRotation(handle, handle.pendingRotation);
+            }
+        }
         const tail = handle.stderr.join("\n");
         const message = tail ? `${reason}\n--- runner log tail ---\n${tail}` : reason;
+        if (opts.failActiveResponses !== false) {
+            this.failActiveResponses(handle, "runner_crashed", message);
+        }
         const error = new AgentRuntimeError(message, 500, "runner_crashed");
         for (const pending of handle.caps.values()) {
             pending.reject(error);
@@ -1272,20 +2218,23 @@ export class RunnerManager {
             terminal._fail(message);
         }
         for (const resolve of handle.live.values()) {
-            resolve({ ok: false, error: message });
+            resolve({
+                ok: false,
+                error: { message, code: "runner_crashed", statusCode: 500 },
+            });
         }
         handle.caps.clear();
         handle.terminals.clear();
         handle.live.clear();
+        handle.imageTransfers.clear();
+        for (const deliveryId of handle.mirrorDeliveries.keys()) {
+            this.releaseMirrorDelivery(handle, deliveryId);
+        }
         handle.transport.close();
     }
     terminateHandle(handle, reason) {
         if (handle.termination)
             return handle.termination;
-        if (handle.terminalCleanupRetryTimer) {
-            clearTimeout(handle.terminalCleanupRetryTimer);
-            delete handle.terminalCleanupRetryTimer;
-        }
         const attempt = (async () => {
             if (!handle.dead) {
                 try {
@@ -1294,7 +2243,8 @@ export class RunnerManager {
                 catch {
                     // The process signal below remains the authoritative shutdown path.
                 }
-                this.failHandle(handle, reason);
+                this.interruptActiveResponses(handle);
+                this.failHandle(handle, reason, { failActiveResponses: false });
             }
             this.signalChild(handle.child, "SIGTERM", handle.processGroup);
             let childExited = await waitForChildExit(handle.completion, this.shutdownGraceMs);
@@ -1302,15 +2252,14 @@ export class RunnerManager {
                 this.signalChild(handle.child, "SIGKILL", handle.processGroup);
                 childExited = await waitForChildExit(handle.completion, this.shutdownKillGraceMs);
             }
-            const terminalStopped = handle.key === CAP_KEY
-                ? true
-                : await Promise.resolve(this.terminateTerminalServer(`${handle.key}-main`)).catch(() => false);
+            if (handle.key !== CAP_KEY) {
+                await Promise.resolve(this.terminateTerminalServer(`${handle.key}-main`, handle.child.pid)).catch((error) => {
+                    console.warn(`[runner-manager] best-effort terminal close failed for ${handle.key}-main: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
             if (!childExited) {
                 throw new Error(`runner child ${handle.child.pid ?? handle.key} did not exit after SIGKILL`);
             }
-            if (!terminalStopped) {
-                throw new Error(`runner terminal ${handle.key}-main remained live after child exit`);
-            }
             this.childHandles.delete(handle);
         })();
         handle.termination = attempt;
@@ -1319,34 +2268,246 @@ export class RunnerManager {
         }, () => {
             if (handle.termination === attempt)
                 delete handle.termination;
-            handle.terminalCleanupRetryFailures += 1;
-            // A failed cleanup must not pin closeAndDrain forever. Keep the
-            // submission in the daemon activity snapshot, but release its gate
-            // reservation so maintenance returns a structured busy result.
+            // A child that survives SIGKILL is still real activity. Release the
+            // gate reservation but retain the handoff until a later explicit stop.
             this.preserveTerminalInputHandoffsAsActivity(handle);
-            this.scheduleTerminalInputCleanupRetry(handle);
         });
         return attempt;
     }
     reapIdle() {
+        if (this.reapPromise)
+            return this.reapPromise;
+        const attempt = this.reapIdleOnce();
+        this.reapPromise = attempt;
+        const clear = () => {
+            if (this.reapPromise === attempt)
+                this.reapPromise = null;
+        };
+        void attempt.then(clear, clear);
+        return attempt;
+    }
+    async reapIdleOnce() {
         const now = this.now();
         for (const [key, handle] of this.handles) {
-            if (handle.caps.size > 0 || handle.terminals.size > 0) {
+            if (this.isManagedNativeHandle(handle)) {
+                await this.reapNativePane(handle, now);
                 continue;
             }
-            // A live codex forwarder must outlive terminal detach / idle turns — it is
-            // the session's single event writer, so never reap a session that has one.
-            if (this.liveSessionKeys.has(key)) {
+            if (handle.caps.size > 0 || handle.terminals.size > 0 || handle.live.size > 0) {
                 continue;
             }
-            if (now - handle.lastUsedAt < this.idleTtlMs) {
+            const idleForMs = now - handle.lastUsedAt;
+            if (idleForMs < this.idleTtlMs) {
                 continue;
             }
-            void this.terminateHandle(handle, "idle runner reaped").catch((error) => {
+            const hasActiveResponse = handle.activeResponseIds.size > 0;
+            if (hasActiveResponse)
+                continue;
+            const reason = this.liveSessionKeys.has(key)
+                ? "idle live runner reaped"
+                : "idle runner reaped";
+            void this.terminateHandle(handle, reason).catch((error) => {
                 logTerminationFailure(handle, error);
             });
         }
     }
+    /** Provider-authoritative turn state is the lifecycle truth; attached clients
+     * and tmux's own activity clock are independent busy evidence. There is no
+     * "user was inactive for an hour" override for an active turn. */
+    async reapNativePane(handle, now) {
+        if (this.nativePaneIdleTtlMs <= 0 || handle.dead)
+            return;
+        if (await this.isNativePaneBusy(handle)) {
+            handle.nativePaneLastBusyAt = now;
+            return;
+        }
+        const lastBusyAt = handle.nativePaneLastBusyAt;
+        if (lastBusyAt === undefined) {
+            // First idle observation starts a full grace window.
+            handle.nativePaneLastBusyAt = now;
+            return;
+        }
+        if (now - lastBusyAt < this.nativePaneIdleTtlMs)
+            return;
+        // Close the select→reap race: activity may begin after classification but
+        // before teardown.
+        if (await this.isNativePaneBusy(handle)) {
+            handle.nativePaneLastBusyAt = this.now();
+            return;
+        }
+        // A failed teardown must re-arm on the next scan instead of retrying on
+        // every sweep forever.
+        delete handle.nativePaneLastBusyAt;
+        await this.reapNativeTerminal(handle).catch((error) => {
+            logTerminationFailure(handle, error);
+        });
+    }
+    reapNativeTerminal(handle) {
+        const localThreadId = this.currentTerminalSessionId(handle, handle.key);
+        const terminalId = `${localThreadId}-main`;
+        const reqId = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                if (!handle.live.delete(reqId))
+                    return;
+                reject(new Error(`runner did not acknowledge idle terminal reap within ${this.liveReadyTimeoutMs}ms`));
+            }, this.liveReadyTimeoutMs);
+            timeout.unref?.();
+            handle.live.set(reqId, (reply) => {
+                clearTimeout(timeout);
+                if (reply.ok) {
+                    resolve();
+                    return;
+                }
+                reject(fromWireError(reply.error ?? {
+                    message: "idle terminal reap failed",
+                    code: "terminal_reap_failed",
+                    statusCode: 500,
+                }));
+            });
+            handle.transport.send({
+                t: "terminal.reap",
+                reqId,
+                localThreadId,
+                terminalId,
+            });
+        });
+    }
+    async isNativePaneBusy(handle) {
+        if (handle.activeResponseIds.size > 0 ||
+            handle.caps.size > 0 ||
+            handle.live.size > 0 ||
+            handle.terminals.size > 0) {
+            return true;
+        }
+        const terminalName = `${handle.key}-main`;
+        try {
+            if (await this.terminalHasAttachedClient(terminalName, handle.child.pid))
+                return true;
+        }
+        catch {
+            // A failed probe contributes no busy evidence; check activity next.
+        }
+        let activityAt = null;
+        try {
+            activityAt = await this.terminalWindowActivityAt(terminalName, handle.child.pid);
+        }
+        catch {
+            // A failed probe contributes no busy evidence.
+        }
+        return activityAt !== null &&
+            this.wallNow() - activityAt * 1_000 < this.nativePaneOutputBusyWindowMs;
+    }
+    isManagedNativeHandle(handle) {
+        const sessionId = this.currentTerminalSessionId(handle, handle.key);
+        const provider = this.liveOptions.get(sessionId)?.execution.provider;
+        return isManagedNativeProvider(provider);
+    }
+    failActiveResponses(handle, code, message) {
+        const responseIds = [...handle.activeResponseIds];
+        handle.activeResponseIds.clear();
+        const sessionId = this.currentTerminalSessionId(handle, handle.key);
+        for (const responseId of responseIds) {
+            rememberTerminalResponse(handle, responseId);
+            this.emitCompensatingMirror(handle, sessionId, {
+                type: "response.failed",
+                responseId,
+                error: {
+                    source: "execution",
+                    code,
+                    message,
+                },
+            });
+        }
+    }
+    interruptActiveResponses(handle) {
+        const responseIds = [...handle.activeResponseIds];
+        handle.activeResponseIds.clear();
+        const sessionId = this.currentTerminalSessionId(handle, handle.key);
+        for (const responseId of responseIds) {
+            this.emitCompensatingMirror(handle, sessionId, {
+                type: "session.interrupted",
+                sessionId,
+                responseId,
+            });
+        }
+    }
+    /** Crash/termination compensation is intentionally best-effort because it is
+     * a terminal/status edge rather than an ordinary transcript delivery.
+     * Still consume an asynchronous persistence rejection so a dying child
+     * cannot take the parent daemon down with an unhandled rejection. */
+    emitCompensatingMirror(handle, sessionId, event) {
+        if (!this.mirrorListener)
+            return;
+        try {
+            const result = this.mirrorListener(sessionId, event);
+            if (result && typeof result.then === "function") {
+                void Promise.resolve(result).catch((error) => {
+                    logCompensatingMirrorFailure(handle, sessionId, event.type, error);
+                });
+            }
+        }
+        catch (error) {
+            logCompensatingMirrorFailure(handle, sessionId, event.type, error);
+        }
+    }
+    /** Track the provider-authoritative response lifecycle. Native-pane busy
+     * classification consumes this level directly; output volume is separately
+     * grounded in tmux's own activity clock. */
+    observeHandleRuntimeEvent(handle, event) {
+        switch (event.type) {
+            case "response.created":
+            case "response.output_text.delta":
+            case "response.reasoning_summary_text.delta":
+            case "response.function_call_output.delta":
+            case "response.output_item.done":
+                if (handle.terminalResponseIds.has(event.responseId))
+                    return;
+                handle.activeResponseIds.add(event.responseId);
+                return;
+            case "session.interaction.requested":
+                if (handle.terminalResponseIds.has(event.responseId))
+                    return;
+                handle.activeResponseIds.add(event.responseId);
+                return;
+            case "response.completed":
+            case "response.failed":
+            case "session.interrupted":
+                handle.activeResponseIds.delete(event.responseId);
+                rememberTerminalResponse(handle, event.responseId);
+                return;
+            case "session.status":
+                if (event.status === "running" && event.responseId) {
+                    if (handle.terminalResponseIds.has(event.responseId))
+                        return;
+                    handle.activeResponseIds.add(event.responseId);
+                }
+                else if (event.status !== "running") {
+                    if (event.responseId) {
+                        handle.activeResponseIds.delete(event.responseId);
+                        rememberTerminalResponse(handle, event.responseId);
+                    }
+                    else {
+                        for (const responseId of handle.activeResponseIds) {
+                            rememberTerminalResponse(handle, responseId);
+                        }
+                        handle.activeResponseIds.clear();
+                    }
+                }
+                return;
+            case "session.rotated":
+                handle.activeResponseIds.clear();
+                return;
+            default:
+                return;
+        }
+    }
+    isStaleMirrorGeneration(handle, generation) {
+        const currentGeneration = handle.pendingRotation?.generation ??
+            handle.completedRotation?.generation ??
+            0;
+        return generation < currentGeneration;
+    }
     openSessionContext(sessionId) {
         if (!this.sessionContextProvider)
             return undefined;
@@ -1365,6 +2526,16 @@ export class RunnerManager {
         }
     }
 }
+function rememberTerminalResponse(handle, responseId) {
+    handle.terminalResponseIds.delete(responseId);
+    handle.terminalResponseIds.add(responseId);
+    while (handle.terminalResponseIds.size > MAX_TERMINAL_RESPONSE_IDS) {
+        const oldest = handle.terminalResponseIds.values().next().value;
+        if (!oldest)
+            break;
+        handle.terminalResponseIds.delete(oldest);
+    }
+}
 function trackedTerminalSubmissions(tracker, data) {
     const pasteStart = "\u001b[200~";
     const pasteEnd = "\u001b[201~";
@@ -1408,8 +2579,8 @@ function trackedTerminalSubmissions(tracker, data) {
             if (command.length > 0 &&
                 (command.includes("\u001b") ||
                     !command.startsWith("/") ||
-                    /^\/(?:clear|fork)(?:\s|$)/u.test(command))) {
-                submissions.push(/^\/(?:clear|fork)(?:\s|$)/u.test(command) ? "rotation" : "turn");
+                    /^\/(?:branch|clear|fork)(?:\s|$)/u.test(command))) {
+                submissions.push(/^\/(?:branch|clear|fork)(?:\s|$)/u.test(command) ? "rotation" : "turn");
             }
             continue;
         }
@@ -1503,9 +2674,61 @@ function closeSessionContext(context) {
         }));
     }
 }
+function isDetachedGeneratedImageEvent(event) {
+    if (event.type !== "response.output_item.done" ||
+        event.item.type !== "function_call_output") {
+        return false;
+    }
+    const data = event.item.data;
+    return Boolean(data.__rynxGeneratedImage && data.__rynxGeneratedImage.result === undefined);
+}
+function attachGeneratedImageResult(event, result) {
+    if (!isDetachedGeneratedImageEvent(event))
+        return undefined;
+    const outputEvent = event;
+    const item = outputEvent.item;
+    if (item.type !== "function_call_output")
+        return undefined;
+    const data = item.data;
+    return {
+        ...outputEvent,
+        item: {
+            ...item,
+            data: {
+                ...data,
+                __rynxGeneratedImage: {
+                    ...data.__rynxGeneratedImage,
+                    result,
+                },
+            },
+        },
+    };
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function mirrorNackClassification(error) {
+    if (typeof error === "object" && error !== null &&
+        error.mirrorClassification === "ambiguous")
+        return "ambiguous";
+    const statusCode = error instanceof AgentRuntimeError
+        ? error.statusCode
+        : typeof error === "object" && error !== null &&
+            typeof error.statusCode === "number"
+            ? error.statusCode
+            : undefined;
+    return statusCode !== undefined &&
+        statusCode >= 400 && statusCode < 500 &&
+        ![408, 409, 425, 429].includes(statusCode)
+        ? "permanent"
+        : "transient";
+}
+function mirrorAbandonToken(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const token = error.abandonToken;
+    return typeof token === "string" && token.length > 0 ? token : undefined;
+}
 function defaultRunnerEntry() {
     if (process.env.RYNX_RUNNER_ENTRY?.trim()) {
         return process.env.RYNX_RUNNER_ENTRY.trim();
@@ -1580,6 +2803,18 @@ function logTerminationFailure(handle, error) {
         error: error instanceof Error ? error.message : String(error),
     }));
 }
+function logCompensatingMirrorFailure(handle, sessionId, eventType, error) {
+    console.error(JSON.stringify({
+        level: "error",
+        type: "runner",
+        event: "compensating_mirror_failed",
+        key: handle.key,
+        sessionId,
+        eventType,
+        pid: handle.child.pid,
+        error: errorMessage(error),
+    }));
+}
 function capabilityForkResult(result) {
     return result.ok
         ? { ok: true }