@rynx-ai/runtime 0.1.11-beta.44 → 0.1.11-beta.48

package/dist/claude/native-bridge.js

@@ -11,7 +11,7 @@
  * Dependency-light on purpose (node builtins plus erased protocol types) so the
  * standalone hook entrypoints do not pull the whole runtime into every process.
  */
-import { appendFileSync, closeSync, fsyncSync, mkdirSync, openSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { appendFileSync, closeSync, copyFileSync, fsyncSync, mkdirSync, openSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { adoptLegacyRuntimeDirectory, legacyRuntimeStateRoot, runtimeSessionDigest, runtimeSessionStateDir, } from "../runtime-state-paths.js";
@@ -69,6 +69,21 @@ export function prepareClaudeBridgeDir(sessionId) {
     const dir = claudeBridgeDir(sessionId);
     adoptLegacyRuntimeDirectory(join(legacyRuntimeStateRoot(), "claude-native", runtimeSessionDigest(sessionId)), dir);
     mkdirSync(dir, { recursive: true, mode: 0o700 });
+    // Preserve original bridge logs before the normal runtime refresh clears its
+    // rendezvous. Collection itself never calls this function or changes files.
+    const history = join(dir, "history", randomUUID());
+    for (const file of [HOOKS_FILE, STATE_FILE, DELTAS_FILE, INTERACTIONS_FILE, INTERACTION_ACKS_FILE]) {
+        try {
+            if (!statSync(join(dir, file)).isFile())
+                continue;
+            mkdirSync(history, { recursive: true, mode: 0o700 });
+            copyFileSync(join(dir, file), join(history, file));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                process.stderr.write(`Claude bridge log preservation failed: ${String(error)}\n`);
+        }
+    }
     for (const file of [
         HOOKS_FILE,
         STATE_FILE,

package/dist/claude/native-integration.js

@@ -2407,6 +2407,28 @@ const CLAUDE_PASTE_COMMIT_TIMEOUT_MS = 5_000;
 const CLAUDE_PASTE_SETTLE_MS = 100;
 const CLAUDE_SUBMIT_CONFIRM_TIMEOUT_MS = 10_000;
 const CLAUDE_SUBMIT_RETRY_MS = 1_000;
+const CLAUDE_UNKNOWN_COMMAND_WATCH_MS = 3_000;
+// Watch guessed skills, leaving known native commands on their existing
+// delivery path. This list does not change which commands may run.
+const CLAUDE_NATIVE_BUILTIN_COMMANDS = new Set([
+    "add-dir", "agents", "bug", "config", "cost", "doctor", "exit", "fast",
+    "feedback", "help", "hooks", "ide", "login", "logout", "mcp", "memory",
+    "onboarding", "permissions", "plugin", "quiet", "quit", "release-notes",
+    "resume", "save", "status", "terminal-setup", "upgrade", "verbose",
+    "clear", "compact", "effort", "model", "ultrareview", "branch", "fork",
+]);
+/** Count rejection messages: omit composer/echo rows and ignore
+ * wrapping, including a narrow pane wrapping inside the command name. */
+function unknownCommandRejections(pane, command, glyph) {
+    const collapsed = pane.split(/\r?\n/)
+        .filter((line) => !line.includes(glyph))
+        .join("")
+        .replace(/\s/g, "");
+    // Unlike a bare substring count, keep /foo-bar's rejection from authorizing
+    // a second delivery of /foo. Retain namespaced, path-like and Unicode names.
+    return collapsed.split(`Unknowncommand:/${command}`).slice(1)
+        .filter((suffix) => !/^[\p{L}\p{M}\p{N}_:./-]/u.test(suffix)).length;
+}
 function selectedMenuRow(line, glyph) {
     const index = line.indexOf(glyph);
     if (index < 0)
@@ -2494,6 +2516,27 @@ async function pollUntil(pred, timeoutMs, pollMs, now, sleep, signal) {
  * recorded neither a direct user prompt nor a type-ahead enqueue.
  */
 export async function injectViaTerminal(injector, text, opts = {}) {
+    const command = /^\s*\/(\S+)/u.exec(text)?.[1];
+    if (!command || CLAUDE_NATIVE_BUILTIN_COMMANDS.has(command)) {
+        return pasteAndSubmitViaTerminal(injector, text, opts);
+    }
+    const glyph = opts.promptGlyph ?? CLAUDE_PROMPT_GLYPH;
+    const baseline = unknownCommandRejections(injector.capturePane(), command, glyph);
+    if (!await pasteAndSubmitViaTerminal(injector, text, opts))
+        return false;
+    // A fresh, explicit rejection proves Claude dropped this guessed skill.
+    // Stale scrollback and an unacknowledged/slow submission never justify a
+    // second paste. Keep the watch and recovery within the Host's injectLock.
+    const rejected = await pollUntil(() => unknownCommandRejections(injector.capturePane(), command, glyph) > baseline, CLAUDE_UNKNOWN_COMMAND_WATCH_MS, opts.pollMs ?? 150, opts.now ?? (() => Date.now()), opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))), opts.signal);
+    if (opts.signal?.aborted)
+        return false;
+    if (!rejected)
+        return true;
+    // Exactly one recovery, using a zero-width prefix. Reuse the
+    // existing paste/submit recipe without changing newlines or attachments.
+    return pasteAndSubmitViaTerminal(injector, text.replace(/^(\s*)\//u, "$1\ufeff/"), opts);
+}
+async function pasteAndSubmitViaTerminal(injector, text, opts) {
     const glyph = opts.promptGlyph ?? CLAUDE_PROMPT_GLYPH;
     const pollMs = opts.pollMs ?? 150;
     const now = opts.now ?? (() => Date.now());

package/dist/codex-app-server/forwarder.d.ts

@@ -49,6 +49,8 @@ export interface CodexForwarderSink {
     onRecoveredTurnStatus?(status: "idle" | "failed", turnId: string | undefined, error?: Error): void;
     /** A turn failed on the runtime. */
     onTurnError(error: Error): void;
+    /** A steer rejection proves a recorded turn is inactive, without its outcome. */
+    onTurnInactive?(turnId: string): void;
     /** The user's turn text (sourced from codex's `userMessage` item), so a
      *  co-driving TUI's prompt is recorded even though this process never injected it. */
     onUserMessage?(content: string | UserContentPart[]): void;
@@ -136,6 +138,8 @@ export declare class CodexSessionForwarder {
     isTurnOpen(): boolean;
     /** The current turn's codex id (only meaningful while {@link isTurnOpen}). */
     currentTurnId(): string | null;
+    /** Reconcile a proven stale steer without clearing a newer observed turn. */
+    clearActiveTurnIfMatches(turnId: string): void;
     /**
      * Record a turn accepted by the injection connection before the independent
      * observer receives `turn/started`. This closes the read-decide-RPC-write race:

package/dist/codex-app-server/forwarder.js

@@ -162,6 +162,16 @@ export class CodexSessionForwarder {
     currentTurnId() {
         return this.currentTurnIdValue;
     }
+    /** Reconcile a proven stale steer without clearing a newer observed turn. */
+    clearActiveTurnIfMatches(turnId) {
+        if (this.currentTurnIdValue !== turnId)
+            return;
+        this.flushPendingCompletion();
+        this.flushDeferredAssistantMessage();
+        this.currentTurnIdValue = null;
+        this.turnOpen = false;
+        this.sink.onTurnInactive?.(turnId);
+    }
     /**
      * Record a turn accepted by the injection connection before the independent
      * observer receives `turn/started`. This closes the read-decide-RPC-write race:

package/dist/codex-app-server/transport.js

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
+import { join } from "node:path";
+import { teeDiagnosticStream } from "@rynx-ai/core";
 import { createCodexChildEnv } from "../codex-child-env.js";
 const DEFAULT_SPAWN_ARGS = ["app-server", "--listen", "stdio://"];
 /**
@@ -51,6 +53,8 @@ export class DefaultCodexAppServerProcessSpawner {
             stdio: ["pipe", "pipe", "pipe"],
             env: { ...createCodexChildEnv(process.env), ...this.extraEnv },
         });
+        if (process.env.RYNX_RUNTIME_LOG_DIR)
+            teeDiagnosticStream(child.stderr, join(process.env.RYNX_RUNTIME_LOG_DIR, "app-server.stderr.log"));
         if (!child.stdin || !child.stdout) {
             throw new Error("Codex app-server child process is missing stdio handles");
         }

package/dist/codex-app-server/ws-channel.js

@@ -14,6 +14,8 @@
  */
 import { spawn } from "node:child_process";
 import { createServer } from "node:net";
+import { join } from "node:path";
+import { diagnosticEvents, teeDiagnosticStream } from "@rynx-ai/core";
 import { WebSocket } from "ws";
 import { createCodexChildEnv } from "../codex-child-env.js";
 import { newRuntimeProcessTag, reconcileRuntimeProcesses, registerRuntimeProcess, runtimeProcessArgv0, runtimeProcessOwnerIdentity, unregisterRuntimeProcess, withRuntimeProcessStateArg, } from "./process-registry.js";
@@ -76,6 +78,13 @@ export class WsRpcChannel {
             ...(processTag ? { argv0: runtimeProcessArgv0(this.opts.cliPath, processTag) } : {}),
         });
         const childPid = this.child.pid;
+        if (process.env.RYNX_RUNTIME_LOG_DIR) {
+            const logDir = process.env.RYNX_RUNTIME_LOG_DIR;
+            teeDiagnosticStream(this.child.stderr, join(logDir, "app-server.stderr.log"));
+            const event = diagnosticEvents(join(logDir, "process-events.jsonl"));
+            event("app-server.spawn", { pid: childPid });
+            this.child.on("exit", (code, signal) => event("app-server.exit", { code, signal }));
+        }
         if (processTag && this.opts.stateDir && childPid) {
             registerRuntimeProcess({
                 pid: childPid,

package/dist/host.js

@@ -1299,6 +1299,16 @@ export class LocalAgentHost {
             // transition.
             onTurnEnd: completeCurrentTurn,
             onTurnInterrupted: interruptCurrentTurn,
+            onTurnInactive: (turnId) => {
+                const responseId = `resp_codex_${turnId}`;
+                if (currentResponseId === responseId) {
+                    closeCanonicalInteractions();
+                    normalizer = null;
+                    currentResponseId = null;
+                }
+                clearPendingInputsForResponse(responseId);
+                emitCurrent({ type: "session.status", sessionId: currentSessionId, responseId, status: "idle" });
+            },
             onRecoveredTurnStatus: (status, turnId, error) => {
                 const responseId = turnId ? `resp_codex_${turnId}` : undefined;
                 if (normalizer && (!responseId || currentResponseId === responseId)) {
@@ -1901,20 +1911,35 @@ export class LocalAgentHost {
                     const turnId = live.forwarder.currentTurnId();
                     if (turnId) {
                         injectionMethod = "turn/steer";
-                        const steered = await injectionClient.turnSteer({
-                            threadId,
-                            expectedTurnId: turnId,
-                            input: nativeInput,
-                        });
-                        pendingInput.responseId = `resp_codex_${steered.turnId}`;
-                        if (pendingInput.observed)
-                            forgetPendingInput();
-                        else
-                            pendingInput.state = "accepted";
-                        live.forwarder.noteTurnAccepted(steered.turnId);
-                        return { outcome: "steered", responseId: `resp_codex_${steered.turnId}` };
+                        const steer = async (expectedTurnId) => {
+                            const steered = await injectionClient.turnSteer({ threadId, expectedTurnId, input: nativeInput });
+                            pendingInput.responseId = `resp_codex_${steered.turnId}`;
+                            if (pendingInput.observed)
+                                forgetPendingInput();
+                            else
+                                pendingInput.state = "accepted";
+                            live.forwarder.noteTurnAccepted(steered.turnId);
+                            return { outcome: "steered", responseId: pendingInput.responseId };
+                        };
+                        try {
+                            return await steer(turnId);
+                        }
+                        catch (error) {
+                            if (!(error instanceof CodexTransportError) || error.code !== -32600 ||
+                                error.message.trim().toLowerCase() !== "no active turn to steer")
+                                throw error;
+                            // Only this explicit rejection proves that resubmitting cannot
+                            // duplicate the input. A timeout or unrelated error never retries.
+                            if (live.rotationPending || live.stopped || live.threadId !== threadId)
+                                throw error;
+                            live.forwarder.clearActiveTurnIfMatches(turnId);
+                        }
+                        const currentTurnId = live.forwarder.currentTurnId();
+                        if (currentTurnId)
+                            return await steer(currentTurnId);
                     }
                 }
+                injectionMethod = "turn/start";
                 // Match reference implementation's turn boundary: change the native thread settings
                 // under the same lock immediately before starting the next Turn. Never
                 // put settings on turn/start or mutate a Turn that is already open.
@@ -3187,7 +3212,7 @@ export class LocalAgentHost {
             }
             catch (error) {
                 live.error = error instanceof Error ? error.message : String(error);
-                return { outcome: "failed" };
+                throw new CodexRuntimeError(`Claude message injection via terminal failed: ${live.error}`, 503, "native_message_injection_failed");
             }
             finally {
                 if (live.injectAbort === abort)

package/dist/runner/manager.d.ts

@@ -64,9 +64,6 @@ export interface RunnerManagerOptions {
     /** Max wait for a native interrupt acknowledgement before reporting it
      * unproven. Callers may then use the explicit force-stop path. */
     liveInterruptTimeoutMs?: number;
-    /** Max wait for an accepted owner TUI submission to become observable as a
-     * mirrored response or a published native rotation. */
-    terminalInputHandoffTimeoutMs?: number;
     /** Injected for tests. */
     spawn?: typeof nodeSpawn;
     /** Injected for tests. Defaults to signaling the whole POSIX process group
@@ -188,7 +185,6 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly liveReadyTimeoutMs;
     private readonly nativeLiveStartTimeoutMs;
     private readonly liveInterruptTimeoutMs;
-    private readonly terminalInputHandoffTimeoutMs;
     private reapPromise;
     private stopping;
     private stopPromise;
@@ -224,9 +220,6 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly forkOperations;
     private readonly forkBufferedMessages;
     private readonly forkBufferedTerminalInputs;
-    /** Owner TUI submissions accepted by the parent but not yet represented by a
-     * mirrored response or a durably published native rotation. */
-    private readonly terminalInputHandoffs;
     constructor(opts: RunnerManagerOptions);
     /**
      * Open a live terminal on the session's runner child (spawning it if needed).
@@ -256,17 +249,11 @@ export declare class RunnerManager implements AgentCapabilities {
     /** Register the sink for session rotations (claude `/clear`·`/fork`): the server
      *  records the new session's meta (carry-over agent/model/title). */
     onRotate(listener: (rotation: RotateInfo) => void | Promise<void>): void;
-    /** Accepted TUI submissions that have not crossed into an observable runtime
-     * state. The daemon folds this into runningTurns after closing admission. */
-    pendingTerminalInputCount(): number;
-    private beginTerminalInputHandoffs;
-    private settleTerminalInputHandoff;
-    private settleTerminalRotationHandoff;
+    /** Actual transport writes and ownership transfers, independent of turn lifecycle. */
+    pendingNativeOperationCount(): number;
+    private finishTerminalWrite;
+    private finishTerminalWrites;
     private currentTerminalSessionId;
-    private finishTerminalInputHandoff;
-    private finishAllTerminalInputHandoffs;
-    private preserveTerminalInputHandoffsAsActivity;
-    private expireTerminalInputHandoffs;
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if

package/dist/runner/manager.js

@@ -18,6 +18,8 @@
 import { spawn as nodeSpawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import readline from "node:readline";
+import { join } from "node:path";
+import { diagnosticEvents, sessionDiagnosticDir, teeDiagnosticStream } from "@rynx-ai/core";
 import { fileURLToPath } from "node:url";
 import { AgentRuntimeError, } from "@rynx-ai/core";
 import { listRuntimeModels } from "../models-catalog.js";
@@ -44,10 +46,6 @@ const DEFAULT_LIVE_READY_TIMEOUT_MS = 25_000;
  * 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;
 /** 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. */
@@ -291,7 +289,6 @@ export class RunnerManager {
     liveReadyTimeoutMs;
     nativeLiveStartTimeoutMs;
     liveInterruptTimeoutMs;
-    terminalInputHandoffTimeoutMs;
     reapPromise = null;
     stopping = false;
     stopPromise;
@@ -327,9 +324,6 @@ 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;
@@ -358,7 +352,6 @@ export class RunnerManager {
         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);
         const reapIntervalMs = opts.reapIntervalMs ?? 60_000;
         if (reapIntervalMs > 0) {
             this.reapTimer = setInterval(() => void this.reapIdle(), reapIntervalMs);
@@ -398,26 +391,22 @@ 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")))
-                : [];
+            if (msg.t === "term.input" && opts.role === "owner") {
+                handle.terminalWrites.set(msg.reqId, {
+                    attachId,
+                    reservation: this.reserveAdmission(),
+                });
+            }
             const send = () => {
                 try {
                     handle.transport.send(msg);
                 }
                 catch (error) {
-                    for (const handoff of handoffs) {
-                        this.finishTerminalInputHandoff(handle, handoff);
-                    }
+                    if (msg.t === "term.input")
+                        this.finishTerminalWrite(handle, msg.reqId);
                     throw error;
                 }
             };
@@ -489,78 +478,29 @@ 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() {
+    /** Actual transport writes and ownership transfers, independent of turn lifecycle. */
+    pendingNativeOperationCount() {
         let count = 0;
-        for (const handoffs of this.terminalInputHandoffs.values()) {
-            count += handoffs.length;
+        for (const handle of this.childHandles) {
+            count += handle.terminalWrites.size;
+            if (handle.pendingRotation)
+                count += 1;
+            if (handle.dead)
+                count += 1;
         }
         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;
-        }
+    finishTerminalWrite(handle, reqId) {
+        const write = handle.terminalWrites.get(reqId);
+        handle.terminalWrites.delete(reqId);
+        write?.reservation.release();
     }
-    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);
+    finishTerminalWrites(handle, attachId) {
+        for (const [reqId, write] of handle.terminalWrites) {
+            if (attachId === undefined || write.attachId === attachId) {
+                this.finishTerminalWrite(handle, reqId);
             }
         }
-        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) {
@@ -569,51 +509,6 @@ export class RunnerManager {
         }
         return handle.activeSessionId || 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) {
-        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;
-        }
-    }
-    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
@@ -1021,10 +916,7 @@ export class RunnerManager {
         if (this.reapTimer) {
             clearInterval(this.reapTimer);
         }
-        const children = new Set([
-            ...this.childHandles,
-            ...this.terminalInputHandoffs.keys(),
-        ]);
+        const children = new Set(this.childHandles);
         const attempt = (async () => {
             const results = await Promise.allSettled([...children].map((handle) => this.terminateHandle(handle, "runner manager stopped")));
             this.handles.clear();
@@ -1052,8 +944,7 @@ export class RunnerManager {
     // ── internals ──────────────────────────────────────────────────────────────
     handleForCleanup(localThreadId) {
         return this.handles.get(localThreadId) ??
-            [...this.terminalInputHandoffs].find(([handle, handoffs]) => handle.key === localThreadId ||
-                handoffs.some((handoff) => handoff.sessionId === localThreadId))?.[0];
+            [...this.childHandles].find((handle) => handle.key === localThreadId || handle.activeSessionId === localThreadId);
     }
     /** 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
@@ -1306,9 +1197,6 @@ export class RunnerManager {
                 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();
@@ -1525,6 +1413,7 @@ export class RunnerManager {
                 inFlight: false,
                 logicalTargetPublished: false,
                 publicationComplete: false,
+                admission: this.admissionReserve?.(),
             };
             handle.pendingRotation = pending;
             this.forkReservations.set(pending.to, targetReservation);
@@ -1657,7 +1546,6 @@ export class RunnerManager {
             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)
@@ -1736,6 +1624,7 @@ export class RunnerManager {
         this.forkBufferedTerminalInputs.delete(pending.to);
         pending.releaseTarget();
         pending.releaseSource();
+        pending.admission?.release();
     }
     async publishNativeRotationNotice(pending) {
         // Only /clear supersedes the old Session. A /fork keeps
@@ -1800,6 +1689,9 @@ export class RunnerManager {
         await Promise.all(publications);
     }
     spawnHandle(key) {
+        const logDir = join(sessionDiagnosticDir("runtime", key), "instances", randomUUID());
+        const event = diagnosticEvents(join(logDir, "process-events.jsonl"), { sessionId: key });
+        event("runner.spawn");
         const args = this.runnerEntry.endsWith(".ts")
             ? ["--import", "tsx", this.runnerEntry]
             : [this.runnerEntry];
@@ -1820,6 +1712,7 @@ export class RunnerManager {
                     ...this.childEnv,
                     ...(sessionContext?.childEnv ?? {}),
                     RYNX_RUNNER_SESSION: key,
+                    RYNX_RUNTIME_LOG_DIR: logDir,
                 },
             });
         }
@@ -1828,6 +1721,10 @@ export class RunnerManager {
             throw error;
         }
         const completion = observeChildCompletion(child);
+        teeDiagnosticStream(child.stderr, join(logDir, "runner.stderr.log"));
+        child.on("spawn", () => event("runner.started", { pid: child.pid }));
+        child.on("error", (error) => event("runner.error", { message: error.message }));
+        child.on("exit", (code, signal) => event("runner.exit", { code, signal }));
         const transport = new StdioRunnerTransport(child.stdout, child.stdin);
         const handle = {
             key,
@@ -1838,6 +1735,7 @@ export class RunnerManager {
             lastUsedAt: this.now(),
             activeResponseIds: new Set(),
             terminalResponseIds: new Set(),
+            terminalWrites: new Map(),
             dead: false,
             completion,
             processGroup,
@@ -1849,7 +1747,10 @@ export class RunnerManager {
             mirrorDeliveries: new Map(),
         };
         this.childHandles.add(handle);
-        void completion.then(() => this.childHandles.delete(handle));
+        void completion.then(() => {
+            this.finishTerminalWrites(handle);
+            this.childHandles.delete(handle);
+        });
         transport.onMessage((msg) => this.onChildMessage(handle, msg));
         if (child.stderr) {
             const rl = readline.createInterface({ input: child.stderr, crlfDelay: Infinity });
@@ -1911,9 +1812,15 @@ export class RunnerManager {
                 });
                 return;
             case "term.ack":
+                if (msg.operation === "input")
+                    this.finishTerminalWrite(handle, msg.reqId);
                 handle.terminals.get(msg.attachId)?._ack(msg.reqId, msg.operation);
                 return;
             case "term.error": {
+                if (msg.reqId)
+                    this.finishTerminalWrite(handle, msg.reqId);
+                else
+                    this.finishTerminalWrites(handle, msg.attachId);
                 const terminal = handle.terminals.get(msg.attachId);
                 if (!msg.reqId)
                     handle.terminals.delete(msg.attachId);
@@ -2264,13 +2171,12 @@ export class RunnerManager {
         })();
         handle.termination = attempt;
         void attempt.then(() => {
-            this.finishAllTerminalInputHandoffs(handle);
+            this.finishTerminalWrites(handle);
         }, () => {
             if (handle.termination === attempt)
                 delete handle.termination;
-            // 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);
+            // An unexited dead handle remains visible in pendingNativeOperationCount.
+            this.finishTerminalWrites(handle);
         });
         return attempt;
     }
@@ -2536,70 +2442,6 @@ function rememberTerminalResponse(handle, responseId) {
         handle.terminalResponseIds.delete(oldest);
     }
 }
-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("/") ||
-                    /^\/(?:branch|clear|fork)(?:\s|$)/u.test(command))) {
-                submissions.push(/^\/(?:branch|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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.44",
+  "version": "0.1.11-beta.48",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -26,7 +26,7 @@
   "dependencies": {
     "smol-toml": "1.7.1",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.44"
+    "@rynx-ai/core": "0.1.11-beta.48"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"