@wjarka/cezarion 0.14.8 → 0.14.9-dev.829

package/dist/core/codex-app-server-runner.js

@@ -1,12 +1,20 @@
+import { randomUUID } from 'node:crypto';
 import { parseEffort } from '../contract/index.js';
 import { isSignalTerminationExit, prependSystemPrompt, trackChildExit } from './agent-runner.js';
 import { AUTO_END_DELAY_MS, DEFAULT_RUN_TIMEOUT_MS, KILL_GRACE_MS, } from './runner-runtime.js';
 import { parseAskRequest } from './ask.js';
 import { readNdjson } from './ndjson.js';
 import { V1TextCoalescer } from './v1-text-coalescer.js';
+import { InputSubmissions } from './input-submissions.js';
 import { codexTurnOutcome } from './codex-turn-outcome.js';
-import { CodexAppServerRpc, codexSpawnError, endCodexAppServer, resolveCodexExecutable, spawnCodexAppServer, waitForCodexAppServerExit, } from './codex-app-server-transport.js';
+import { CodexAppServerRpc, CodexRpcResponseError, codexSpawnError, endCodexAppServer, resolveCodexExecutable, spawnCodexAppServer, waitForCodexAppServerExit, } from './codex-app-server-transport.js';
 import { codexSessionStarted, createCodexUiState, mapCodexNotification, } from './codex-ui-mapper.js';
+// One startup budget, including handshake ACKs and the first main-thread turn.
+// This is not a model-turn or human-question lifetime limit.
+const STARTUP_TIMEOUT_MS = 60_000;
+// After real process exit, allow buffered output to drain before closing pipes
+// a descendant may have inherited. This timer never proves termination.
+const EXIT_DRAIN_MS = 250;
 /**
  * `AgentRunner` over `codex app-server` — the same JSONL transport the VS Code
  * extension and desktop app use (JSON-RPC 2.0, newline-delimited, over
@@ -50,6 +58,12 @@ export const CODEX_SPEC_SUPPORT = {
 export class CodexAppServerRunner {
     backend = 'codex';
     specSupport = CODEX_SPEC_SUPPORT;
+    inputDelivery = {
+        mode: 'steer', consumption: 'observable',
+        // The userMessage item marks the input entering the thread's history (probe 2026-09-24:
+        // 0.8 s and 26.7 s after the steer, both before the tool ended); the next model call reads it.
+        via: 'turn/steer with clientUserMessageId; item/started userMessage clientId once in the thread history',
+    };
     bin;
     timeoutMs;
     lastSession = null;
@@ -82,6 +96,17 @@ class CodexSession {
     threadId;
     activeTurnId;
     agentInputReady = false;
+    /** Accepted agent input not yet seen as a consumed userMessage item (#505). */
+    submissions = new InputSubmissions();
+    inFlightSubmissionId;
+    refusedBeforeStartup = false;
+    humanPromptsPending = 0;
+    refusedForHuman = false;
+    /** Submissions that opened a turn via turn/start rather than steering one. */
+    turnStartSubmissions = new Set();
+    /** Recent main-thread turn outcomes (true = completed without error), for a late turn/start response. */
+    completedTurns = new Map();
+    turnCompletions = 0;
     agentSubmissionPending = false;
     turnBoundaryVersion = 0;
     pendingUserInput;
@@ -97,6 +122,14 @@ class CodexSession {
     });
     tokensUsed = 0;
     ready;
+    startupPhase = 'initialize';
+    openingAcknowledged = false;
+    firstTurnStarted = false;
+    startupComplete = false;
+    startupTimer;
+    stopKillTimer;
+    hardStopStarted = false;
+    failure;
     autoEndTimer;
     eofTermTimer;
     eofKillTimer;
@@ -121,98 +154,130 @@ class CodexSession {
         this.opts = opts;
         try {
             this.child = spawnCodexAppServer(bin, spec.cwd, spec.env);
-            this.rpc = new CodexAppServerRpc(this.child);
+            this.rpc = new CodexAppServerRpc(this.child, (error) => {
+                if (!this.hardStopStarted && !this.hasExited())
+                    this.fail(error);
+            });
         }
         catch (err) {
             throw codexSpawnError(err, bin);
         }
-        this.hasExited = trackChildExit(this.child);
+        const hasExited = trackChildExit(this.child);
+        this.hasExited = hasExited;
+        // Observe termination BEFORE bootstrap. Pending RPCs cannot own the only
+        // path to discovering that their process has already gone (#493).
+        const exited = waitForCodexAppServerExit(this.child);
+        let drainTimer;
         this.child.on('error', (err) => {
-            this.spawnFailed = codexSpawnError(err, bin);
+            if (this.child.pid === undefined) {
+                this.spawnFailed = codexSpawnError(err, bin);
+                this.closeInput(this.spawnFailed.message);
+                this.child.stdout.destroy();
+            }
+            else if (this.stdinOpen) {
+                this.fail(new Error(`codex app-server process error while waiting for ${this.startupPhase}`));
+            }
+        });
+        this.child.once('exit', (code, signal) => {
+            if (this.stdinOpen && !this.startupComplete) {
+                this.failure ??= new Error(`Codex startup exited (${signal ?? code ?? 'unknown'}) while waiting for ${this.startupPhase}`);
+            }
+            // Do not discard final buffered text on a healthy exit. Revoke RPCs
+            // immediately, then bound pipe draining ONLY after physical termination.
+            this.rpc.close('codex app-server exited');
+            drainTimer = setTimeout(() => this.child.stdout.destroy(), EXIT_DRAIN_MS);
+            drainTimer.unref?.();
+            if (this.stopKillTimer)
+                clearTimeout(this.stopKillTimer);
         });
         const stderrChunks = [];
         this.child.stderr.setEncoding('utf8');
         this.child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
-        // Optional wall-clock kill switch (disabled for interactive sessions).
+        // Whole-session timeouts remain optional; startup is always bounded.
         const limitMs = spec.timeoutMs ?? timeoutMs;
-        let killTimer;
         let deadline;
         if (limitMs > 0) {
             deadline = setTimeout(() => {
                 this.timedOut = true;
                 this.interrupt();
-                this.child.stdout.destroy();
-                killTimer = setTimeout(() => {
-                    if (!this.hasExited()) {
-                        this.terminatedByCezar = true;
-                        this.child.kill('SIGKILL');
-                    }
-                }, KILL_GRACE_MS);
-                killTimer.unref?.();
             }, limitMs);
             deadline.unref?.();
         }
-        // Handshake → thread → first turn. Kicked off concurrently with the read
-        // loop below (which resolves the request() promises this awaits).
+        this.startupTimer = setTimeout(() => {
+            this.fail(new Error(`Codex startup timed out after 60s while waiting for ${this.startupPhase}`), 'timed out after 60s');
+        }, STARTUP_TIMEOUT_MS);
+        this.startupTimer.unref?.();
         this.ready = this.bootstrap();
-        this.result = (async () => {
-            let sessionError;
+        const reader = (async () => {
             try {
-                const readLoop = async () => {
-                    for await (const line of readNdjson(this.child.stdout)) {
-                        if (this.timedOut)
-                            break;
-                        let msg;
-                        try {
-                            msg = JSON.parse(line);
-                        }
-                        catch {
-                            continue; // not JSON-RPC — skip
-                        }
-                        // A sub-agent child thread's turn lifecycle must reach neither channel (#600):
-                        // v1 would emit a bogus `turn-end`, and the v2 mapper — which carries no thread
-                        // identity — would record the child turn as the parent's, clearing its turn-scoped
-                        // plan/reasoning state and resetting the current turn id. Child ITEM events still
-                        // flow, so nested sub-agent activity keeps rendering.
-                        if (this.isForeignTurnLifecycle(msg))
-                            continue;
-                        this.emitUi((state) => mapCodexNotification(msg, state));
-                        this.dispatch(msg);
+                for await (const line of readNdjson(this.child.stdout)) {
+                    let msg;
+                    try {
+                        msg = JSON.parse(line);
                     }
-                };
-                // Start consuming stdout before awaiting bootstrap: JSON-RPC responses
-                // read here settle the initialize/thread/turn requests. Owning both
-                // promises makes every bootstrap rejection part of session.result.
-                await Promise.all([this.ready, readLoop()]);
+                    catch {
+                        continue;
+                    }
+                    // Explicit shutdown suppresses late lifecycle, not passive output.
+                    // Natural exit can overtake the final turn frame: retain its outcome
+                    // without restoring ACK/ask/input authority on the dead connection.
+                    const finalOutcome = this.stdinOpen && hasExited() &&
+                        (msg.method === 'turn/completed' || msg.method === 'turn/failed');
+                    if (!this.open && (msg.id !== undefined || (!PASSIVE_OUTPUT_METHODS.has(msg.method ?? '') && !finalOutcome)))
+                        continue;
+                    // Child turn lifecycle must reach neither channel (#600).
+                    if (this.isForeignTurnLifecycle(msg))
+                        continue;
+                    this.emitUi((state) => mapCodexNotification(msg, state));
+                    this.dispatch(msg);
+                }
+                if (this.stdinOpen && !hasExited()) {
+                    if (!this.startupComplete)
+                        this.fail(new Error(`Codex startup stdout closed while waiting for ${this.startupPhase}`));
+                    else
+                        this.end();
+                }
             }
-            catch (err) {
-                if (!this.timedOut) {
-                    sessionError = err;
-                    // Bootstrap failed before a usable turn exists. Closing stdin lets
-                    // app-server exit normally; end() also owns the TERM/KILL watchdog
-                    // if a broken child ignores EOF.
-                    this.end();
+            catch {
+                if (this.stdinOpen && !hasExited()) {
+                    this.fail(new Error(`codex app-server output failed while waiting for ${this.startupPhase}`));
+                }
+            }
+        })();
+        this.result = (async () => {
+            let exitCode;
+            try {
+                try {
+                    await Promise.all([this.ready, reader]);
                 }
+                catch (err) {
+                    if (this.stdinOpen && !hasExited())
+                        this.fail(err instanceof Error ? err : new Error(String(err)));
+                }
+                // RPC cancellation is not a receipt for process termination. Keep the
+                // TERM→KILL watchdog alive until this independently owned promise settles.
+                exitCode = await exited;
+                await reader;
             }
             finally {
                 if (deadline)
                     clearTimeout(deadline);
-                if (killTimer)
-                    clearTimeout(killTimer);
-                if (this.autoEndTimer)
-                    clearTimeout(this.autoEndTimer);
-                this.stdinOpen = false;
+                if (drainTimer)
+                    clearTimeout(drainTimer);
+                if (this.stopKillTimer)
+                    clearTimeout(this.stopKillTimer);
+                if (this.eofTermTimer)
+                    clearTimeout(this.eofTermTimer);
+                if (this.eofKillTimer)
+                    clearTimeout(this.eofKillTimer);
+                this.closeInput('codex app-server exited');
+                this.child.stdin.destroy();
+                this.child.stderr.destroy();
             }
-            const exitCode = await waitForCodexAppServerExit(this.child);
-            if (this.eofTermTimer)
-                clearTimeout(this.eofTermTimer);
-            if (this.eofKillTimer)
-                clearTimeout(this.eofKillTimer);
-            this.rpc.rejectPending();
             if (this.spawnFailed)
                 throw this.spawnFailed;
-            if (sessionError)
-                throw sessionError;
+            if (this.failure)
+                throw this.failure;
             // Timeout/interrupt can end the read loop mid-item — recover buffered prose.
             this.textCoalescer.flush();
             const text = this.textChunks.join('\n').trim();
@@ -250,26 +315,45 @@ class CodexSession {
         })();
     }
     get open() {
-        return this.stdinOpen;
+        return this.stdinOpen && this.rpc.open && !this.hasExited();
     }
     get pid() {
         return this.child.pid;
     }
-    sendAgentMessage(content) {
-        if (!this.stdinOpen || !this.agentInputReady || this.pendingUserInput || this.agentSubmissionPending)
+    sendAgentMessage(content, inputIds = []) {
+        // #505: a running turn is steered with turn/steer; only an unanswered native ask
+        // or an in-flight submission refuses.
+        // Until the thread and its first turn exist there is nothing to steer or start;
+        // a refusal here earns one readiness hint when startup completes.
+        if (this.open && !this.startupComplete) {
+            this.refusedBeforeStartup = true;
+            return false;
+        }
+        // A human prompt still on its way to the wire goes first (#505 local review).
+        if (this.open && this.humanPromptsPending > 0) {
+            this.refusedForHuman = true;
+            return false;
+        }
+        if (!this.open || this.pendingUserInput || this.agentSubmissionPending)
             return false;
         this.agentInputReady = false;
         this.agentSubmissionPending = true;
         if (this.autoEndTimer)
             clearTimeout(this.autoEndTimer);
         this.autoEndTimer = undefined;
+        const submissionId = randomUUID();
+        this.submissions.accept(submissionId, inputIds, '');
+        this.inFlightSubmissionId = submissionId;
         // Reserve synchronously; only the matching RPC result acknowledges delivery.
-        return this.startOrSteerTurn(textOf(content)).catch((err) => {
+        return this.startOrSteerTurn(textOf(content), submissionId).catch((err) => {
+            this.submissions.consume(submissionId); // never accepted: the caller keeps ownership
             if (this.stdinOpen)
                 this.emit({ type: 'error', message: `codex: agent input failed: ${String(err)}` });
             throw err;
         }).finally(() => {
             this.agentSubmissionPending = false;
+            if (this.inFlightSubmissionId === submissionId)
+                this.inFlightSubmissionId = undefined;
             if (this.stdinOpen && this.agentInputReady && !this.pendingUserInput) {
                 this.opts.onAgentInputReady?.();
                 this.scheduleAutoEnd();
@@ -277,7 +361,7 @@ class CodexSession {
         });
     }
     scheduleAutoEnd() {
-        if (!this.opts.autoEndAfterFirstTurn || !this.stdinOpen || this.autoEndTimer || this.agentSubmissionPending)
+        if (!this.opts.autoEndAfterFirstTurn || !this.open || this.autoEndTimer || this.agentSubmissionPending)
             return;
         this.autoEndTimer = setTimeout(() => {
             this.autoEndTimer = undefined;
@@ -288,7 +372,7 @@ class CodexSession {
     }
     sendMessage(content) {
         this.agentInputReady = false;
-        if (!this.stdinOpen)
+        if (!this.open)
             return false;
         if (this.autoEndTimer) {
             clearTimeout(this.autoEndTimer);
@@ -301,14 +385,26 @@ class CodexSession {
             const pending = this.pendingUserInput;
             this.pendingUserInput = undefined;
             this.rpc.respond({ id: pending.rpcId, result: { answers: userInputAnswers(pending.questions, text) } });
-            return true;
+            return this.open;
         }
-        // Wait for the thread to exist, then steer the live turn or start a new one.
+        // Wait for the thread to exist, then steer the live turn or start a new one. Agent input
+        // waits until this prompt's request settles, so it can never overtake it.
+        this.humanPromptsPending += 1;
         void this.ready
             .then(() => this.startOrSteerTurn(text))
             .catch((err) => {
-            const message = err instanceof Error ? err.message : String(err);
-            this.emit({ type: 'note', message: `codex: turn failed: ${message}` });
+            if (this.stdinOpen) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.emit({ type: 'note', message: `codex: turn failed: ${message}` });
+            }
+        })
+            .finally(() => {
+            this.humanPromptsPending -= 1;
+            if (this.humanPromptsPending === 0 && this.refusedForHuman) {
+                this.refusedForHuman = false;
+                if (this.open && !this.pendingUserInput && !this.agentSubmissionPending)
+                    this.opts.onAgentInputReady?.();
+            }
         });
         return true;
     }
@@ -316,8 +412,7 @@ class CodexSession {
     end() {
         if (!this.stdinOpen)
             return;
-        this.rejectPendingUserInput('session ended');
-        this.stdinOpen = false;
+        this.closeInput('session ended');
         try {
             endCodexAppServer(this.child, (term, kill) => {
                 this.eofTermTimer = term;
@@ -331,20 +426,79 @@ class CodexSession {
         }
     }
     interrupt() {
-        this.stdinOpen = false;
-        this.rejectPendingUserInput('turn interrupted');
-        // Best-effort graceful cancel of the in-flight turn, then hard stop.
-        if (this.threadId && this.activeTurnId) {
+        if (this.hardStopStarted || this.hasExited())
+            return;
+        this.hardStopStarted = true;
+        if (this.eofTermTimer)
+            clearTimeout(this.eofTermTimer);
+        if (this.eofKillTimer)
+            clearTimeout(this.eofKillTimer);
+        // Native cancellation is best effort; never wait for its ACK to stop.
+        if (this.stdinOpen && this.threadId && this.activeTurnId) {
             void this.rpc.request('turn/interrupt', { threadId: this.threadId, turnId: this.activeTurnId }).catch(() => undefined);
         }
-        if (!this.hasExited()) {
-            this.terminatedByCezar = true;
-            this.child.kill('SIGTERM');
+        this.closeInput('codex session stopped');
+        this.terminatedByCezar = true;
+        this.child.kill('SIGTERM');
+        this.stopKillTimer = setTimeout(() => {
+            if (!this.hasExited())
+                this.child.kill('SIGKILL');
+        }, KILL_GRACE_MS);
+        this.stopKillTimer.unref?.();
+    }
+    closeInput(reason) {
+        this.stdinOpen = false;
+        this.rejectPendingUserInput(reason);
+        this.agentInputReady = false;
+        if (this.startupTimer)
+            clearTimeout(this.startupTimer);
+        if (this.autoEndTimer)
+            clearTimeout(this.autoEndTimer);
+        this.rpc.close(reason);
+    }
+    fail(error, diagnostic = 'failed') {
+        if (!this.stdinOpen)
+            return;
+        this.failure ??= error;
+        // Stage-only diagnostics never include prompt/config/env or raw stderr.
+        const message = this.startupComplete ? 'Codex app-server failed; closing app-server'
+            : `Codex startup ${diagnostic} while waiting for ${this.startupPhase}; closing app-server`;
+        try {
+            this.emit({ type: 'note', message });
         }
+        catch { /* A failing diagnostic sink cannot release a still-live process. */ }
+        this.interrupt();
+    }
+    assertOpen() {
+        if (!this.open)
+            throw new Error('codex session closed');
+    }
+    startupWaitingFor(phase) {
+        this.assertOpen();
+        this.startupPhase = phase;
+        this.emit({ type: 'note', message: `Codex startup: waiting for ${phase}` });
+    }
+    checkStartupComplete() {
+        if (!this.openingAcknowledged || !this.firstTurnStarted || !this.stdinOpen)
+            return;
+        if (this.startupComplete)
+            return;
+        this.startupComplete = true;
+        if (this.startupTimer)
+            clearTimeout(this.startupTimer);
+        // Input refused during startup can now steer the opening turn (#505).
+        if (this.refusedBeforeStartup)
+            queueMicrotask(() => {
+                this.refusedBeforeStartup = false;
+                if (this.open && !this.pendingUserInput && !this.agentSubmissionPending)
+                    this.opts.onAgentInputReady?.();
+            });
     }
     // ---- protocol -----------------------------------------------------------
     async bootstrap() {
+        this.startupWaitingFor('initialize');
         await this.rpc.initialize();
+        this.assertOpen();
         const overrides = {
             model: this.spec.model,
             cwd: this.spec.cwd,
@@ -360,11 +514,15 @@ class CodexSession {
                 } } : {}),
         };
         if (this.spec.resume && this.spec.sessionId) {
+            this.startupWaitingFor('thread/resume');
             await this.rpc.request('thread/resume', { threadId: this.spec.sessionId, ...clean(overrides) });
+            this.assertOpen();
             this.threadId = this.spec.sessionId;
         }
         else {
+            this.startupWaitingFor('thread/start');
             const res = await this.rpc.request('thread/start', clean(overrides));
+            this.assertOpen();
             this.threadId = threadIdOf(res) ?? this.spec.sessionId;
         }
         if (this.threadId) {
@@ -378,31 +536,73 @@ class CodexSession {
         // has no dedicated app-server field, so it rides along as a leading block
         // of the opening message.
         const first = prependSystemPrompt(this.spec.systemPrompt, this.spec.userPrompt);
+        this.startupWaitingFor('turn/start');
         await this.startOrSteerTurn(first);
+        this.assertOpen();
+        this.openingAcknowledged = true;
+        this.checkStartupComplete();
+        if (!this.startupComplete)
+            this.startupWaitingFor('first main-thread turn');
     }
-    async startOrSteerTurn(text) {
+    async startOrSteerTurn(text, clientUserMessageId) {
+        this.assertOpen();
         if (!this.threadId)
-            return;
+            throw new Error('codex app-server did not return a thread id');
         this.agentInputReady = false;
         const input = [{ type: 'text', text, text_elements: [] }];
+        // Echoed as the consumed userMessage item's `clientId` (#505).
+        const ids = clientUserMessageId ? { clientUserMessageId } : {};
         if (this.activeTurnId) {
-            await this.rpc.request('turn/steer', {
-                threadId: this.threadId,
-                input,
-                expectedTurnId: this.activeTurnId,
-            });
-            return;
+            const boundary = this.turnBoundaryVersion;
+            try {
+                await this.rpc.request('turn/steer', {
+                    threadId: this.threadId,
+                    input,
+                    expectedTurnId: this.activeTurnId,
+                    ...ids,
+                });
+                // Accepted, but the turn completed before the model read it: nothing will read
+                // it now, so start a turn with it under the same client id (#505).
+                const stranded = clientUserMessageId !== undefined && this.turnBoundaryVersion !== boundary &&
+                    !this.activeTurnId && this.submissions.has(clientUserMessageId);
+                if (!stranded)
+                    return;
+            }
+            catch (err) {
+                // Only a definitive refusal falls back: the server answered with an error AND
+                // the turn ended meanwhile. A timeout or closed transport is ambiguous — the
+                // steer may have landed — so it rejects without a retry (#505).
+                if (!(err instanceof CodexRpcResponseError) || this.turnBoundaryVersion === boundary || this.activeTurnId)
+                    throw err;
+            }
         }
         // Ask the app-server for reasoning summaries; without this the model runs
         // with its default (no summary), so the reasoning thread stays empty even
         // though the mapper and UI can render it. The override persists for this
         // turn and every subsequent turn, so seeding it on turn/start is enough.
         const boundaryVersion = this.turnBoundaryVersion;
+        const completionsBefore = this.turnCompletions;
         const res = await this.rpc.request('turn/start', {
             threadId: this.threadId,
             input,
+            ...ids,
             ...codexTurnStartExtras(this.spec),
         });
+        if (clientUserMessageId) {
+            // This turn's own input: its completion proves the model processed it (#505). A response
+            // can arrive after that turn already completed; settle it from the recorded outcome.
+            const startedTurn = turnIdOf(res);
+            const outcome = startedTurn && this.turnCompletions > completionsBefore ? this.completedTurns.get(startedTurn) : undefined;
+            if (outcome === undefined)
+                this.turnStartSubmissions.add(clientUserMessageId);
+            else {
+                const settled = this.submissions.consume(clientUserMessageId);
+                if (settled.length && outcome)
+                    this.opts.onAgentInputConsumed?.(settled);
+                else if (settled.length)
+                    this.emit({ type: 'input-unconsumed', inputIds: settled });
+            }
+        }
         if (this.turnBoundaryVersion === boundaryVersion)
             this.activeTurnId = turnIdOf(res) ?? this.activeTurnId;
     }
@@ -459,6 +659,10 @@ class CodexSession {
                     this.turnBoundaryVersion += 1;
                 if (this.isForeignThreadTurn(params))
                     break; // sub-agent child thread — not our turn (#600)
+                if (this.threadId && turnIdOf(params)) {
+                    this.firstTurnStarted = true;
+                    this.checkStartupComplete();
+                }
                 this.activeTurnId = turnIdOf(params) ?? this.activeTurnId;
                 break;
             }
@@ -475,6 +679,13 @@ class CodexSession {
             case 'item/started': {
                 const item = params.item ?? {};
                 const type = stringField(item, 'type');
+                if (type === 'userMessage' && !this.isForeignThreadTurn(params)) {
+                    // The model received this input now; `clientId` names our submission (#505).
+                    const clientId = stringField(item, 'clientId');
+                    const ids = clientId ? this.submissions.consume(clientId) : [];
+                    if (ids.length)
+                        this.opts.onAgentInputConsumed?.(ids);
+                }
                 // Only tool-like items become tool events; message/reasoning stream as text.
                 if (type && !NON_TOOL_ITEMS.has(type)) {
                     const id = stringField(item, 'id') ?? `item-${this.rpc.allocateId()}`;
@@ -523,11 +734,29 @@ class CodexSession {
                 // partial prose before the turn boundary (run.ts reads markers there).
                 this.textCoalescer.flush();
                 const outcome = codexTurnOutcome(method, params);
+                const completedId = turnIdOf(params);
+                if (completedId) {
+                    this.completedTurns.set(completedId, outcome.error === undefined);
+                    if (this.completedTurns.size > 32)
+                        this.completedTurns.delete(this.completedTurns.keys().next().value);
+                }
+                this.turnCompletions += 1;
                 if (outcome.error !== undefined && !this.terminatedByCezar) {
                     this.emit({ type: 'error', message: outcome.error });
                 }
-                this.agentInputReady = true;
-                this.emit({ type: 'turn-end' });
+                this.agentInputReady = this.open;
+                // A completed turn processed its own input; a failed one may never have reached the
+                // model, so its input stays pending and is reported unconsumed below.
+                const started = outcome.error === undefined ? [...this.turnStartSubmissions].flatMap(id => this.submissions.consume(id)) : [];
+                this.turnStartSubmissions.clear();
+                if (started.length)
+                    this.opts.onAgentInputConsumed?.(started);
+                // An in-flight steer is owned by its RPC outcome, not by this boundary.
+                const inFlight = this.inFlightSubmissionId ? this.submissions.consume(this.inFlightSubmissionId) : [];
+                const unconsumedInputIds = this.submissions.takeUnconsumed();
+                if (this.inFlightSubmissionId && inFlight.length)
+                    this.submissions.accept(this.inFlightSubmissionId, inFlight, '');
+                this.emit(unconsumedInputIds.length ? { type: 'turn-end', unconsumedInputIds } : { type: 'turn-end' });
                 this.scheduleAutoEnd();
                 break;
             }
@@ -601,6 +830,12 @@ const NON_TOOL_ITEMS = new Set(['agentMessage', 'userMessage', 'reasoning', 'pla
 /** Turn-lifecycle notification methods — the only frames whose child-thread copies must be
  *  dropped so a sub-agent turn can't be mistaken for the parent's (#600). */
 const TURN_LIFECYCLE_METHODS = new Set(['turn/started', 'turn/completed', 'turn/failed']);
+/** Notifications that only collect output; never dispatch control after close. */
+const PASSIVE_OUTPUT_METHODS = new Set([
+    'item/started', 'item/updated', 'item/completed', 'item/agentMessage/delta',
+    'item/reasoning/textDelta', 'item/reasoning/summaryDelta', 'item/reasoning/summaryTextDelta',
+    'item/commandExecution/outputDelta', 'thread/tokenUsage/updated', 'turn/plan/updated',
+]);
 const REASONING_SUMMARIES = new Set(['auto', 'concise', 'detailed', 'none']);
 /**
  * The reasoning-summary override sent on `turn/start` (TurnStartParams.summary).