@rynx-ai/runtime 0.1.11-beta.3 → 0.1.11-beta.30

package/dist/runner/manager.js

@@ -22,8 +22,9 @@ 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";
 /** Routing key for the shared capability runner (slash-command RPCs). */
 const CAP_KEY = "__cap__";
@@ -33,17 +34,23 @@ 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;
@@ -144,6 +151,8 @@ export class RunnerManager {
     sessionStore;
     runnerEntry;
     idleTtlMs;
+    nativePaneIdleTtlMs;
+    nativePaneOutputBusyWindowMs;
     spawn;
     childEnv;
     sessionContextProvider;
@@ -160,15 +169,22 @@ 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;
+    /** 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 +214,30 @@ 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.terminalWindowActivityAt = opts.terminalWindowActivityAt ?? tmuxWindowActivityAt;
+        this.terminalHasAttachedClient = opts.terminalHasAttachedClient ?? tmuxHasAttachedClient;
         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 {
@@ -261,6 +282,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 +352,9 @@ export class RunnerManager {
     onMirror(listener) {
         this.mirrorListener = 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) {
@@ -431,11 +457,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 +471,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 +488,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 +530,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 +617,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 +629,55 @@ 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 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 +717,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 +729,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);
@@ -869,7 +940,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();
@@ -1011,14 +1081,56 @@ 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);
     }
+    deliverMirrorMessage(handle, message) {
+        if (handle.dead)
+            return;
+        if (message.event.type === "session.collaboration_mode") {
+            this.collaborationModeListener?.(message.sessionId, message.event.mode);
+        }
+        this.observeHandleRuntimeEvent(handle, message.event);
+        let delivered;
+        try {
+            delivered = Promise.resolve(this.mirrorListener?.(message.sessionId, message.event));
+        }
+        catch (error) {
+            delivered = Promise.reject(error);
+        }
+        if (message.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, message.sessionId, "turn");
+        }
+        if (message.transferId && message.seq !== undefined) {
+            void delivered.then(() => {
+                if (!handle.dead) {
+                    handle.transport.send({
+                        t: "mirror.image.ack",
+                        transferId: message.transferId,
+                        seq: message.seq,
+                    });
+                }
+            }, (error) => {
+                this.failMirrorImageTransfer(handle, `generated image publication failed: ${errorMessage(error)}`);
+            });
+        }
+        else {
+            void delivered.catch((error) => {
+                console.error(`Session mirror publication failed: ${errorMessage(error)}`);
+            });
+        }
+    }
+    failMirrorImageTransfer(handle, reason) {
+        handle.imageTransfers.clear();
+        void this.terminateHandle(handle, reason).catch((error) => {
+            logTerminationFailure(handle, error);
+        });
+    }
     deliverRotateMessage(handle, message) {
         if (this.forkReservations.has(message.to) ||
             this.sourceForkReservations.has(message.from)) {
@@ -1078,6 +1190,7 @@ export class RunnerManager {
             this.settleTerminalRotationHandoff(handle, message.from, message.to);
             if (handle.dead)
                 return;
+            handle.activeResponseIds.clear();
             this.handles.set(message.to, handle);
             this.liveSessionKeys.add(message.to);
             this.liveOptions.set(message.to, {
@@ -1144,14 +1257,15 @@ export class RunnerManager {
             transport,
             stderr: [],
             lastUsedAt: this.now(),
+            activeResponseIds: new Set(),
             dead: false,
             completion,
-            terminalCleanupRetryFailures: 0,
             processGroup,
             ...(sessionContext ? { sessionContext } : {}),
             caps: new Map(),
             terminals: new Map(),
             live: new Map(),
+            imageTransfers: new Map(),
         };
         this.childHandles.add(handle);
         void completion.then(() => this.childHandles.delete(handle));
@@ -1210,14 +1324,83 @@ export class RunnerManager {
                     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.image.begin": {
+                if (handle.dead ||
+                    handle.imageTransfers.has(msg.transferId) ||
+                    !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,
+                    event: msg.event,
+                    totalChars: msg.totalChars,
+                    receivedChars: 0,
+                    nextSeq: 1,
+                    chunks: [],
+                });
+                handle.transport.send({ t: "mirror.image.ack", transferId: msg.transferId, seq: 0 });
+                return;
+            }
+            case "mirror.image.chunk": {
+                const transfer = handle.imageTransfers.get(msg.transferId);
+                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,
+                });
+                return;
+            }
+            case "mirror.image.commit": {
+                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;
                 }
+                handle.imageTransfers.delete(msg.transferId);
+                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,
+                };
+                if (this.bufferForkTargetMessage(handle, mirrored)) {
+                    handle.transport.send({
+                        t: "mirror.image.hold",
+                        transferId: msg.transferId,
+                        seq: msg.seq,
+                    });
+                    return;
+                }
+                this.deliverMirrorMessage(handle, mirrored);
                 return;
+            }
             case "rotate": {
                 if (handle.dead)
                     return;
@@ -1232,10 +1415,19 @@ export class RunnerManager {
                 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,7 +1437,7 @@ export class RunnerManager {
         }
     }
     /** Mark a handle dead and reject every pending run/cap with the exit reason. */
-    failHandle(handle, reason) {
+    failHandle(handle, reason, opts = {}) {
         if (handle.dead) {
             return;
         }
@@ -1264,6 +1456,9 @@ export class RunnerManager {
         }
         const tail = handle.stderr.join("\n");
         const message = tail ? `${reason}\n--- runner log tail ---\n${tail}` : reason;
+        if (opts.failActiveResponses !== false) {
+            this.failActiveResponses(handle, "runner_crashed", message);
+        }
         const error = new AgentRuntimeError(message, 500, "runner_crashed");
         for (const pending of handle.caps.values()) {
             pending.reject(error);
@@ -1272,20 +1467,20 @@ 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();
         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 +1489,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 +1498,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`)).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 +1514,174 @@ 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.terminateHandle(handle, "idle native pane reaped").catch((error) => logTerminationFailure(handle, error));
+    }
+    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))
+                return true;
+        }
+        catch {
+            // A failed probe contributes no busy evidence; check activity next.
+        }
+        let activityAt = null;
+        try {
+            activityAt = await this.terminalWindowActivityAt(terminalName);
+        }
+        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) {
+            this.mirrorListener?.(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.mirrorListener?.(sessionId, {
+                type: "session.interrupted",
+                sessionId,
+                responseId,
+            });
+        }
+    }
+    /** 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":
+                handle.activeResponseIds.add(event.responseId);
+                return;
+            case "session.interaction.requested":
+                handle.activeResponseIds.add(event.responseId);
+                return;
+            case "response.completed":
+            case "response.failed":
+            case "session.interrupted":
+                handle.activeResponseIds.delete(event.responseId);
+                return;
+            case "session.status":
+                if (event.status === "running" && event.responseId) {
+                    handle.activeResponseIds.add(event.responseId);
+                }
+                else if (event.status !== "running") {
+                    if (event.responseId)
+                        handle.activeResponseIds.delete(event.responseId);
+                    else
+                        handle.activeResponseIds.clear();
+                }
+                return;
+            case "session.rotated":
+                handle.activeResponseIds.clear();
+                return;
+            default:
+                return;
+        }
+    }
     openSessionContext(sessionId) {
         if (!this.sessionContextProvider)
             return undefined;
@@ -1503,6 +1838,36 @@ 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);
 }