@parall/codex-agent 1.58.2 → 1.59.0

package/dist/dispatch.d.ts

@@ -1,4 +1,4 @@
-import type { CleanupForkOpts, DispatchAdapter, DispatchOpts, ForkOpts, ForkSessionHandle, GatewayLogger, RuntimeEvent } from '@parall/agent-core';
+import type { CleanupForkOpts, DispatchAdapter, DispatchInputLifecycle, DispatchOpts, ForkOpts, ForkSessionHandle, GatewayLogger, RuntimeEvent } from '@parall/agent-core';
 import type { CodexAgentConfig } from './config.js';
 import { type NotificationTap } from './instructions-refresh.js';
 import type { CodexSessionManager } from './session-manager.js';
@@ -62,7 +62,7 @@ export declare class CodexAppServerAdapter implements DispatchAdapter {
     private startPromise;
     private readonly activeTurns;
     private readonly activeTurnIds;
-    private readonly pendingInjections;
+    private readonly injections;
     private readonly resumedThreadIds;
     /** Threads whose reconcile compaction is in flight — tap-only traffic. */
     private readonly reconcilingThreadIds;
@@ -105,10 +105,12 @@ export declare class CodexAppServerAdapter implements DispatchAdapter {
         developerInstructions?: string | null;
     }): void;
     private threadConfigOverrides;
-    enqueueDuringDispatch(sessionKey: string, body: string): Promise<boolean>;
+    enqueueDuringDispatch(sessionKey: string, body: string, inputLifecycle?: DispatchInputLifecycle): Promise<boolean>;
     abortDispatch(sessionKey: string): void;
     hasPendingInjections(sessionKey: string): boolean;
-    dispatch({ event, bodyForAgent, sessionKey, context, noteActivity, }: DispatchOpts): AsyncIterable<RuntimeEvent>;
+    hasUnsettledInjections(sessionKey: string): boolean;
+    acknowledgeDiscardedInjection(sessionKey: string, deliveryKey: string): void;
+    dispatch({ event, bodyForAgent, sessionKey, context, inputLifecycle, noteActivity, }: DispatchOpts): AsyncIterable<RuntimeEvent>;
     /**
      * Bring the app-server up and open (start or resume) the thread for this
      * dispatch, then reconcile the main thread's EFFECTIVE instructions plane.

package/dist/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,YAAY,EACZ,QAAQ,EACR,iBAAiB,EACjB,aAAa,EACb,YAAY,EACb,MAAM,oBAAoB,CAAC;AAa5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAIhE,KAAK,4BAA4B,GAAG,IAAI,CACtC,gBAAgB,EACd,gBAAgB,GAChB,UAAU,GACV,WAAW,GACX,OAAO,GACP,iBAAiB,GACjB,SAAS,GACT,cAAc,CACjB,GAAG;IACF,cAAc,EAAE,mBAAmB,CAAC;IACpC,GAAG,CAAC,EAAE,aAAa,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;;;;;;;OAiBG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,gFAAgF;IAChF,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,8EAA8E;IAC9E,4BAA4B,CAAC,EAAE,MAAM,CAAC;CACvC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAsB,YAAW,eAAe;IA8C/C,OAAO,CAAC,QAAQ,CAAC,IAAI;IA7CjC,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,IAAI,CAA+C;IAC3D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;IAC3D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;IACtD,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAqB;IAC1D;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA8B;IAC/D,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAkC;IACxE,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,8BAA8B,CAAK;IAE3C;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;gBAYQ,IAAI,EAAE,4BAA4B;IAS/D,6EAA6E;IAC7E,kBAAkB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,IAAI;IAKpD;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAU1B,YAAY,CAAC,MAAM,EAAE;QACnB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAChC,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACvC,GAAG,IAAI;IAQR,OAAO,CAAC,qBAAqB;IAQvB,qBAAqB,CACzB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,cAAc,CAAC,EAAE,sBAAsB,GACtC,OAAO,CAAC,OAAO,CAAC;IAuBnB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IA0BvC,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAIjD,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAInD,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAIrE,QAAQ,CAAC,EACd,KAAK,EACL,YAAY,EACZ,UAAU,EACV,OAAO,EACP,cAAc,EACd,YAAY,GACb,EAAE,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC;IAqS7C;;;;;;OAMG;YACW,kBAAkB;IAoGhC,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMjD,WAAW,CAAC,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IA+ChG,WAAW,CAAC,EAAE,IAAI,EAAE,EAAE,eAAe;IAIrC,OAAO,CAAC,cAAc;IAKtB;;;;;;;;;;;;OAYG;IACH,qBAAqB,IAAI,IAAI;IAI7B,OAAO,CAAC,gBAAgB,CAAS;IAEjC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB,CAAK;YAEhB,mBAAmB;IAS3B,IAAI;YA2BI,aAAa;YA4Bb,OAAO;IAoIrB,OAAO,CAAC,qBAAqB;YAsCf,UAAU;IAwDxB,OAAO,CAAC,iBAAiB;CA2D1B"}

package/dist/dispatch.js

@@ -5,6 +5,7 @@ import { appendPreparedLocalAttachmentRefs, pinLocalAttachmentPaths, } from '@pa
 import { ensureGitRepo, IS_WIN32, killWin32Tree, quoteWin32Arg } from './app-server-process.js';
 import { buildTurnInput, extractThreadId, extractThreadIdFromNotification, extractTurnId, } from './app-server-protocol.js';
 import { normalizeApprovalPolicy, normalizeSandbox } from './config.js';
+import { CodexInjectionRegistry } from './injection-registry.js';
 import { MainThreadInstructionsRefresher, } from './instructions-refresh.js';
 import { JsonRpcStdioClient } from './jsonrpc-client.js';
 import { answerServerRequest } from './server-requests.js';
@@ -32,7 +33,7 @@ export class CodexAppServerAdapter {
     startPromise = null;
     activeTurns = new Map();
     activeTurnIds = new Map();
-    pendingInjections = new Map();
+    injections = new CodexInjectionRegistry();
     resumedThreadIds = new Set();
     /** Threads whose reconcile compaction is in flight — tap-only traffic. */
     reconcilingThreadIds = new Set();
@@ -112,7 +113,10 @@ export class CodexAppServerAdapter {
             inheritedPath: process.env.PATH,
         });
     }
-    async enqueueDuringDispatch(sessionKey, body) {
+    async enqueueDuringDispatch(sessionKey, body, inputLifecycle) {
+        // Identity is mandatory — the drain releases the injection by this key (injection-registry.ts).
+        if (!inputLifecycle)
+            return false;
         const client = this.client;
         if (!client || client.isDisposed())
             return false;
@@ -128,7 +132,7 @@ export class CodexAppServerAdapter {
                 expectedTurnId: turnId,
                 input: buildTurnInput(body, []),
             });
-            this.pendingInjections.set(sessionKey, (this.pendingInjections.get(sessionKey) ?? 0) + 1);
+            this.injections.register(sessionKey, inputLifecycle.deliveryKey);
             return true;
         }
         catch (err) {
@@ -137,7 +141,8 @@ export class CodexAppServerAdapter {
         }
     }
     abortDispatch(sessionKey) {
-        this.pendingInjections.delete(sessionKey);
+        // A torn-down turn owes nothing: the error complete releases its members for fresh turns.
+        this.injections.clear(sessionKey);
         const threadId = this.opts.sessionManager.getThreadId(sessionKey);
         if (!threadId)
             return;
@@ -163,24 +168,19 @@ export class CodexAppServerAdapter {
         sink.close();
     }
     hasPendingInjections(sessionKey) {
-        return (this.pendingInjections.get(sessionKey) ?? 0) > 0;
+        return this.injections.hasPending(sessionKey);
     }
-    async *dispatch({ event, bodyForAgent, sessionKey, context, noteActivity, }) {
-        const pending = this.pendingInjections.get(sessionKey) ?? 0;
-        if (pending > 0) {
-            this.pendingInjections.delete(sessionKey);
-            const threadId = this.opts.sessionManager.getThreadId(sessionKey);
-            if (threadId && this.client && !this.client.isDisposed()) {
-                (this.opts.log ?? context.log)?.info?.(`${pending} steer injection(s) already sent; skipping turn/start`);
-                yield {
-                    type: 'runtime_session',
-                    runtimeSessionId: threadId,
-                    runtimeLaneKey: sessionKey,
-                };
-                return;
-            }
-            (this.opts.log ?? context.log)?.warn?.(`pending steer invalidated (subprocess died); falling through to normal dispatch`);
-        }
+    hasUnsettledInjections(sessionKey) {
+        return this.injections.hasUnsettled(sessionKey);
+    }
+    acknowledgeDiscardedInjection(sessionKey, deliveryKey) {
+        this.injections.markDrained(sessionKey, deliveryKey);
+    }
+    async *dispatch({ event, bodyForAgent, sessionKey, context, inputLifecycle, noteActivity, }) {
+        // This dispatch drains the injected copies it lists; it ALWAYS runs its own
+        // turn — never skipped on outstanding injections (PFB-84, injection-registry.ts).
+        if (inputLifecycle)
+            this.injections.markDrained(sessionKey, inputLifecycle.deliveryKey);
         const isMainSession = this.opts.sessionManager.isMain(sessionKey);
         if (isMainSession && this.mainLaneQuarantined) {
             // Try the pending restart now — it may have been deferred behind an
@@ -456,6 +456,7 @@ export class CodexAppServerAdapter {
             releasePreparedAttachments();
             this.activeTurns.delete(threadId);
             this.activeTurnIds.delete(threadId);
+            this.injections.settleAll(sessionKey); // the turn consumed (or lost) everything steered into it
             if (!sawTurnEnd) {
                 sink.close();
             }
@@ -665,7 +666,7 @@ export class CodexAppServerAdapter {
         this.client = null;
         this.initialized = false;
         this.activeTurnIds.clear();
-        this.pendingInjections.clear();
+        this.injections.clear();
         // Resume markers are process-local facts. Clear them HERE, synchronously:
         // the old child's close callback sees the replaced refs and skips its
         // cleanup as stale, so a marker surviving stop() would make the next
@@ -692,7 +693,7 @@ export class CodexAppServerAdapter {
             }
             this.activeTurns.clear();
             this.activeTurnIds.clear();
-            this.pendingInjections.clear();
+            this.injections.clear();
             this.client = null;
             this.proc = null;
             this.initialized = false;
@@ -856,7 +857,7 @@ export class CodexAppServerAdapter {
         }
         this.activeTurns.clear();
         this.activeTurnIds.clear();
-        this.pendingInjections.clear();
+        this.injections.clear();
         this.resumedThreadIds.clear();
         this.instructionsRefresher.clearThreadState();
         this.mainLaneQuarantined = false;

package/dist/injection-registry.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Bookkeeping for mid-turn steer injections (`turn/steer`), per session key.
+ *
+ * Codex gives no per-input runtime receipt: a successful `turn/steer` only
+ * says the app-server accepted the text into the running turn. So each
+ * injection carries two independent facts with two different owners:
+ *
+ *   - settled — the turn it was steered into has ended (the adapter's own
+ *     dispatch() generator closing on turn/completed, an interrupt, or the
+ *     subprocess dying). Only an UNSETTLED injection may hold a lane's
+ *     complete open (DispatchAdapter.hasUnsettledInjections).
+ *   - drained — the gateway consumed the buffered copy that backs it: either
+ *     the already-rendered drain branch (acknowledgeDiscardedInjection) or a
+ *     group dispatch() whose inputLifecycle lists the WorkItem. Until then the
+ *     copy still owes frame-boundary bookkeeping (hasPendingInjections).
+ *
+ * Entries are keyed by WorkItem id — the deliveryKey the gateway uses on both
+ * sides — never counted. The pre-PFB-84 design kept a per-session COUNT and
+ * made the next dispatch() skip turn/start while it was non-zero: a copy the
+ * gateway discarded without a dispatch() never decremented it, so the count
+ * leaked onto the NEXT unrelated message, whose dispatch then ran no turn and
+ * was complete(ok)-swept as no_action — the model never saw it.
+ */
+export declare class CodexInjectionRegistry {
+    private readonly sessions;
+    /** Record a successful steer. `deliveryKey` may join several WorkItem ids with ','. */
+    register(sessionKey: string, deliveryKey: string): void;
+    /** The buffered copies behind these WorkItems drained (group dispatch or discard). */
+    markDrained(sessionKey: string, deliveryKey: string): void;
+    /** The turn every injection of this session was steered into has ended. */
+    settleAll(sessionKey: string): void;
+    /** An injection whose buffered copy has not drained yet (bookkeeping owed). */
+    hasPending(sessionKey: string): boolean;
+    /** An injection whose turn is still running (the only state that may defer a complete). */
+    hasUnsettled(sessionKey: string): boolean;
+    /** Drop every entry (turn aborted / subprocess gone): nothing is owed anymore. */
+    clear(sessionKey?: string): void;
+}
+//# sourceMappingURL=injection-registry.d.ts.map

package/dist/injection-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection-registry.d.ts","sourceRoot":"","sources":["../src/injection-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkD;IAE3E,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAWvD,sFAAsF;IACtF,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAY1D,2EAA2E;IAC3E,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAUnC,+EAA+E;IAC/E,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IASvC,2FAA2F;IAC3F,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IASzC,kFAAkF;IAClF,KAAK,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;CAOjC"}

package/dist/injection-registry.js

@@ -0,0 +1,103 @@
+/**
+ * Bookkeeping for mid-turn steer injections (`turn/steer`), per session key.
+ *
+ * Codex gives no per-input runtime receipt: a successful `turn/steer` only
+ * says the app-server accepted the text into the running turn. So each
+ * injection carries two independent facts with two different owners:
+ *
+ *   - settled — the turn it was steered into has ended (the adapter's own
+ *     dispatch() generator closing on turn/completed, an interrupt, or the
+ *     subprocess dying). Only an UNSETTLED injection may hold a lane's
+ *     complete open (DispatchAdapter.hasUnsettledInjections).
+ *   - drained — the gateway consumed the buffered copy that backs it: either
+ *     the already-rendered drain branch (acknowledgeDiscardedInjection) or a
+ *     group dispatch() whose inputLifecycle lists the WorkItem. Until then the
+ *     copy still owes frame-boundary bookkeeping (hasPendingInjections).
+ *
+ * Entries are keyed by WorkItem id — the deliveryKey the gateway uses on both
+ * sides — never counted. The pre-PFB-84 design kept a per-session COUNT and
+ * made the next dispatch() skip turn/start while it was non-zero: a copy the
+ * gateway discarded without a dispatch() never decremented it, so the count
+ * leaked onto the NEXT unrelated message, whose dispatch then ran no turn and
+ * was complete(ok)-swept as no_action — the model never saw it.
+ */
+export class CodexInjectionRegistry {
+    sessions = new Map();
+    /** Record a successful steer. `deliveryKey` may join several WorkItem ids with ','. */
+    register(sessionKey, deliveryKey) {
+        let entries = this.sessions.get(sessionKey);
+        if (!entries) {
+            entries = new Map();
+            this.sessions.set(sessionKey, entries);
+        }
+        for (const id of splitDeliveryKey(deliveryKey)) {
+            if (!entries.has(id))
+                entries.set(id, { settled: false, drained: false });
+        }
+    }
+    /** The buffered copies behind these WorkItems drained (group dispatch or discard). */
+    markDrained(sessionKey, deliveryKey) {
+        const entries = this.sessions.get(sessionKey);
+        if (!entries)
+            return;
+        for (const id of splitDeliveryKey(deliveryKey)) {
+            const entry = entries.get(id);
+            if (!entry)
+                continue;
+            entry.drained = true;
+            if (entry.settled)
+                entries.delete(id);
+        }
+        if (entries.size === 0)
+            this.sessions.delete(sessionKey);
+    }
+    /** The turn every injection of this session was steered into has ended. */
+    settleAll(sessionKey) {
+        const entries = this.sessions.get(sessionKey);
+        if (!entries)
+            return;
+        for (const [id, entry] of entries) {
+            entry.settled = true;
+            if (entry.drained)
+                entries.delete(id);
+        }
+        if (entries.size === 0)
+            this.sessions.delete(sessionKey);
+    }
+    /** An injection whose buffered copy has not drained yet (bookkeeping owed). */
+    hasPending(sessionKey) {
+        const entries = this.sessions.get(sessionKey);
+        if (!entries)
+            return false;
+        for (const entry of entries.values()) {
+            if (!entry.drained)
+                return true;
+        }
+        return false;
+    }
+    /** An injection whose turn is still running (the only state that may defer a complete). */
+    hasUnsettled(sessionKey) {
+        const entries = this.sessions.get(sessionKey);
+        if (!entries)
+            return false;
+        for (const entry of entries.values()) {
+            if (!entry.settled)
+                return true;
+        }
+        return false;
+    }
+    /** Drop every entry (turn aborted / subprocess gone): nothing is owed anymore. */
+    clear(sessionKey) {
+        if (sessionKey === undefined) {
+            this.sessions.clear();
+            return;
+        }
+        this.sessions.delete(sessionKey);
+    }
+}
+function splitDeliveryKey(deliveryKey) {
+    return deliveryKey
+        .split(',')
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/codex-agent",
-  "version": "1.58.2",
+  "version": "1.59.0",
   "description": "Codex CLI bridge runtime for self-hosted Parall agents",
   "license": "MIT",
   "repository": {
@@ -25,9 +25,9 @@
     "src"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.58.2",
-    "@parall/cli": "1.58.2",
-    "@parall/sdk": "1.58.2"
+    "@parall/agent-core": "1.59.0",
+    "@parall/cli": "1.59.0",
+    "@parall/sdk": "1.59.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/dispatch.ts

@@ -4,6 +4,7 @@ import * as path from 'node:path';
 import type {
   CleanupForkOpts,
   DispatchAdapter,
+  DispatchInputLifecycle,
   DispatchOpts,
   ForkOpts,
   ForkSessionHandle,
@@ -24,6 +25,7 @@ import {
 } from './app-server-protocol.js';
 import type { CodexAgentConfig } from './config.js';
 import { normalizeApprovalPolicy, normalizeSandbox } from './config.js';
+import { CodexInjectionRegistry } from './injection-registry.js';
 import {
   MainThreadInstructionsRefresher,
   type NotificationTap,
@@ -104,7 +106,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
   private startPromise: Promise<void> | null = null;
   private readonly activeTurns = new Map<string, TurnSink>();
   private readonly activeTurnIds = new Map<string, string>();
-  private readonly pendingInjections = new Map<string, number>();
+  private readonly injections = new CodexInjectionRegistry();
   private readonly resumedThreadIds = new Set<string>();
   /** Threads whose reconcile compaction is in flight — tap-only traffic. */
   private readonly reconcilingThreadIds = new Set<string>();
@@ -194,7 +196,13 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     });
   }
 
-  async enqueueDuringDispatch(sessionKey: string, body: string): Promise<boolean> {
+  async enqueueDuringDispatch(
+    sessionKey: string,
+    body: string,
+    inputLifecycle?: DispatchInputLifecycle,
+  ): Promise<boolean> {
+    // Identity is mandatory — the drain releases the injection by this key (injection-registry.ts).
+    if (!inputLifecycle) return false;
     const client = this.client;
     if (!client || client.isDisposed()) return false;
     const threadId = this.opts.sessionManager.getThreadId(sessionKey);
@@ -207,7 +215,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
         expectedTurnId: turnId,
         input: buildTurnInput(body, []),
       });
-      this.pendingInjections.set(sessionKey, (this.pendingInjections.get(sessionKey) ?? 0) + 1);
+      this.injections.register(sessionKey, inputLifecycle.deliveryKey);
       return true;
     } catch (err) {
       this.opts.log?.warn?.(`turn/steer failed: ${errToString(err)}`);
@@ -216,7 +224,8 @@ export class CodexAppServerAdapter implements DispatchAdapter {
   }
 
   abortDispatch(sessionKey: string): void {
-    this.pendingInjections.delete(sessionKey);
+    // A torn-down turn owes nothing: the error complete releases its members for fresh turns.
+    this.injections.clear(sessionKey);
     const threadId = this.opts.sessionManager.getThreadId(sessionKey);
     if (!threadId) return;
     const sink = this.activeTurns.get(threadId);
@@ -241,7 +250,15 @@ export class CodexAppServerAdapter implements DispatchAdapter {
   }
 
   hasPendingInjections(sessionKey: string): boolean {
-    return (this.pendingInjections.get(sessionKey) ?? 0) > 0;
+    return this.injections.hasPending(sessionKey);
+  }
+
+  hasUnsettledInjections(sessionKey: string): boolean {
+    return this.injections.hasUnsettled(sessionKey);
+  }
+
+  acknowledgeDiscardedInjection(sessionKey: string, deliveryKey: string): void {
+    this.injections.markDrained(sessionKey, deliveryKey);
   }
 
   async *dispatch({
@@ -249,27 +266,12 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     bodyForAgent,
     sessionKey,
     context,
+    inputLifecycle,
     noteActivity,
   }: DispatchOpts): AsyncIterable<RuntimeEvent> {
-    const pending = this.pendingInjections.get(sessionKey) ?? 0;
-    if (pending > 0) {
-      this.pendingInjections.delete(sessionKey);
-      const threadId = this.opts.sessionManager.getThreadId(sessionKey);
-      if (threadId && this.client && !this.client.isDisposed()) {
-        (this.opts.log ?? context.log)?.info?.(
-          `${pending} steer injection(s) already sent; skipping turn/start`,
-        );
-        yield {
-          type: 'runtime_session',
-          runtimeSessionId: threadId,
-          runtimeLaneKey: sessionKey,
-        };
-        return;
-      }
-      (this.opts.log ?? context.log)?.warn?.(
-        `pending steer invalidated (subprocess died); falling through to normal dispatch`,
-      );
-    }
+    // This dispatch drains the injected copies it lists; it ALWAYS runs its own
+    // turn — never skipped on outstanding injections (PFB-84, injection-registry.ts).
+    if (inputLifecycle) this.injections.markDrained(sessionKey, inputLifecycle.deliveryKey);
 
     const isMainSession = this.opts.sessionManager.isMain(sessionKey);
     if (isMainSession && this.mainLaneQuarantined) {
@@ -552,6 +554,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       releasePreparedAttachments();
       this.activeTurns.delete(threadId!);
       this.activeTurnIds.delete(threadId!);
+      this.injections.settleAll(sessionKey); // the turn consumed (or lost) everything steered into it
       if (!sawTurnEnd) {
         sink.close();
       }
@@ -770,7 +773,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     this.client = null;
     this.initialized = false;
     this.activeTurnIds.clear();
-    this.pendingInjections.clear();
+    this.injections.clear();
     // Resume markers are process-local facts. Clear them HERE, synchronously:
     // the old child's close callback sees the replaced refs and skips its
     // cleanup as stale, so a marker surviving stop() would make the next
@@ -797,7 +800,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       }
       this.activeTurns.clear();
       this.activeTurnIds.clear();
-      this.pendingInjections.clear();
+      this.injections.clear();
       this.client = null;
       this.proc = null;
       this.initialized = false;
@@ -977,7 +980,7 @@ export class CodexAppServerAdapter implements DispatchAdapter {
     }
     this.activeTurns.clear();
     this.activeTurnIds.clear();
-    this.pendingInjections.clear();
+    this.injections.clear();
     this.resumedThreadIds.clear();
     this.instructionsRefresher.clearThreadState();
     this.mainLaneQuarantined = false;

package/src/injection-registry.ts

@@ -0,0 +1,100 @@
+/**
+ * Bookkeeping for mid-turn steer injections (`turn/steer`), per session key.
+ *
+ * Codex gives no per-input runtime receipt: a successful `turn/steer` only
+ * says the app-server accepted the text into the running turn. So each
+ * injection carries two independent facts with two different owners:
+ *
+ *   - settled — the turn it was steered into has ended (the adapter's own
+ *     dispatch() generator closing on turn/completed, an interrupt, or the
+ *     subprocess dying). Only an UNSETTLED injection may hold a lane's
+ *     complete open (DispatchAdapter.hasUnsettledInjections).
+ *   - drained — the gateway consumed the buffered copy that backs it: either
+ *     the already-rendered drain branch (acknowledgeDiscardedInjection) or a
+ *     group dispatch() whose inputLifecycle lists the WorkItem. Until then the
+ *     copy still owes frame-boundary bookkeeping (hasPendingInjections).
+ *
+ * Entries are keyed by WorkItem id — the deliveryKey the gateway uses on both
+ * sides — never counted. The pre-PFB-84 design kept a per-session COUNT and
+ * made the next dispatch() skip turn/start while it was non-zero: a copy the
+ * gateway discarded without a dispatch() never decremented it, so the count
+ * leaked onto the NEXT unrelated message, whose dispatch then ran no turn and
+ * was complete(ok)-swept as no_action — the model never saw it.
+ */
+export class CodexInjectionRegistry {
+  private readonly sessions = new Map<string, Map<string, InjectionState>>();
+
+  /** Record a successful steer. `deliveryKey` may join several WorkItem ids with ','. */
+  register(sessionKey: string, deliveryKey: string): void {
+    let entries = this.sessions.get(sessionKey);
+    if (!entries) {
+      entries = new Map();
+      this.sessions.set(sessionKey, entries);
+    }
+    for (const id of splitDeliveryKey(deliveryKey)) {
+      if (!entries.has(id)) entries.set(id, { settled: false, drained: false });
+    }
+  }
+
+  /** The buffered copies behind these WorkItems drained (group dispatch or discard). */
+  markDrained(sessionKey: string, deliveryKey: string): void {
+    const entries = this.sessions.get(sessionKey);
+    if (!entries) return;
+    for (const id of splitDeliveryKey(deliveryKey)) {
+      const entry = entries.get(id);
+      if (!entry) continue;
+      entry.drained = true;
+      if (entry.settled) entries.delete(id);
+    }
+    if (entries.size === 0) this.sessions.delete(sessionKey);
+  }
+
+  /** The turn every injection of this session was steered into has ended. */
+  settleAll(sessionKey: string): void {
+    const entries = this.sessions.get(sessionKey);
+    if (!entries) return;
+    for (const [id, entry] of entries) {
+      entry.settled = true;
+      if (entry.drained) entries.delete(id);
+    }
+    if (entries.size === 0) this.sessions.delete(sessionKey);
+  }
+
+  /** An injection whose buffered copy has not drained yet (bookkeeping owed). */
+  hasPending(sessionKey: string): boolean {
+    const entries = this.sessions.get(sessionKey);
+    if (!entries) return false;
+    for (const entry of entries.values()) {
+      if (!entry.drained) return true;
+    }
+    return false;
+  }
+
+  /** An injection whose turn is still running (the only state that may defer a complete). */
+  hasUnsettled(sessionKey: string): boolean {
+    const entries = this.sessions.get(sessionKey);
+    if (!entries) return false;
+    for (const entry of entries.values()) {
+      if (!entry.settled) return true;
+    }
+    return false;
+  }
+
+  /** Drop every entry (turn aborted / subprocess gone): nothing is owed anymore. */
+  clear(sessionKey?: string): void {
+    if (sessionKey === undefined) {
+      this.sessions.clear();
+      return;
+    }
+    this.sessions.delete(sessionKey);
+  }
+}
+
+type InjectionState = { settled: boolean; drained: boolean };
+
+function splitDeliveryKey(deliveryKey: string): string[] {
+  return deliveryKey
+    .split(',')
+    .map((id) => id.trim())
+    .filter((id) => id.length > 0);
+}