@parall/codex-agent 1.58.1 → 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;
@@ -104,10 +104,13 @@ export declare class CodexAppServerAdapter implements DispatchAdapter {
         reasoningEffort?: string | null;
         developerInstructions?: string | null;
     }): void;
-    enqueueDuringDispatch(sessionKey: string, body: string): Promise<boolean>;
+    private threadConfigOverrides;
+    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":"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"}

package/dist/dispatch.js

@@ -5,9 +5,11 @@ 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';
+import { buildThreadConfigOverrides } from './thread-config.js';
 import { TurnSink } from './turn-sink.js';
 /**
  * Bridge driver backed by `codex app-server --listen stdio://`.
@@ -31,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();
@@ -104,7 +106,17 @@ export class CodexAppServerAdapter {
         if (config.developerInstructions !== undefined)
             this.opts.developerInstructions = config.developerInstructions ?? undefined;
     }
-    async enqueueDuringDispatch(sessionKey, body) {
+    threadConfigOverrides() {
+        return buildThreadConfigOverrides({
+            reasoningEffort: this.opts.reasoningEffort,
+            capabilityBinDir: this.opts.capabilityBinDir,
+            inheritedPath: process.env.PATH,
+        });
+    }
+    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;
@@ -120,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) {
@@ -129,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;
@@ -155,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
@@ -448,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();
             }
@@ -596,10 +605,9 @@ export class CodexAppServerAdapter {
             }
             if (this.opts.model)
                 forkParams.model = this.opts.model;
-            if (this.opts.reasoningEffort) {
-                // Raw config.toml key — see openThread for the snake_case rationale.
-                forkParams.config = { model_reasoning_effort: this.opts.reasoningEffort };
-            }
+            const threadConfig = this.threadConfigOverrides();
+            if (threadConfig)
+                forkParams.config = threadConfig;
             const result = await client.sendRequest('thread/fork', forkParams);
             const forkedThreadId = extractThreadId(result);
             if (!forkedThreadId) {
@@ -658,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
@@ -685,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;
@@ -849,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;
@@ -885,16 +893,14 @@ export class CodexAppServerAdapter {
         }
         if (this.opts.model)
             commonParams.model = this.opts.model;
-        if (this.opts.reasoningEffort) {
-            // The nested `config` object is raw config.toml overrides and keeps the
-            // TOML key names — `model_reasoning_effort` (snake_case) — unlike the
-            // typed top-level params (`approvalPolicy` / `sandbox`), which are
-            // camelCase. Empirically verified against both pinned CLI generations
-            // (0.133.0 and 0.144.1): the camelCase key is silently ignored
-            // (thread/start echoes reasoningEffort: null), the snake_case key is
-            // applied and echoed back.
-            commonParams.config = { model_reasoning_effort: this.opts.reasoningEffort };
-        }
+        // The nested `config` object is raw config.toml overrides and keeps TOML
+        // key names (for example model_reasoning_effort, allow_login_shell, and
+        // shell_environment_policy), unlike the typed camelCase top-level params.
+        // The reasoning key's casing is verified against pinned CLI generations;
+        // the shell policy is the official Codex config surface.
+        const threadConfig = this.threadConfigOverrides();
+        if (threadConfig)
+            commonParams.config = threadConfig;
         const method = opts.resumeId ? 'thread/resume' : 'thread/start';
         const params = opts.resumeId
             ? {

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/dist/thread-config.d.ts

@@ -0,0 +1,20 @@
+export type ThreadConfigOverrideOptions = {
+    reasoningEffort?: string;
+    capabilityBinDir?: string;
+    inheritedPath?: string;
+    platform?: NodeJS.Platform;
+};
+/**
+ * Build the raw config.toml overrides shared by thread start/resume/fork.
+ *
+ * Codex normally allows POSIX tools to use a login shell. On macOS,
+ * /etc/zprofile's path_helper (and an operator's own profile) can reorder PATH
+ * after the app-server inherited it, moving a globally-installed vendor CLI
+ * ahead of Parall's credential-broker pointer. Force non-login execution,
+ * disable profile-based command translation, and pin the already-resolved
+ * daemon PATH with the capability directory first. The daemon resolves the
+ * operator's runtime/tool PATH before spawning this bridge, so commands keep
+ * the same executable search path without a per-command profile reload.
+ */
+export declare function buildThreadConfigOverrides({ reasoningEffort, capabilityBinDir, inheritedPath, platform, }: ThreadConfigOverrideOptions): Record<string, unknown> | undefined;
+//# sourceMappingURL=thread-config.d.ts.map

package/dist/thread-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-config.d.ts","sourceRoot":"","sources":["../src/thread-config.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,2BAA2B,GAAG;IACxC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,QAA2B,GAC5B,EAAE,2BAA2B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAoBnE"}

package/dist/thread-config.js

@@ -0,0 +1,33 @@
+import * as path from 'node:path';
+/**
+ * Build the raw config.toml overrides shared by thread start/resume/fork.
+ *
+ * Codex normally allows POSIX tools to use a login shell. On macOS,
+ * /etc/zprofile's path_helper (and an operator's own profile) can reorder PATH
+ * after the app-server inherited it, moving a globally-installed vendor CLI
+ * ahead of Parall's credential-broker pointer. Force non-login execution,
+ * disable profile-based command translation, and pin the already-resolved
+ * daemon PATH with the capability directory first. The daemon resolves the
+ * operator's runtime/tool PATH before spawning this bridge, so commands keep
+ * the same executable search path without a per-command profile reload.
+ */
+export function buildThreadConfigOverrides({ reasoningEffort, capabilityBinDir, inheritedPath, platform = process.platform, }) {
+    const config = {};
+    if (reasoningEffort)
+        config.model_reasoning_effort = reasoningEffort;
+    // Windows shells do not have the POSIX login-profile reorder that this
+    // override addresses; the app-server process PATH already carries the .cmd
+    // pointer directory there.
+    if (capabilityBinDir && platform !== 'win32') {
+        const pathEntries = (inheritedPath ?? '')
+            .split(path.delimiter)
+            .filter((entry) => entry && entry !== capabilityBinDir);
+        const effectivePath = [capabilityBinDir, ...pathEntries].join(path.delimiter);
+        config.allow_login_shell = false;
+        config.shell_environment_policy = {
+            experimental_use_profile: false,
+            set: { PATH: effectivePath },
+        };
+    }
+    return Object.keys(config).length > 0 ? config : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/codex-agent",
-  "version": "1.58.1",
+  "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.1",
-    "@parall/sdk": "1.58.1",
-    "@parall/cli": "1.58.1"
+    "@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,
@@ -32,6 +34,7 @@ import {
 import { JsonRpcStdioClient } from './jsonrpc-client.js';
 import { answerServerRequest } from './server-requests.js';
 import type { CodexSessionManager } from './session-manager.js';
+import { buildThreadConfigOverrides } from './thread-config.js';
 import { TurnSink } from './turn-sink.js';
 
 type CodexAppServerAdapterOptions = Pick<
@@ -103,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>();
@@ -185,7 +188,21 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       this.opts.developerInstructions = config.developerInstructions ?? undefined;
   }
 
-  async enqueueDuringDispatch(sessionKey: string, body: string): Promise<boolean> {
+  private threadConfigOverrides(): Record<string, unknown> | undefined {
+    return buildThreadConfigOverrides({
+      reasoningEffort: this.opts.reasoningEffort,
+      capabilityBinDir: this.opts.capabilityBinDir,
+      inheritedPath: process.env.PATH,
+    });
+  }
+
+  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);
@@ -198,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)}`);
@@ -207,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);
@@ -232,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({
@@ -240,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) {
@@ -543,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();
       }
@@ -694,10 +706,8 @@ export class CodexAppServerAdapter implements DispatchAdapter {
         forkParams.developerInstructions = this.opts.developerInstructions;
       }
       if (this.opts.model) forkParams.model = this.opts.model;
-      if (this.opts.reasoningEffort) {
-        // Raw config.toml key — see openThread for the snake_case rationale.
-        forkParams.config = { model_reasoning_effort: this.opts.reasoningEffort };
-      }
+      const threadConfig = this.threadConfigOverrides();
+      if (threadConfig) forkParams.config = threadConfig;
       const result = await client.sendRequest('thread/fork', forkParams);
       const forkedThreadId = extractThreadId(result);
       if (!forkedThreadId) {
@@ -763,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
@@ -790,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;
@@ -970,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;
@@ -1009,16 +1019,13 @@ export class CodexAppServerAdapter implements DispatchAdapter {
       commonParams.developerInstructions = this.opts.developerInstructions;
     }
     if (this.opts.model) commonParams.model = this.opts.model;
-    if (this.opts.reasoningEffort) {
-      // The nested `config` object is raw config.toml overrides and keeps the
-      // TOML key names — `model_reasoning_effort` (snake_case) — unlike the
-      // typed top-level params (`approvalPolicy` / `sandbox`), which are
-      // camelCase. Empirically verified against both pinned CLI generations
-      // (0.133.0 and 0.144.1): the camelCase key is silently ignored
-      // (thread/start echoes reasoningEffort: null), the snake_case key is
-      // applied and echoed back.
-      commonParams.config = { model_reasoning_effort: this.opts.reasoningEffort };
-    }
+    // The nested `config` object is raw config.toml overrides and keeps TOML
+    // key names (for example model_reasoning_effort, allow_login_shell, and
+    // shell_environment_policy), unlike the typed camelCase top-level params.
+    // The reasoning key's casing is verified against pinned CLI generations;
+    // the shell policy is the official Codex config surface.
+    const threadConfig = this.threadConfigOverrides();
+    if (threadConfig) commonParams.config = threadConfig;
 
     const method = opts.resumeId ? 'thread/resume' : 'thread/start';
     const params: Record<string, unknown> = opts.resumeId

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);
+}

package/src/thread-config.ts

@@ -0,0 +1,47 @@
+import * as path from 'node:path';
+
+export type ThreadConfigOverrideOptions = {
+  reasoningEffort?: string;
+  capabilityBinDir?: string;
+  inheritedPath?: string;
+  platform?: NodeJS.Platform;
+};
+
+/**
+ * Build the raw config.toml overrides shared by thread start/resume/fork.
+ *
+ * Codex normally allows POSIX tools to use a login shell. On macOS,
+ * /etc/zprofile's path_helper (and an operator's own profile) can reorder PATH
+ * after the app-server inherited it, moving a globally-installed vendor CLI
+ * ahead of Parall's credential-broker pointer. Force non-login execution,
+ * disable profile-based command translation, and pin the already-resolved
+ * daemon PATH with the capability directory first. The daemon resolves the
+ * operator's runtime/tool PATH before spawning this bridge, so commands keep
+ * the same executable search path without a per-command profile reload.
+ */
+export function buildThreadConfigOverrides({
+  reasoningEffort,
+  capabilityBinDir,
+  inheritedPath,
+  platform = process.platform,
+}: ThreadConfigOverrideOptions): Record<string, unknown> | undefined {
+  const config: Record<string, unknown> = {};
+  if (reasoningEffort) config.model_reasoning_effort = reasoningEffort;
+
+  // Windows shells do not have the POSIX login-profile reorder that this
+  // override addresses; the app-server process PATH already carries the .cmd
+  // pointer directory there.
+  if (capabilityBinDir && platform !== 'win32') {
+    const pathEntries = (inheritedPath ?? '')
+      .split(path.delimiter)
+      .filter((entry) => entry && entry !== capabilityBinDir);
+    const effectivePath = [capabilityBinDir, ...pathEntries].join(path.delimiter);
+    config.allow_login_shell = false;
+    config.shell_environment_policy = {
+      experimental_use_profile: false,
+      set: { PATH: effectivePath },
+    };
+  }
+
+  return Object.keys(config).length > 0 ? config : undefined;
+}