@agentex/agent 0.0.16 → 0.0.19

package/dist/providers/codex/session.js

@@ -1,11 +1,90 @@
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { findBinary } from "../../utils/binary.js";
 import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
 import { injectWorkspaceSkills } from "../../utils/skills.js";
 import { resolveInstructions } from "../../utils/instructions.js";
+import { createToolNameTracker } from "../../utils/tool-names.js";
 import { parseCodexStreamLine } from "./parse.js";
 import { withPlanModePreamble } from "./plan-mode.js";
 import { scanCodexSessionUsage } from "./usage-scanner.js";
+import { codexSessionCodec } from "./codec.js";
+import { parseCollaborationModes, resolveCollaborationModeParam } from "./modes.js";
+/**
+ * Extract a resume thread id from session params (reusing the codec's
+ * sessionId / session_id / thread_id alias handling), or null to start fresh.
+ */
+function readCodexResumeId(sessionParams) {
+    const decoded = codexSessionCodec.deserialize(sessionParams ?? null);
+    const id = decoded?.["sessionId"];
+    return typeof id === "string" && id.length > 0 ? id : null;
+}
+/** Pull and normalize the question list out of a `requestUserInput` params blob.
+ *  Tolerant of missing/extra fields — drops anything without an id and at least
+ *  a question or a header (Codex sometimes sends header-only prompts). */
+function parseCodexQuestions(params) {
+    const raw = Array.isArray(params["questions"]) ? params["questions"] : [];
+    const out = [];
+    for (const item of raw) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const q = item;
+        const id = typeof q["id"] === "string" ? q["id"] : "";
+        const questionText = typeof q["question"] === "string" ? q["question"] : "";
+        const header = typeof q["header"] === "string" ? q["header"] : "";
+        if (!id || (!questionText && !header))
+            continue;
+        // Fall back to the header as the prompt text so the bridged AskUserQuestion is
+        // never empty and the host can key its answer off the same `question` value.
+        const question = questionText || header;
+        const options = Array.isArray(q["options"])
+            ? q["options"]
+                .filter((o) => typeof o === "object" && o !== null)
+                .map((o) => ({
+                label: typeof o["label"] === "string" ? o["label"] : "",
+                ...(typeof o["description"] === "string" && o["description"]
+                    ? { description: o["description"] }
+                    : {}),
+            }))
+                .filter((o) => o.label.length > 0)
+            : [];
+        out.push({
+            id,
+            header,
+            question,
+            options,
+            ...(q["multiSelect"] === true ? { multiSelect: true } : {}),
+        });
+    }
+    return out;
+}
+function normalizeAnswerValues(raw) {
+    if (typeof raw === "string")
+        return raw.length > 0 ? [raw] : [];
+    if (Array.isArray(raw))
+        return raw.filter((v) => typeof v === "string" && v.length > 0);
+    return [];
+}
+/** Translate a host AskUserQuestion answer (keyed by question text or header)
+ *  into the Codex `requestUserInput` response shape:
+ *  `{ [questionId]: { answers: string[] } }`. A denied response yields {}. */
+function buildCodexUserInputAnswers(questions, resp) {
+    const out = {};
+    if (!resp.allow)
+        return out;
+    const updated = resp.updatedInput && typeof resp.updatedInput["answers"] === "object"
+        ? resp.updatedInput["answers"]
+        : null;
+    if (!updated)
+        return out;
+    for (const q of questions) {
+        const raw = updated[q.question] ?? updated[q.header];
+        const values = normalizeAnswerValues(raw);
+        if (values.length > 0)
+            out[q.id] = { answers: values };
+    }
+    return out;
+}
 // ---------------------------------------------------------------------------
 // JSON-RPC 2.0 helpers
 // ---------------------------------------------------------------------------
@@ -34,15 +113,23 @@ function asObj(parent, key) {
         : {};
 }
 function classifyMessage(msg) {
-    const isRpc = msg["jsonrpc"] === "2.0";
-    if (isRpc) {
-        const hasId = "id" in msg && (typeof msg["id"] === "number" || typeof msg["id"] === "string");
-        const hasMethod = "method" in msg && typeof msg["method"] === "string";
-        const id = typeof msg["id"] === "number" ? msg["id"] : parseInt(String(msg["id"]), 10);
+    // Detect JSON-RPC by *structure*, not by the `jsonrpc:"2.0"` discriminator.
+    // codex-cli 0.130.0's `app-server` emits responses without the `jsonrpc`
+    // field (technically non-compliant with the spec, but it's what ships).
+    // Heuristic: a message is JSON-RPC if it has any of (jsonrpc, id, method).
+    const hasJsonRpc = msg["jsonrpc"] === "2.0";
+    const hasId = "id" in msg && (typeof msg["id"] === "number" || typeof msg["id"] === "string");
+    const hasMethod = "method" in msg && typeof msg["method"] === "string";
+    const hasResult = "result" in msg;
+    const hasError = "error" in msg;
+    if (hasJsonRpc || hasId || hasMethod) {
+        const id = hasId
+            ? (typeof msg["id"] === "number" ? msg["id"] : parseInt(String(msg["id"]), 10))
+            : null;
         if (hasId && hasMethod) {
-            return { kind: "request", id, method: msg["method"], params: asObj(msg, "params") };
+            return { kind: "request", id: id, method: msg["method"], params: asObj(msg, "params") };
         }
-        if (hasId && !hasMethod) {
+        if (hasId && (hasResult || hasError)) {
             const errRaw = msg["error"];
             const error = typeof errRaw === "object" && errRaw !== null
                 ? { code: num(errRaw, "code"), message: str(errRaw, "message") }
@@ -50,12 +137,11 @@ function classifyMessage(msg) {
             const result = typeof msg["result"] === "object" && msg["result"] !== null
                 ? msg["result"]
                 : undefined;
-            return { kind: "response", id, result, error };
+            return { kind: "response", id: id, result, error };
         }
         if (hasMethod) {
             return { kind: "notification", method: msg["method"], params: asObj(msg, "params") };
         }
-        return null;
     }
     // Legacy NDJSON events (from `codex exec --json` format) — have a `type` field
     if (typeof msg["type"] === "string") {
@@ -88,15 +174,20 @@ export async function createCodexSession(ctx) {
     const instructions = config.planMode
         ? withPlanModePreamble(baseInstructions)
         : baseInstructions;
-    // Spawn Codex in interactive JSON-RPC mode.
-    // planMode and skipPermissions are mutually exclusive — planMode wins.
-    const args = [...resolved.prefixArgs, "--json"];
+    // Spawn Codex in interactive JSON-RPC mode via the `app-server` subcommand
+    // (codex-cli 0.130.0+; the old top-level `--json` flag was removed).
+    //
+    // Args order matters: `--sandbox` and `--dangerously-bypass-approvals-and-sandbox`
+    // are TOP-LEVEL options and must come BEFORE the `app-server` subcommand.
+    // extraArgs land after the subcommand — semantics depend on the user's intent.
+    const args = [...resolved.prefixArgs];
     if (config.planMode) {
         args.push("--sandbox", "read-only");
     }
     else if (config.skipPermissions) {
         args.push("--dangerously-bypass-approvals-and-sandbox");
     }
+    args.push("app-server");
     if (config.extraArgs)
         args.push(...config.extraArgs);
     const proc = spawn(resolved.bin, args, {
@@ -133,13 +224,29 @@ export class CodexSessionImpl {
     instructions;
     _state = "idle";
     _threadId = null;
+    /** Thread id to resume (from ctx.sessionParams); null starts a fresh thread. */
+    _resumeThreadId;
     _lineBuffer = "";
     _nextId = 1;
     // Pending outgoing RPC responses (keyed by request id)
     _pendingRpc = new Map();
-    // Active turn state
-    _turnResolve = null;
-    _turnReject = null;
+    // Pending result-resolvers. With concurrent send, multiple in-flight send()
+    // Promises may share a single result event (when the CLI coalesces them
+    // into one turn) or get distinct results across turns. On each
+    // turn.completed / turn.failed we drain the entire list — every pending
+    // Promise resolves with the same TurnResult.
+    _pendingResults = [];
+    /** Result Promises for sends that haven't settled, tracked so `drain()` can
+     *  await the in-flight turn(s) before closing. */
+    _inFlight = new Set();
+    /** Set by `drain()`: new `send()` calls are refused while true. */
+    _draining = false;
+    /** Shared promise so concurrent / repeated `drain()` calls coalesce. */
+    _drainPromise = null;
+    /** Stamps `tool_result.toolName` by correlating with prior `tool_call`s. */
+    _trackToolName = createToolNameTracker();
+    // Per-turn accumulators. Cleared after each result delivery so a subsequent
+    // turn's events don't inherit stale values.
     _turnSummary = null;
     _turnUsage = null;
     _turnModel = null;
@@ -159,6 +266,7 @@ export class CodexSessionImpl {
         this.cwd = cwd;
         this.model = model;
         this.instructions = instructions;
+        this._resumeThreadId = readCodexResumeId(ctx.sessionParams);
         proc.stdout.setEncoding("utf-8");
         proc.stdout.on("data", (chunk) => this.handleStdout(chunk));
         proc.stderr.setEncoding("utf-8");
@@ -174,30 +282,30 @@ export class CodexSessionImpl {
             if (this._state !== "closed") {
                 this._state = "closed";
                 const err = new Error(`Codex process exited unexpectedly (code=${code}, signal=${signal})`);
-                for (const [, pending] of this._pendingRpc)
-                    pending.reject(err);
-                this._pendingRpc.clear();
-                if (this._turnReject) {
-                    this._turnReject(err);
-                    this._turnResolve = null;
-                    this._turnReject = null;
-                }
+                this.rejectAllPending(err);
             }
         });
         proc.on("error", (err) => {
             if (this._state !== "closed") {
                 this._state = "closed";
-                for (const [, pending] of this._pendingRpc)
-                    pending.reject(err);
-                this._pendingRpc.clear();
-                if (this._turnReject) {
-                    this._turnReject(err);
-                    this._turnResolve = null;
-                    this._turnReject = null;
-                }
+                this.rejectAllPending(err);
             }
         });
     }
+    /** Reject every pending send() Promise and outgoing JSON-RPC call. */
+    rejectAllPending(err) {
+        const pending = this._pendingResults.splice(0);
+        for (const p of pending) {
+            if (p.settled)
+                continue;
+            p.settled = true;
+            p.cleanup?.();
+            p.reject(err);
+        }
+        for (const [, p] of this._pendingRpc)
+            p.reject(err);
+        this._pendingRpc.clear();
+    }
     get sessionId() { return this._threadId; }
     get state() { return this._state; }
     // -------------------------------------------------------------------------
@@ -225,42 +333,184 @@ export class CodexSessionImpl {
             clientInfo: { name: "agentex", version: "1.0.0" },
             capabilities: {},
         });
-        // 2. thread/start
+        // 2. Resume an existing thread when the caller supplied sessionParams,
+        //    otherwise start a fresh one. `thread/resume` continues the SAME thread
+        //    with its full context retained — distinct from `thread/fork`, which is
+        //    a divergent rewind copy. The thread keeps its original cwd/model, so we
+        //    pass only the thread id (+ refreshed developer instructions).
+        if (this._resumeThreadId) {
+            const resumeParams = { threadId: this._resumeThreadId };
+            if (this.instructions)
+                resumeParams["developerInstructions"] = this.instructions;
+            try {
+                const res = await this.rpcRequest("thread/resume", resumeParams);
+                const thread = asObj(res, "thread");
+                // thread/resume may echo the thread back or return {}; fall back to the
+                // id we resumed with so `sessionId` is always populated.
+                this._threadId = str(thread, "id") || str(thread, "sessionId") || this._resumeThreadId;
+                return;
+            }
+            catch (err) {
+                // The thread is unknown to this codex install (different machine, pruned
+                // history). Don't fail the whole session — fall back to a fresh thread
+                // and surface the downgrade on stderr. The new id flows back out via
+                // the next sessionParams snapshot so callers see the session changed.
+                if (this.ctx.onOutput) {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    try {
+                        void this.ctx.onOutput("stderr", `agentex: codex thread/resume failed for ${this._resumeThreadId}, starting a fresh thread: ${reason}\n`);
+                    }
+                    catch { /* swallow */ }
+                }
+            }
+        }
+        // thread/start (fresh)
         const threadParams = { cwd: this.cwd };
         if (this.model)
             threadParams["model"] = this.model;
         if (this.instructions)
             threadParams["developerInstructions"] = this.instructions;
+        // Apply a chosen collaboration mode (config.modeId) by resolving it against
+        // the live mode list. Only on fresh threads — a resumed thread keeps the
+        // mode it was created with. Mode discovery is advisory: a failure or an
+        // unknown id just falls through to the default mode.
+        const modeId = this.ctx.config?.modeId;
+        if (modeId) {
+            try {
+                // Bound the discovery RPC: an older app-server that ignores
+                // `collaborationMode/list` would otherwise hang the whole handshake.
+                const modesResponse = await Promise.race([
+                    this.rpcRequest("collaborationMode/list", {}),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("collaborationMode/list timed out")), 10_000)),
+                ]);
+                const collaborationMode = resolveCollaborationModeParam(parseCollaborationModes(modesResponse), modeId);
+                if (collaborationMode) {
+                    // Avoid sending instructions twice: the caller's top-level
+                    // `developerInstructions` wins, so drop the mode's copy.
+                    if (this.instructions)
+                        delete collaborationMode.settings["developer_instructions"];
+                    threadParams["collaborationMode"] = collaborationMode;
+                }
+            }
+            catch { /* modes are advisory — ignore discovery failures */ }
+        }
         const res = await this.rpcRequest("thread/start", threadParams);
-        this._threadId = str(res, "threadId") || str(res, "thread_id") || null;
+        // codex-cli 0.130.0+ shape: { thread: { id, sessionId, ... }, model, ... }
+        const thread = asObj(res, "thread");
+        this._threadId = str(thread, "id") || str(thread, "sessionId") || null;
     }
     // -------------------------------------------------------------------------
     // Public API
     // -------------------------------------------------------------------------
-    async send(message) {
+    async send(message, options) {
         if (this._state === "closed")
             throw new Error("Session is closed");
-        if (this._state !== "idle")
-            throw new Error("A turn is already in progress");
-        this._state = "thinking";
-        this._turnSummary = null;
-        this._turnUsage = null;
-        this._turnModel = null;
-        this._turnIsError = false;
-        this._turnErrorMessage = null;
-        this._turnStartedAt = new Date();
-        // Start a turn — the completion comes via notifications, not the RPC response
-        const turnParams = { input: message };
+        if (this._draining)
+            throw new Error("Session is draining — no new sends accepted");
+        // No protocol-level guard — Codex's TUI demonstrates queueing of user
+        // messages during an active turn, and our wire test (transcript
+        // 019e33c3) confirms two `user_message` events recorded across a
+        // long-running turn. We bet on the JSON-RPC layer queueing similarly
+        // and pass through. If the second `turn/start` lands during the first
+        // turn, the per-turn accumulators continue collecting until the result
+        // event fires; the result then drains all pending resolvers.
+        if (this._state === "idle") {
+            this._state = "thinking";
+            this._turnStartedAt = new Date();
+        }
+        // UUID is for API parity with Claude — Codex's JSON-RPC doesn't carry it
+        // through the wire protocol, so cancel(uuid) is a no-op for Codex.
+        const uuid = randomUUID();
+        // Start a turn — the completion comes via notifications, not the RPC response.
+        // codex-cli 0.130.0+ expects `input` as a content-block array, not a plain
+        // string. The MCP-style shape: [{type:"text", text:"..."}].
+        const turnParams = {
+            input: [{ type: "text", text: message }],
+        };
         if (this._threadId)
             turnParams["threadId"] = this._threadId;
+        let resolveFn;
+        let rejectFn;
+        const result = new Promise((resolve, reject) => {
+            resolveFn = resolve;
+            rejectFn = reject;
+        });
+        const entry = { resolve: resolveFn, reject: rejectFn };
+        this._pendingResults.push(entry);
+        // Track the in-flight turn so drain() can await it; drop it on settle.
+        this._inFlight.add(result);
+        void result.catch(() => { }).finally(() => this._inFlight.delete(result));
+        // Per-send timeout / abort, falling back to the session-level
+        // ProviderConfig.timeoutSec default when no per-call timeout is given.
+        this.armSendDeadline(entry, options);
         this.rpcRequest("turn/start", turnParams).catch(() => {
-            // Turn-level errors arrive via turn.failed notifications
+            // Turn-level errors arrive via turn.failed notifications.
         });
-        return new Promise((resolve, reject) => {
-            this._turnResolve = resolve;
-            this._turnReject = reject;
+        return { uuid, result };
+    }
+    /**
+     * Wire up this send's timeout and/or abort signal. On fire, the active turn
+     * is cancelled (`turn/cancel`) and the send settles with `timeout` /
+     * `aborted`. No-op when neither a timeout nor a signal applies.
+     */
+    armSendDeadline(entry, options) {
+        const timeoutSec = options?.timeoutSec ?? this.ctx.config?.timeoutSec;
+        const signal = options?.signal;
+        const hasTimeout = typeof timeoutSec === "number" && timeoutSec > 0;
+        if (!hasTimeout && !signal)
+            return;
+        if (signal?.aborted) {
+            queueMicrotask(() => this.settleEarly(entry, "aborted"));
+            return;
+        }
+        let timer;
+        const onAbort = () => this.settleEarly(entry, "aborted");
+        if (hasTimeout) {
+            timer = setTimeout(() => this.settleEarly(entry, "timeout"), timeoutSec * 1000);
+        }
+        if (signal)
+            signal.addEventListener("abort", onAbort, { once: true });
+        entry.cleanup = () => {
+            if (timer)
+                clearTimeout(timer);
+            if (signal)
+                signal.removeEventListener("abort", onAbort);
+        };
+    }
+    /**
+     * Settle a still-pending send early (timeout or abort). Cancels the active
+     * turn best-effort and resolves the send's `result` with a synthetic
+     * TurnResult. A no-op if the entry already settled (the real result raced
+     * ahead). The late real turn-completion later finds the entry already gone.
+     */
+    settleEarly(entry, kind) {
+        if (entry.settled)
+            return;
+        entry.settled = true;
+        entry.cleanup?.();
+        const idx = this._pendingResults.indexOf(entry);
+        if (idx >= 0)
+            this._pendingResults.splice(idx, 1);
+        // Best-effort cancel of the active turn. With concurrent sends this ends
+        // the single shared turn for all of them — see SendOptions JSDoc.
+        void this.interrupt();
+        entry.resolve({
+            summary: null,
+            usage: undefined,
+            costUsd: null,
+            status: kind,
+            errorCode: kind,
+            errorMessage: kind === "timeout"
+                ? "Turn exceeded its timeout and was interrupted"
+                : "Turn was aborted",
         });
     }
+    async cancel(_uuid) {
+        // Codex's JSON-RPC protocol exposes no per-message cancel — only
+        // turn-wide `turn/cancel` (which is what `interrupt()` calls).
+        // capabilities.cancelQueuedMessage is false; this is a documented no-op.
+        return { cancelled: false };
+    }
     async interrupt() {
         if (this._state === "idle" || this._state === "closed")
             return;
@@ -269,16 +519,34 @@ export class CodexSessionImpl {
         }
         catch { /* best effort */ }
     }
+    async drain() {
+        if (this._state === "closed")
+            return;
+        // Coalesce concurrent / repeated drains onto one promise.
+        if (this._drainPromise)
+            return this._drainPromise;
+        this._draining = true;
+        this._drainPromise = (async () => {
+            // Let every in-flight turn settle (resolve or reject) before closing, so
+            // a running tool finishes rather than being killed mid-flight.
+            await Promise.allSettled([...this._inFlight]);
+            await this.close();
+        })();
+        return this._drainPromise;
+    }
     async close() {
         if (this._state === "closed")
             return;
         this._state = "closed";
         this.proc.stdin.end();
+        // Grace window before SIGKILL is configurable via ProviderConfig.graceSec
+        // for sessions running long tools.
+        const graceSec = this.ctx.config?.graceSec ?? 5;
         await new Promise((resolve) => {
             const timeout = setTimeout(() => {
                 this.proc.kill("SIGKILL");
                 resolve();
-            }, 5000);
+            }, graceSec * 1000);
             this.proc.on("exit", () => {
                 clearTimeout(timeout);
                 resolve();
@@ -351,17 +619,35 @@ export class CodexSessionImpl {
             method === "item/fileChange/requestApproval") {
             void this.handleApproval(id, method, params);
         }
+        else if (method === "item/tool/requestUserInput" ||
+            method === "tool/requestUserInput") {
+            // `tool/requestUserInput` is the legacy method name on older codex builds.
+            void this.handleUserInputRequest(id, params);
+        }
         else {
-            // Unknown server request — ack to unblock
+            // Unknown server request — ack to unblock the turn.
             this.rpcResponse(id, {});
         }
     }
+    /**
+     * Leave a waiting-for-input/approval state correctly. A slow host handler can
+     * resolve after the turn already ended (deliverTurnResult → idle), so restore
+     * to `thinking` only when a turn is still in flight, else `idle` — never clobber
+     * a finished turn back to `thinking`.
+     */
+    restoreStateAfter(waitingState) {
+        if (this._state !== waitingState)
+            return;
+        this._state = this._pendingResults.length > 0 ? "thinking" : "idle";
+    }
     async handleApproval(id, method, params) {
         this._state = "waiting_for_approval";
+        // Codex's app-server expects `{ decision: "accept" | "decline" | "cancel" }`
+        // (NOT `{ approved: boolean }`). agentex's UserInputResponse has no interrupt
+        // concept, so allow → accept and deny → decline.
         if (!this.ctx.onUserInputRequest) {
-            this.rpcResponse(id, { approved: true });
-            if (this._state === "waiting_for_approval")
-                this._state = "thinking";
+            this.rpcResponse(id, { decision: "accept" });
+            this.restoreStateAfter("waiting_for_approval");
             return;
         }
         const toolName = method === "item/commandExecution/requestApproval"
@@ -374,13 +660,43 @@ export class CodexSessionImpl {
                 toolUseId: str(params, "id"),
                 description: str(params, "command") || str(params, "path") || undefined,
             });
-            this.rpcResponse(id, { approved: resp.allow });
+            this.rpcResponse(id, { decision: resp.allow ? "accept" : "decline" });
         }
         catch {
-            this.rpcResponse(id, { approved: false });
+            this.rpcResponse(id, { decision: "decline" });
         }
-        if (this._state === "waiting_for_approval")
-            this._state = "thinking";
+        this.restoreStateAfter("waiting_for_approval");
+    }
+    /**
+     * Handle a Codex `requestUserInput` server→client request: the agent is asking
+     * the user one or more structured questions. Maps onto the cross-provider
+     * AskUserQuestion shape so callers reuse `parseAskUserQuestion`, then answers
+     * back in Codex's `{ answers: { [questionId]: { answers: string[] } } }` shape.
+     */
+    async handleUserInputRequest(id, params) {
+        // Questions are user *input*, not a tool-permission gate — distinct state so a
+        // host UI can render a question form vs an approval prompt.
+        this._state = "waiting_for_input";
+        const questions = parseCodexQuestions(params);
+        // No host handler, or nothing answerable → return empty answers so the
+        // agent proceeds without hanging.
+        if (!this.ctx.onUserInputRequest || questions.length === 0) {
+            this.rpcResponse(id, { answers: {} });
+            this.restoreStateAfter("waiting_for_input");
+            return;
+        }
+        try {
+            const resp = await this.ctx.onUserInputRequest({
+                toolName: "AskUserQuestion",
+                input: { questions },
+                toolUseId: str(params, "id") || "codex-user-input",
+            });
+            this.rpcResponse(id, { answers: buildCodexUserInputAnswers(questions, resp) });
+        }
+        catch {
+            this.rpcResponse(id, { answers: {} });
+        }
+        this.restoreStateAfter("waiting_for_input");
     }
     // -------------------------------------------------------------------------
     // Notification handling (v2 format)
@@ -399,7 +715,9 @@ export class CodexSessionImpl {
         }
         // Map v2 notification methods to processing
         if (method === "thread/started") {
-            this._threadId = str(params, "threadId") || str(params, "thread_id") || this._threadId;
+            // codex-cli 0.130.0+ shape: { thread: { id, sessionId, ... } }
+            const thread = asObj(params, "thread");
+            this._threadId = str(thread, "id") || str(thread, "sessionId") || this._threadId;
             this.emitStreamEvent(rawLine);
             return;
         }
@@ -540,7 +858,15 @@ export class CodexSessionImpl {
         let usage = this._turnUsage && resolvedModel
             ? { [resolvedModel]: { inputTokens: this._turnUsage.inputTokens, outputTokens: this._turnUsage.outputTokens } }
             : undefined;
-        // If no usage from the stream, try scanning session logs
+        // Usage precedence: the `turn.completed` payload is authoritative when
+        // present (captured above into _turnUsage). Only when the stream carried no
+        // usage do we fall back to scanning Codex's on-disk session logs.
+        //
+        // RACINESS: the disk scan is best-effort and inherently racy — the rollout
+        // file may still be flushing when we read it, so a fallback scan can miss the
+        // latest turn or read partially-written totals. We therefore scan ONLY when
+        // there is no in-band usage, and never let a scan failure fail the turn
+        // (usage simply stays undefined). Prefer the in-band payload always.
         if (!usage && this._turnStartedAt) {
             const startedAt = this._turnStartedAt;
             const threadId = this._threadId ?? undefined;
@@ -578,11 +904,24 @@ export class CodexSessionImpl {
         if (this._state === "closed")
             return;
         this._state = "idle";
-        if (this._turnResolve) {
-            const resolve = this._turnResolve;
-            this._turnResolve = null;
-            this._turnReject = null;
-            resolve(result);
+        // Drain ALL pending send() resolvers with this turn's result. Multiple
+        // concurrent sends coalesced into one turn share the same TurnResult.
+        const pending = this._pendingResults.splice(0);
+        // Clear per-turn accumulators so a subsequent turn doesn't inherit
+        // stale summary / usage / model.
+        this._turnSummary = null;
+        this._turnUsage = null;
+        this._turnModel = null;
+        this._turnIsError = false;
+        this._turnErrorMessage = null;
+        this._turnStartedAt = null;
+        for (const p of pending) {
+            // Skip sends already settled early by timeout / abort.
+            if (p.settled)
+                continue;
+            p.settled = true;
+            p.cleanup?.();
+            p.resolve(result);
         }
     }
     emitStreamEvent(rawLine) {
@@ -605,9 +944,12 @@ export class CodexSessionImpl {
         const cb = this.ctx.onEvent;
         if (!cb)
             return;
+        // Enrich synchronously (in stream order) so tool_result events carry the
+        // name of the tool_call they answer.
+        const enriched = this._trackToolName(event);
         this._eventChain = this._eventChain.then(async () => {
             try {
-                await cb(event);
+                await cb(enriched);
             }
             catch { /* swallow */ }
         });