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

package/dist/runner/manager.js

@@ -22,7 +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 { isManagedNativeProvider } from "./startup-policy.js";
 import { StdioRunnerTransport } from "./transport.js";
 /** Routing key for the shared capability runner (slash-command RPCs). */
 const CAP_KEY = "__cap__";
@@ -32,10 +34,29 @@ 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. */
+/** Setup-pane launch includes the app-server readiness phase but does not wait
+ * for native thread discovery. Keep enough headroom around the app-server's
+ * own 10s gate so scheduling/IPC overhead cannot win the same deadline. */
+const DEFAULT_LIVE_START_TIMEOUT_MS = 30_000;
+/** Legacy fallback for a provider without a native startup policy. */
 const DEFAULT_LIVE_READY_TIMEOUT_MS = 25_000;
+/** 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;
+/** A Provider that never closes its active response must not keep a detached
+ * runner + tmux server alive forever. This is intentionally much longer than
+ * the normal idle TTL so legitimate long-running turns are not treated as
+ * stale. User input/control activity refreshes the deadline; Provider output
+ * does not, because a runaway redraw loop is the failure mode this bounds. */
+const DEFAULT_STALE_ACTIVE_TTL_MS = 60 * 60_000;
 /** Keep per-Session spawn context small enough to remain an environment handoff,
  * not an unbounded transport. */
 const MAX_SESSION_CONTEXT_ENV_ENTRIES = 32;
@@ -136,9 +157,12 @@ export class RunnerManager {
     sessionStore;
     runnerEntry;
     idleTtlMs;
+    staleActiveTtlMs;
     spawn;
     childEnv;
     sessionContextProvider;
+    admissionOpen;
+    admissionReserve;
     now;
     defaultRuntime;
     handles = new Map();
@@ -148,8 +172,14 @@ export class RunnerManager {
     reapTimer;
     shutdownGraceMs;
     shutdownKillGraceMs;
+    signalChild;
+    terminateTerminalServer;
     liveStartTimeoutMs;
     liveReadyTimeoutMs;
+    nativeLiveStartTimeoutMs;
+    liveInterruptTimeoutMs;
+    terminalInputHandoffTimeoutMs;
+    terminalInputCleanupRetryMs;
     stopping = false;
     stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
@@ -175,20 +205,32 @@ export class RunnerManager {
     forkOperations = new Map();
     forkBufferedMessages = new Map();
     forkBufferedTerminalInputs = new Map();
+    /** Owner TUI submissions accepted by the parent but not yet represented by a
+     * mirrored response or a durably published native rotation. */
+    terminalInputHandoffs = new Map();
     constructor(opts) {
         this.config = opts.config;
         this.sessionStore = opts.sessionStore;
         this.runnerEntry = opts.runnerEntry ?? defaultRunnerEntry();
         this.idleTtlMs = opts.idleTtlMs ?? 300_000;
+        this.staleActiveTtlMs = Math.max(this.idleTtlMs, opts.staleActiveTtlMs ?? DEFAULT_STALE_ACTIVE_TTL_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.defaultRuntime = opts.config.AGENT_RUNTIME ?? "codex";
+        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.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);
@@ -216,6 +258,7 @@ export class RunnerManager {
      * and attach.
      */
     openLiveTerminal(localThreadId, opts) {
+        this.assertAdmissionOpen();
         if (this.forkReservations.has(localThreadId)) {
             throw new TerminalOpenError("Session fork is still being committed", "terminal_not_live");
         }
@@ -228,12 +271,38 @@ export class RunnerManager {
     openTerminalOnHandle(handle, localThreadId, opts) {
         handle.lastUsedAt = this.now();
         const attachId = randomUUID();
+        const inputTracker = {
+            buffer: "",
+            previousWasCarriageReturn: false,
+            bracketedPaste: false,
+            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")))
+                : [];
+            const send = () => {
+                try {
+                    handle.transport.send(msg);
+                }
+                catch (error) {
+                    for (const handoff of handoffs) {
+                        this.finishTerminalInputHandoff(handle, handoff);
+                    }
+                    throw error;
+                }
+            };
             const sourceReservation = this.sourceForkReservations.get(localThreadId);
             if (msg.t === "term.input" && sourceReservation) {
                 void sourceReservation.then(() => {
                     if (!handle.dead)
-                        handle.transport.send(msg);
+                        send();
+                }).catch((error) => {
+                    void this.terminateHandle(handle, `terminal input delivery failed: ${errorMessage(error)}`).catch((terminationError) => {
+                        logTerminationFailure(handle, terminationError);
+                    });
                 });
                 return;
             }
@@ -246,7 +315,7 @@ export class RunnerManager {
                     return;
                 }
             }
-            handle.transport.send(msg);
+            send();
         }, () => handle.terminals.delete(attachId));
         handle.terminals.set(attachId, terminal);
         handle.transport.send({
@@ -284,20 +353,171 @@ export class RunnerManager {
     onRotate(listener) {
         this.rotateListener = listener;
     }
+    /** Accepted TUI submissions that have not crossed into an observable runtime
+     * state. The daemon folds this into runningTurns after closing admission. */
+    pendingTerminalInputCount() {
+        let count = 0;
+        for (const handoffs of this.terminalInputHandoffs.values()) {
+            count += handoffs.length;
+        }
+        return count;
+    }
+    beginTerminalInputHandoffs(handle, sessionId, kinds) {
+        if (kinds.length === 0)
+            return [];
+        const created = [];
+        try {
+            for (const kind of kinds) {
+                const handoff = {
+                    sessionId,
+                    kind,
+                    reservation: this.reserveAdmission(),
+                    timer: undefined,
+                };
+                handoff.timer = setTimeout(() => {
+                    this.expireTerminalInputHandoffs(handle);
+                }, this.terminalInputHandoffTimeoutMs);
+                handoff.timer.unref?.();
+                const handoffs = this.terminalInputHandoffs.get(handle);
+                if (handoffs)
+                    handoffs.push(handoff);
+                else
+                    this.terminalInputHandoffs.set(handle, [handoff]);
+                created.push(handoff);
+            }
+            return created;
+        }
+        catch (error) {
+            for (const handoff of created) {
+                this.finishTerminalInputHandoff(handle, handoff);
+            }
+            throw error;
+        }
+    }
+    settleTerminalInputHandoff(handle, sessionId, kind) {
+        const handoff = this.terminalInputHandoffs
+            .get(handle)
+            ?.find((candidate) => candidate.sessionId === sessionId);
+        // Runtime observations settle accepted input in submission order. In
+        // particular, a response from the source Session while /clear or /fork is
+        // still publishing must not skip that rotation and release a later turn
+        // which has not yet been rebound or delivered.
+        if (handoff?.kind === kind)
+            this.finishTerminalInputHandoff(handle, handoff);
+    }
+    settleTerminalRotationHandoff(handle, sourceSessionId, targetSessionId) {
+        const handoffs = this.terminalInputHandoffs.get(handle);
+        const rotationIndex = handoffs?.findIndex((handoff) => handoff.sessionId === sourceSessionId && handoff.kind === "rotation") ?? -1;
+        if (!handoffs || rotationIndex < 0)
+            return;
+        // Turns submitted before /clear or /fork are superseded once the rotation
+        // is published. Inputs accepted afterwards belong to the transferred pane
+        // and must follow it to the target Session.
+        const rotation = handoffs[rotationIndex];
+        for (const handoff of [...handoffs.slice(0, rotationIndex)]) {
+            if (handoff.sessionId === sourceSessionId && handoff.kind === "turn") {
+                this.finishTerminalInputHandoff(handle, handoff);
+            }
+        }
+        if (rotation)
+            this.finishTerminalInputHandoff(handle, rotation);
+        for (const handoff of this.terminalInputHandoffs.get(handle) ?? []) {
+            if (handoff.sessionId === sourceSessionId)
+                handoff.sessionId = targetSessionId;
+        }
+    }
+    currentTerminalSessionId(handle, fallback) {
+        for (const [sessionId, candidate] of this.handles) {
+            if (candidate === handle && this.liveSessionKeys.has(sessionId))
+                return sessionId;
+        }
+        return fallback;
+    }
+    finishTerminalInputHandoff(handle, handoff) {
+        if (handoff.timer) {
+            clearTimeout(handoff.timer);
+            handoff.timer = undefined;
+        }
+        handoff.reservation?.release();
+        handoff.reservation = undefined;
+        const handoffs = this.terminalInputHandoffs.get(handle);
+        if (!handoffs)
+            return;
+        const index = handoffs.indexOf(handoff);
+        if (index >= 0)
+            handoffs.splice(index, 1);
+        if (handoffs.length === 0)
+            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);
+        }
+    }
+    preserveTerminalInputHandoffsAsActivity(handle) {
+        for (const handoff of this.terminalInputHandoffs.get(handle) ?? []) {
+            if (handoff.timer) {
+                clearTimeout(handoff.timer);
+                handoff.timer = undefined;
+            }
+            handoff.reservation?.release();
+            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)
+            return;
+        for (const handoff of handoffs) {
+            if (handoff.timer) {
+                clearTimeout(handoff.timer);
+                handoff.timer = undefined;
+            }
+        }
+        void this.terminateHandle(handle, "accepted terminal input did not become observable before maintenance timeout").catch((error) => {
+            logTerminationFailure(handle, error);
+        });
+    }
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if
-     * needed. Idempotent. Resolves true once the codex thread is bound; false for a
-     * non-codex / non-live session (the caller then uses the normal run path).
+     * needed. Idempotent. For Codex-lineage fresh sessions, resolves after the
+     * app-server/observer and pane are launched; thread discovery continues in
+     * parallel with injection. Other providers retain their readiness gate.
      */
     ensureLiveSession(localThreadId, opts) {
-        return this.requestLiveSession(localThreadId, opts, true);
+        const admission = this.reserveAdmission();
+        return this.requestLiveSession(localThreadId, opts, true)
+            .finally(() => admission.release());
     }
     /** Start the Provider pane without waiting for login/onboarding to create a
      * native thread. This is the setup-terminal gate; callers may attach as soon
      * as it resolves, while normal message delivery still uses ensureLiveSession. */
     startLiveSession(localThreadId, opts) {
-        return this.requestLiveSession(localThreadId, opts, false);
+        const admission = this.reserveAdmission();
+        return this.requestLiveSession(localThreadId, opts, false)
+            .finally(() => admission.release());
     }
     requestLiveSession(localThreadId, opts, waitForReady, allowReservedForkTarget = false) {
         const sourceReservation = allowReservedForkTarget
@@ -323,12 +543,25 @@ export class RunnerManager {
         this.liveSessionKeys.add(localThreadId);
         const reqId = randomUUID();
         return new Promise((resolve) => {
-            const timeoutMs = waitForReady ? this.liveReadyTimeoutMs : this.liveStartTimeoutMs;
+            const timeoutMs = !waitForReady
+                ? this.liveStartTimeoutMs
+                : opts.execution.provider === "claude"
+                    ? this.nativeLiveStartTimeoutMs
+                    : isManagedNativeProvider(opts.execution.provider)
+                        ? this.liveStartTimeoutMs
+                        : this.liveReadyTimeoutMs;
             const timeout = setTimeout(() => {
                 if (!handle.live.delete(reqId))
                     return;
                 const finishTimeout = () => {
-                    const reason = `runner did not acknowledge ${waitForReady ? "live readiness" : "terminal start"} within ${timeoutMs}ms`;
+                    const provider = opts.execution.provider;
+                    const reason = !waitForReady
+                        ? `runner did not acknowledge terminal start within ${timeoutMs}ms`
+                        : provider === "claude"
+                            ? `Claude SessionStart was not observed within ${Math.round(timeoutMs / 1_000)}s; the runner process was reset before retry`
+                            : provider === "codex" || provider === "traex"
+                                ? `${provider === "traex" ? "Traex" : "Codex"} app-server/observer/Terminal launch was not acknowledged within ${Math.round(timeoutMs / 1_000)}s; the runner process was reset before retry`
+                                : `runner did not acknowledge live readiness within ${timeoutMs}ms`;
                     this.liveErrors.set(localThreadId, reason);
                     this.liveSessionKeys.delete(localThreadId);
                     // A child that cannot answer a bounded control round-trip is unsafe
@@ -395,13 +628,18 @@ export class RunnerManager {
      * the session has no live forwarder (caller falls back to the run path).
      */
     injectMessage(localThreadId, input) {
+        const admission = this.reserveAdmission();
+        return this.injectMessageAdmitted(localThreadId, input)
+            .finally(() => admission.release());
+    }
+    injectMessageAdmitted(localThreadId, input) {
         const sourceReservation = this.sourceForkReservations.get(localThreadId);
         if (sourceReservation) {
-            return sourceReservation.then(() => this.injectMessage(localThreadId, input));
+            return sourceReservation.then(() => this.injectMessageAdmitted(localThreadId, input));
         }
         const reservation = this.forkReservations.get(localThreadId);
         if (reservation) {
-            return reservation.then(() => this.injectMessage(localThreadId, input));
+            return reservation.then(() => this.injectMessageAdmitted(localThreadId, input));
         }
         const handle = this.getOrSpawn(localThreadId);
         handle.lastUsedAt = this.now();
@@ -444,7 +682,16 @@ export class RunnerManager {
         handle.lastUsedAt = this.now();
         const reqId = randomUUID();
         return new Promise((resolve) => {
-            handle.live.set(reqId, (res) => resolve(res.ok ?? false));
+            const timeout = setTimeout(() => {
+                if (!handle.live.delete(reqId))
+                    return;
+                resolve(false);
+            }, this.liveInterruptTimeoutMs);
+            timeout.unref?.();
+            handle.live.set(reqId, (res) => {
+                clearTimeout(timeout);
+                resolve(res.ok ?? false);
+            });
             handle.transport.send({ t: "live.interrupt", reqId, localThreadId });
         });
     }
@@ -488,6 +735,7 @@ export class RunnerManager {
         return this.forwardCap("clearGoal", [localThreadId], localThreadId);
     }
     forkSession(currentLocalThreadId, newLocalThreadId, options) {
+        this.assertAdmissionOpen();
         if (currentLocalThreadId === newLocalThreadId) {
             return Promise.resolve({
                 ok: false,
@@ -573,7 +821,7 @@ export class RunnerManager {
     }
     /** Stop the runner bound to one session (if any), rejecting its in-flight work. */
     stopRunner(localThreadId) {
-        const handle = this.handles.get(localThreadId);
+        const handle = this.handleForCleanup(localThreadId);
         if (!handle) {
             return;
         }
@@ -581,6 +829,15 @@ export class RunnerManager {
             logTerminationFailure(handle, error);
         });
     }
+    /** Force-stop and join the runner bound to one Session. Unlike stopRunner,
+     * completion proves that the child process has exited. */
+    async terminateLiveSession(localThreadId) {
+        const handle = this.handleForCleanup(localThreadId);
+        if (!handle)
+            return false;
+        await this.terminateHandle(handle, "runner force-stopped");
+        return true;
+    }
     /** Stop every runner and join all child exits. Idempotent across concurrent calls. */
     stop() {
         if (this.stopPromise)
@@ -589,9 +846,12 @@ export class RunnerManager {
         if (this.reapTimer) {
             clearInterval(this.reapTimer);
         }
-        const children = [...this.childHandles];
-        this.stopPromise = (async () => {
-            const results = await Promise.allSettled(children.map((handle) => this.terminateHandle(handle, "runner manager stopped")));
+        const children = new Set([
+            ...this.childHandles,
+            ...this.terminalInputHandoffs.keys(),
+        ]);
+        const attempt = (async () => {
+            const results = await Promise.allSettled([...children].map((handle) => this.terminateHandle(handle, "runner manager stopped")));
             this.handles.clear();
             this.liveSessionKeys.clear();
             this.liveErrors.clear();
@@ -606,9 +866,19 @@ export class RunnerManager {
             }
             this.childHandles.clear();
         })();
-        return this.stopPromise;
+        this.stopPromise = attempt;
+        void attempt.catch(() => {
+            if (this.stopPromise === attempt)
+                this.stopPromise = undefined;
+        });
+        return attempt;
     }
     // ── internals ──────────────────────────────────────────────────────────────
+    handleForCleanup(localThreadId) {
+        return this.handles.get(localThreadId) ??
+            [...this.terminalInputHandoffs].find(([handle, handoffs]) => handle.key === localThreadId ||
+                handoffs.some((handoff) => handoff.sessionId === localThreadId))?.[0];
+    }
     /** Forward a capability to a runner child. Session-less caps (listModels/status)
      *  use the shared `CAP_KEY` child; per-thread caps pass the session's key so they
      *  run on that session's child (which owns its private CODEX_HOME). */
@@ -622,23 +892,48 @@ export class RunnerManager {
         });
     }
     getOrSpawn(key, allowReservedForkTarget = false) {
-        if (this.stopping) {
-            throw new AgentRuntimeError("runner manager is stopped", 503, "runner_stopped");
-        }
-        if (key !== CAP_KEY &&
-            this.forkReservations.has(key) &&
-            !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();
-            return existing;
-        }
-        const handle = this.spawnHandle(key);
-        this.handles.set(key, handle);
-        return handle;
+        const admission = this.reserveAdmission();
+        try {
+            if (this.stopping) {
+                throw new AgentRuntimeError("runner manager is stopped", 503, "runner_stopped");
+            }
+            if (key !== CAP_KEY &&
+                this.forkReservations.has(key) &&
+                !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();
+                return existing;
+            }
+            const handle = this.spawnHandle(key);
+            this.handles.set(key, handle);
+            return handle;
+        }
+        finally {
+            admission.release();
+        }
+    }
+    assertAdmissionOpen() {
+        const reservation = this.admissionReserve?.();
+        if (reservation) {
+            reservation.release();
+            return;
+        }
+        if (!this.admissionReserve && this.admissionOpen())
+            return;
+        throw new AgentRuntimeError("daemon maintenance is in progress", 503, "daemon_maintenance");
+    }
+    reserveAdmission() {
+        const reservation = this.admissionReserve?.();
+        if (reservation)
+            return reservation;
+        if (!this.admissionReserve && this.admissionOpen()) {
+            return { release() { } };
+        }
+        throw new AgentRuntimeError("daemon maintenance is in progress", 503, "daemon_maintenance");
     }
     async performManagedFork(currentLocalThreadId, newLocalThreadId, options) {
         const existingTarget = await this.sessionStore.get(newLocalThreadId);
@@ -749,7 +1044,11 @@ export class RunnerManager {
         if (handle.dead)
             return;
         if (message.t === "mirror") {
+            this.observeHandleRuntimeEvent(handle, message.event);
             this.mirrorListener?.(message.sessionId, message.event);
+            if (message.event.type === "response.created") {
+                this.settleTerminalInputHandoff(handle, message.sessionId, "turn");
+            }
             return;
         }
         this.deliverRotateMessage(handle, message);
@@ -806,8 +1105,14 @@ export class RunnerManager {
         };
         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)
                 return;
+            handle.activeResponseIds.clear();
             this.handles.set(message.to, handle);
             this.liveSessionKeys.add(message.to);
             this.liveOptions.set(message.to, {
@@ -845,10 +1150,12 @@ export class RunnerManager {
         const sessionContext = key === CAP_KEY
             ? undefined
             : this.openSessionContext(key);
+        const processGroup = process.platform !== "win32";
         let child;
         try {
             child = this.spawn(process.execPath, args, {
                 stdio: ["pipe", "pipe", "pipe"],
+                detached: processGroup,
                 // `RYNX_RUNNER_SESSION` = the child's session key (localThreadId, or `__cap__`
                 // for the shared capability child) so its LocalAgentHost scopes the private
                 // CODEX_HOME to this session. It is deliberately applied last.
@@ -872,8 +1179,11 @@ 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(),
@@ -936,7 +1246,14 @@ export class RunnerManager {
                     return;
                 if (this.bufferForkTargetMessage(handle, msg))
                     return;
+                this.observeHandleRuntimeEvent(handle, msg.event);
                 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");
+                }
                 return;
             case "rotate": {
                 if (handle.dead)
@@ -965,7 +1282,7 @@ export class RunnerManager {
         }
     }
     /** Mark a handle dead and reject every pending run/cap with the exit reason. */
-    failHandle(handle, reason) {
+    failHandle(handle, reason, opts = {}) {
         if (handle.dead) {
             return;
         }
@@ -984,6 +1301,9 @@ export class RunnerManager {
         }
         const tail = handle.stderr.join("\n");
         const message = tail ? `${reason}\n--- runner log tail ---\n${tail}` : reason;
+        if (opts.failActiveResponses !== false) {
+            this.failActiveResponses(handle, "runner_crashed", message);
+        }
         const error = new AgentRuntimeError(message, 500, "runner_crashed");
         for (const pending of handle.caps.values()) {
             pending.reject(error);
@@ -1002,7 +1322,11 @@ export class RunnerManager {
     terminateHandle(handle, reason) {
         if (handle.termination)
             return handle.termination;
-        handle.termination = (async () => {
+        if (handle.terminalCleanupRetryTimer) {
+            clearTimeout(handle.terminalCleanupRetryTimer);
+            delete handle.terminalCleanupRetryTimer;
+        }
+        const attempt = (async () => {
             if (!handle.dead) {
                 try {
                     handle.transport.send({ t: "shutdown" });
@@ -1010,38 +1334,126 @@ export class RunnerManager {
                 catch {
                     // The process signal below remains the authoritative shutdown path.
                 }
-                this.failHandle(handle, reason);
+                this.failHandle(handle, reason, { failActiveResponses: false });
             }
-            signalChild(handle.child, "SIGTERM");
-            if (!(await waitForChildExit(handle.completion, this.shutdownGraceMs))) {
-                signalChild(handle.child, "SIGKILL");
-                if (!(await waitForChildExit(handle.completion, this.shutdownKillGraceMs))) {
-                    throw new Error(`runner child ${handle.child.pid ?? handle.key} did not exit after SIGKILL`);
-                }
+            this.signalChild(handle.child, "SIGTERM", handle.processGroup);
+            let childExited = await waitForChildExit(handle.completion, this.shutdownGraceMs);
+            if (!childExited) {
+                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 (!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);
         })();
-        return handle.termination;
+        handle.termination = attempt;
+        void attempt.then(() => {
+            this.finishAllTerminalInputHandoffs(handle);
+        }, () => {
+            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.
+            this.preserveTerminalInputHandoffsAsActivity(handle);
+            this.scheduleTerminalInputCleanupRetry(handle);
+        });
+        return attempt;
     }
     reapIdle() {
         const now = this.now();
         for (const [key, handle] of this.handles) {
-            if (handle.caps.size > 0 || handle.terminals.size > 0) {
+            if (handle.caps.size > 0 || handle.terminals.size > 0 || handle.live.size > 0) {
                 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)) {
+            const idleForMs = now - handle.lastUsedAt;
+            if (idleForMs < this.idleTtlMs) {
                 continue;
             }
-            if (now - handle.lastUsedAt < this.idleTtlMs) {
+            const hasActiveResponse = handle.activeResponseIds.size > 0;
+            if (hasActiveResponse && idleForMs < this.staleActiveTtlMs) {
                 continue;
             }
-            void this.terminateHandle(handle, "idle runner reaped").catch((error) => {
+            const reason = hasActiveResponse
+                ? "stale active runner reaped"
+                : this.liveSessionKeys.has(key)
+                    ? "idle live runner reaped"
+                    : "idle runner reaped";
+            if (hasActiveResponse) {
+                this.failStaleActiveResponses(handle, idleForMs);
+            }
+            void this.terminateHandle(handle, reason).catch((error) => {
                 logTerminationFailure(handle, error);
             });
         }
     }
+    /** Close server-side runtime state before fencing a Provider that stayed
+     * active past its hard inactivity deadline. The child transport is closed by
+     * terminateHandle immediately afterwards, so these are the final events for
+     * the abandoned responses. */
+    failStaleActiveResponses(handle, idleForMs) {
+        this.failActiveResponses(handle, "stale_runner_reaped", `Runner was reaped after ${Math.floor(idleForMs / 1000)}s without user activity`);
+    }
+    failActiveResponses(handle, code, message) {
+        const responseIds = [...handle.activeResponseIds];
+        handle.activeResponseIds.clear();
+        const sessionId = this.currentTerminalSessionId(handle, handle.key);
+        for (const responseId of responseIds) {
+            this.mirrorListener?.(sessionId, {
+                type: "response.failed",
+                responseId,
+                error: {
+                    source: "execution",
+                    code,
+                    message,
+                },
+            });
+        }
+    }
+    /** Track only response lifecycle, not output volume. Output deltas from a
+     * runaway TUI/Provider must not refresh the stale-active deadline. */
+    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":
+                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;
@@ -1060,6 +1472,70 @@ export class RunnerManager {
         }
     }
 }
+function trackedTerminalSubmissions(tracker, data) {
+    const pasteStart = "\u001b[200~";
+    const pasteEnd = "\u001b[201~";
+    const input = tracker.pendingEscape + data;
+    tracker.pendingEscape = "";
+    const submissions = [];
+    for (let index = 0; index < input.length; index += 1) {
+        const character = input[index] ?? "";
+        if (character === "\u001b") {
+            const remaining = input.slice(index);
+            if (remaining.startsWith(pasteStart)) {
+                tracker.bracketedPaste = true;
+                tracker.previousWasCarriageReturn = false;
+                index += pasteStart.length - 1;
+                continue;
+            }
+            if (remaining.startsWith(pasteEnd)) {
+                tracker.bracketedPaste = false;
+                tracker.previousWasCarriageReturn = false;
+                index += pasteEnd.length - 1;
+                continue;
+            }
+            if (pasteStart.startsWith(remaining) || pasteEnd.startsWith(remaining)) {
+                tracker.pendingEscape = remaining;
+                break;
+            }
+        }
+        if (tracker.bracketedPaste) {
+            tracker.buffer += character;
+            tracker.previousWasCarriageReturn = false;
+            continue;
+        }
+        if (character === "\n" && tracker.previousWasCarriageReturn) {
+            tracker.previousWasCarriageReturn = false;
+            continue;
+        }
+        tracker.previousWasCarriageReturn = character === "\r";
+        if (character === "\r" || character === "\n") {
+            const command = tracker.buffer.trim();
+            tracker.buffer = "";
+            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");
+            }
+            continue;
+        }
+        if (character === "\b" || character === "\u007f") {
+            tracker.buffer = tracker.buffer.slice(0, -1);
+            continue;
+        }
+        if (character === "\u0015" || character === "\u0003") {
+            tracker.buffer = "";
+            continue;
+        }
+        // Printable text and tabs are enough to distinguish work-producing prompts
+        // from local TUI slash commands. Other control sequences are ignored.
+        if (character === "\u001b" || character === "\t" || character >= " ") {
+            tracker.buffer += character;
+        }
+    }
+    return submissions;
+}
 function validateSessionContext(context) {
     if (!context || typeof context !== "object") {
         throw new Error("Session context environment provider must return an object");
@@ -1164,9 +1640,18 @@ function observeChildCompletion(child) {
         child.once("exit", onExit);
     });
 }
-function signalChild(child, signal) {
+function signalRunnerChild(child, signal, processGroup) {
     if (childHasExited(child))
         return;
+    if (processGroup && child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        catch {
+            // The group may have exited between the completion check and the signal.
+        }
+    }
     try {
         child.kill(signal);
     }