tumwater 0.4.0 → 0.4.2

package/dist/src/agent/codex/codex-stream.js

@@ -10,12 +10,13 @@
  * state (the open tool calls, the turn's usage fallback, the unmapped native types seen), so
  * call it once per run. Unmapped native types, the distinct text of `error` items, and a
  * command abandoned at the end of its turn are recorded once each on the seam's optional
- * `warnings()` — src/agent/run-agent.ts forwards each as an `agent_unknown_event` warning
+ * `warnings()` — src/agent/run-stream.ts forwards each as an `agent_unknown_event` warning
  * after the run. `sessionId()` reports the thread id once `thread.started` has named it.
  */
 import { nonNegativeNumber, objectOrEmpty, parseJsonObject } from "../../files/json-object.js";
 import { boundText, outputLimits } from "../../pi-extension/bounded-output.js";
-import { secondsUntil } from "../../text/datetime.js";
+import { secondsUntilUnixStamp } from "../../text/datetime.js";
+import { SERVER_TRANSIENT_STATUS } from "../backend-traits.js";
 /** How codex wraps every shell command — the prefix to strip (with its quoting) so the
  * canonical `bash` call carries the model's own command, which suite-rerun detection matches. */
 const SHELL_WRAPPER = /^\/(?:bin\/)?(?:zsh|bash) -lc '(.*)'$/s;
@@ -25,9 +26,6 @@ const RECONNECT = /^Reconnecting\.\.\. (\d+)\/(\d+) /;
 /** The item types dropped silently, with no canonical event and no `warnings()` entry
  * (design §5's `item.*` row): `todo_list` and `web_search`. */
 const DROPPED_ITEM_TYPES = new Set(["todo_list", "web_search"]);
-/** HTTP status classes that mean a transient backend failure (shared with the claude and
- * codex classifiers' reading of `codex exec`'s JSON error). */
-const SERVER_STATUS = new Set([500, 502, 503, 504, 529]);
 /** Strip codex's `/bin/zsh -lc '<cmd>'` (or `bash -lc`) wrapper and its quoting, returning
  * the model's own command — the argument suite-rerun detection matches. Passes a command the
  * capture did not wrap through unchanged. */
@@ -45,31 +43,31 @@ export function windowTypeName(windowMinutes) {
         return "seven_day";
     return `${windowMinutes}_minute`;
 }
-/** One codex `error` item's distinct message → a run warning; repeated identical messages are
- * warned once (finding 11). */
-/** How a `turn.failed` error message classifies into the canonical `tumwaterKind` (and, for a
- * transient backend, its kind), trusted by `PiStreamParser` before its text regexes. The inner
- * `message` is a JSON string carrying `status` and `error.type` / `error.code` (finding 11).
- * Returns the canonical lines to emit beside the closing `message_end`: a rejected rate-limit
- * reading when the error names a used-up window. */
-function classifyTurnFailed(parsed) {
-    const kind = {};
+/** Read the `turn.failed` inner JSON's four deciding fields. The inner `message` is a JSON
+ * string carrying `status` and `error.type` / `error.code` (finding 11). */
+function readTurnFailedFields(parsed) {
     const error = objectOrEmpty(parsed.error);
-    const code = typeof error.code === "string" ? error.code : undefined;
-    const errType = typeof error.type === "string" ? error.type : undefined;
-    const message = typeof error.message === "string" ? error.message : typeof parsed.message === "string" ? parsed.message : undefined;
-    kind.errorMessage = message;
-    const status = nonNegativeNumber(parsed.status, undefined);
+    return {
+        code: typeof error.code === "string" ? error.code : undefined,
+        errType: typeof error.type === "string" ? error.type : undefined,
+        message: typeof error.message === "string" ? error.message : typeof parsed.message === "string" ? parsed.message : undefined,
+        status: nonNegativeNumber(parsed.status, undefined),
+    };
+}
+/** Owns the context-window arm: a `context_window_exceeded` code, or a 400 whose message names
+ * the context window, classifies as `contextExceeded`. */
+function isContextExceeded({ code, errType, message, status }) {
     // The context-window signal is tested BEFORE the generic 400 `invalid_request_error`
     // branch (as claude's classifyResult tests "prompt is too long" before CONFIG_STATUS): a
     // `context_window_exceeded` code, or a 400 whose message names the context window, is
     // `contextExceeded`, never `configError`.
     const namesContextWindow = (t) => t !== undefined &&
         /context window|context length|too long|exceeds? (the )?(model'?s )?context|prompt is too long/i.test(t);
-    if (code === "context_window_exceeded" || (status === 400 && errType === "invalid_request_error" && namesContextWindow(message))) {
-        kind.kind = "contextExceeded";
-        return kind;
-    }
+    return code === "context_window_exceeded" || (status === 400 && errType === "invalid_request_error" && namesContextWindow(message));
+}
+/** Owns the transient rate-limit arm: a `usage_limit_reached` / `rate_limit_exceeded` code or a
+ * 429 returns the rejected reading naming the used-up window, else undefined. */
+function rateLimitReading(parsed, { code, status }) {
     if (code === "usage_limit_reached" || code === "rate_limit_exceeded" || status === 429) {
         // Which window the account hit, from the error's own `rate_limit_reached_type` (else the
         // five-hour window, the one Plus exhausts first). The rejected reading's wait comes from
@@ -77,42 +75,75 @@ function classifyTurnFailed(parsed) {
         const minutes = nonNegativeNumber(parsed.rate_limit_reached_type, undefined);
         const named = typeof parsed.rate_limit_reached_type === "string" ? parsed.rate_limit_reached_type : undefined;
         const resetsAt = nonNegativeNumber(parsed.resets_at, undefined);
-        // secondsUntil folds the unix-seconds resets stamp (×1000 to epoch-ms), clamped at 0.
-        const retryAfter = resetsAt === undefined ? undefined : secondsUntil(resetsAt * 1000, Date.now());
-        kind.kind = "transientRateLimit";
-        kind.rateLimit = {
+        return {
             type: "rate_limit",
             rateLimitType: typeof named === "string" && /_minute$|_hour$|_day$/.test(named)
                 ? named
                 : windowTypeName(minutes ?? 300),
             status: "rejected",
             utilization: 1,
-            ...(resetsAt !== undefined ? { resetsAt } : {}),
-            ...(retryAfter !== undefined ? { retryAfterSeconds: retryAfter } : {}),
+            // secondsUntilUnixStamp folds the unix-seconds resets stamp to epoch-ms, clamped at 0.
+            ...(resetsAt === undefined
+                ? {}
+                : { resetsAt, retryAfterSeconds: secondsUntilUnixStamp(resetsAt, Date.now()) }),
         };
-        return kind;
     }
-    if (code === "usage_not_included") {
-        kind.kind = "configError";
+    return undefined;
+}
+/** Owns the used-up-account arm: `usage_not_included` is a permanent config error, never a
+ * transient retry. */
+function isUsageNotIncluded({ code }) {
+    return code === "usage_not_included";
+}
+/** Owns the server-status arm: any `SERVER_TRANSIENT_STATUS` is a transient backend. */
+function isTransientServer({ status }) {
+    return status !== undefined && SERVER_TRANSIENT_STATUS.has(status);
+}
+/** Owns the permanent-login arms: a reused/invalidated refresh token, a 401, and a 400
+ * `invalid_request_error` are permanent config errors. */
+function isPermanentLogin({ message, status, errType }) {
+    // A refresh-token failure and an absent/invalid login are permanent config errors, which
+    // the doctor names with the login command (design §5).
+    if (/refresh_token_reused|invalidated refresh token/i.test(message ?? ""))
+        return true;
+    if (status === 401)
+        return true;
+    if (status === 400 && errType === "invalid_request_error") {
+        // A 400 `invalid_request_error` names the model as unsupported on a ChatGPT account.
+        return true;
+    }
+    return false;
+}
+/** How a `turn.failed` error message classifies into the canonical `tumwaterKind` (and, for a
+ * transient backend, its kind), trusted by `PiStreamParser` before its text regexes. The inner
+ * `message` is a JSON string carrying `status` and `error.type` / `error.code` (finding 11).
+ * Returns the canonical lines to emit beside the closing `message_end`: a rejected rate-limit
+ * reading when the error names a used-up window. The body is an ordered composition; each arm
+ * lives in its named helper: `readTurnFailedFields` (the field reads), `isContextExceeded`,
+ * `rateLimitReading`, `isUsageNotIncluded`, `isTransientServer` and `isPermanentLogin`. */
+function classifyTurnFailed(parsed) {
+    const fields = readTurnFailedFields(parsed);
+    const kind = { errorMessage: fields.message };
+    if (isContextExceeded(fields)) {
+        kind.kind = "contextExceeded";
         return kind;
     }
-    if (status !== undefined && SERVER_STATUS.has(status)) {
-        kind.kind = "transientBackend";
-        kind.backendKind = "server";
+    const rateLimit = rateLimitReading(parsed, fields);
+    if (rateLimit !== undefined) {
+        kind.kind = "transientRateLimit";
+        kind.rateLimit = rateLimit;
         return kind;
     }
-    // A refresh-token failure and an absent/invalid login are permanent config errors, which
-    // the doctor names with the login command (design §5).
-    if (/refresh_token_reused|invalidated refresh token/i.test(message ?? "")) {
+    if (isUsageNotIncluded(fields)) {
         kind.kind = "configError";
         return kind;
     }
-    if (status === 401) {
-        kind.kind = "configError";
+    if (isTransientServer(fields)) {
+        kind.kind = "transientBackend";
+        kind.backendKind = "server";
         return kind;
     }
-    if (status === 400 && errType === "invalid_request_error") {
-        // A 400 `invalid_request_error` names the model as unsupported on a ChatGPT account.
+    if (isPermanentLogin(fields)) {
         kind.kind = "configError";
         return kind;
     }
@@ -185,187 +216,210 @@ export function codexTranslator(opts = {}) {
         }
         return out;
     };
+    /** The `thread.started` arm: announces the session and the agent start, or records the
+     * unmapped event once when the thread id is missing. */
+    const handleThreadStarted = (event) => {
+        const id = typeof event.thread_id === "string" ? event.thread_id : undefined;
+        if (id === undefined) {
+            recordEvent("thread.started");
+            return [];
+        }
+        sessionIdValue = id;
+        const out = [];
+        out.push(JSON.stringify({
+            type: "session",
+            id,
+            ...(cwd !== undefined ? { cwd } : {}),
+        }));
+        out.push(JSON.stringify({ type: "agent_start" }));
+        return out;
+    };
+    /** The `turn.completed` arm: folds the usage block and abandons the open calls. */
+    const handleTurnCompleted = (event) => {
+        sawTurnCompleted = true;
+        const usage = objectOrEmpty(event.usage);
+        turnUsage =
+            usage.input_tokens !== undefined || usage.output_tokens !== undefined
+                ? {
+                    input: nonNegativeNumber(usage.input_tokens, 0),
+                    cacheRead: nonNegativeNumber(usage.cached_input_tokens, 0),
+                    cacheWrite: nonNegativeNumber(usage.cache_write_input_tokens, 0),
+                    output: nonNegativeNumber(usage.output_tokens, 0),
+                }
+                : undefined;
+        return abandonOpenCalls();
+    };
+    /** The `turn.failed` arm: classifies the inner-JSON error and closes the turn. */
+    const handleTurnFailed = (event) => {
+        sawTurnFailed = true;
+        // The error message is itself a JSON string (finding 11); fall back to the held
+        // top-level error text when it is not.
+        const raw = typeof event.error === "object" && event.error !== null && !Array.isArray(event.error)
+            ? event.error.message
+            : undefined;
+        const inner = typeof raw === "string" ? parseJsonObject(raw) : undefined;
+        const cls = inner ? classifyTurnFailed(inner) : {};
+        const errorMessage = cls.errorMessage ?? (typeof raw === "string" ? raw : pendingFailureText);
+        const closes = abandonOpenCalls();
+        const message = { role: "assistant", content: [], stopReason: "error" };
+        if (errorMessage !== undefined)
+            message.errorMessage = errorMessage;
+        const end = {
+            type: "message_end",
+            message,
+            ...(cls.kind !== undefined ? { tumwaterKind: cls.kind } : {}),
+            ...(cls.backendKind !== undefined ? { backendKind: cls.backendKind } : {}),
+        };
+        if (cls.kind === "transientRateLimit" && typeof cls.rateLimit?.retryAfterSeconds === "number")
+            end.retryAfterSeconds = cls.rateLimit.retryAfterSeconds;
+        return [...(cls.rateLimit !== undefined ? [JSON.stringify(cls.rateLimit)] : []), ...closes, JSON.stringify(end)];
+    };
+    /** The top-level `error` arm: a reconnect text emits an `auto_retry_start`; any other
+     * message is held as the next `turn.failed`'s fallback text. */
+    const handleErrorLine = (event) => {
+        const message = typeof event.message === "string" ? event.message : undefined;
+        const reconnect = message === undefined ? undefined : RECONNECT.exec(message);
+        if (reconnect) {
+            return [
+                JSON.stringify({
+                    type: "auto_retry_start",
+                    attempt: Number(reconnect[1]),
+                    maxAttempts: Number(reconnect[2]),
+                    errorMessage: message,
+                }),
+            ];
+        }
+        // Other top-level `error` lines are not fatal (design §5): held as the fallback text
+        // for a following `turn.failed`.
+        if (message !== undefined)
+            pendingFailureText = message;
+        return [];
+    };
+    /** The `item.started`/`item.completed` arm: reads the item and delegates by type to the
+     * item handlers, dropping the silent types and warning once on the unknown tail. */
+    const handleItem = (event, started) => {
+        const item = objectOrEmpty(event.item);
+        const itemType = typeof item.type === "string" ? item.type : "unknown";
+        if (itemType === "command_execution")
+            return handleCommandItem(item, started);
+        if (itemType === "file_change")
+            return handleFileChangeItem(item, started);
+        if (itemType === "error")
+            return handleErrorItem(item);
+        if (itemType === "agent_message")
+            return handleAgentMessageItem(item);
+        if (DROPPED_ITEM_TYPES.has(itemType))
+            return [];
+        // mcp_tool_call / reasoning and any unknown item shape map to nothing canonical; a
+        // once-per-type warning only (design §5).
+        recordItem(item);
+        return [];
+    };
+    /** The `command_execution` item arm: opens or closes the bash call, capping the result. */
+    const handleCommandItem = (item, started) => {
+        const command = typeof item.command === "string" ? item.command : "";
+        const out = [];
+        if (started) {
+            const id = typeof item.id === "string" ? item.id : `cmd-${openCalls.size}`;
+            openCalls.set(id, "command_execution");
+            const inner = innerCommand(command);
+            out.push(JSON.stringify({
+                type: "message_end",
+                message: {
+                    role: "assistant",
+                    content: [{ type: "toolCall", id, name: "bash", arguments: { command: inner } }],
+                },
+            }));
+            out.push(JSON.stringify({
+                type: "tool_execution_start",
+                toolCallId: id,
+                toolName: "bash",
+                args: { command: inner },
+            }));
+        }
+        else {
+            const id = typeof item.id === "string" ? item.id : "";
+            openCalls.delete(id);
+            const aggregated = typeof item.aggregated_output === "string" ? item.aggregated_output : "";
+            const exitCode = nonNegativeNumber(item.exit_code, undefined);
+            out.push(JSON.stringify({
+                type: "tool_execution_end",
+                toolCallId: id,
+                isError: exitCode !== undefined ? exitCode !== 0 : item.status !== "completed",
+                result: boundText(aggregated, bashLimit),
+            }));
+        }
+        return out;
+    };
+    /** The `file_change` item arm: mirrors each change as an `edit` tool call. */
+    const handleFileChangeItem = (item, started) => {
+        const changes = Array.isArray(item.changes) ? item.changes.filter((c) => typeof c === "object" && c !== null) : [];
+        const id = typeof item.id === "string" ? item.id : "";
+        const out = [];
+        if (!started) {
+            const isError = typeof item.status === "string" && item.status !== "completed";
+            for (let i = 0; i < changes.length; i++) {
+                const callId = `${id}-${i}`;
+                openCalls.delete(callId);
+                out.push(JSON.stringify({ type: "tool_execution_end", toolCallId: callId, isError }));
+            }
+            return out;
+        }
+        const content = changes.map((c, i) => ({
+            type: "toolCall",
+            id: `${id}-${i}`,
+            name: "edit",
+            arguments: {
+                path: typeof c.path === "string" ? c.path : undefined,
+                kind: typeof c.kind === "string" ? c.kind : undefined,
+            },
+        }));
+        if (content.length === 0)
+            return out; // no changes to mirror, nothing else to emit
+        out.push(JSON.stringify({ type: "message_end", message: { role: "assistant", content } }));
+        for (let i = 0; i < content.length; i++) {
+            const callId = `${id}-${i}`;
+            openCalls.set(callId, "file_change");
+            out.push(JSON.stringify({
+                type: "tool_execution_start",
+                toolCallId: callId,
+                toolName: "edit",
+                args: content[i].arguments,
+            }));
+        }
+        return out;
+    };
+    /** The `item.type === "error"` arm: a non-fatal notice warned once per distinct message. */
+    const handleErrorItem = (item) => {
+        const message = typeof item.message === "string" ? item.message : undefined;
+        if (message !== undefined)
+            recordErrorItem(message);
+        return [];
+    };
+    /** The `agent_message` arm: the model's reply as one canonical `message_end`. */
+    const handleAgentMessageItem = (item) => {
+        const text = typeof item.text === "string" ? item.text : "";
+        return [
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "text", text }] },
+            }),
+        ];
+    };
     const translate = (line) => {
         const parsed = parseJsonObject(line);
         if (!parsed)
             return []; // Non-JSON noise on stdout; ignore, as pi's parser does.
         const event = parsed;
         const type = typeof event.type === "string" ? event.type : "unknown";
-        const out = [];
         switch (type) {
-            case "thread.started": {
-                const id = typeof event.thread_id === "string" ? event.thread_id : undefined;
-                if (id === undefined) {
-                    recordEvent(type);
-                    return [];
-                }
-                sessionIdValue = id;
-                out.push(JSON.stringify({
-                    type: "session",
-                    id,
-                    ...(cwd !== undefined ? { cwd } : {}),
-                }));
-                out.push(JSON.stringify({ type: "agent_start" }));
-                return out;
-            }
-            case "turn.started":
-                return [];
-            case "turn.completed": {
-                sawTurnCompleted = true;
-                const usage = objectOrEmpty(event.usage);
-                turnUsage =
-                    usage.input_tokens !== undefined || usage.output_tokens !== undefined
-                        ? {
-                            input: nonNegativeNumber(usage.input_tokens, 0),
-                            cacheRead: nonNegativeNumber(usage.cached_input_tokens, 0),
-                            cacheWrite: nonNegativeNumber(usage.cache_write_input_tokens, 0),
-                            output: nonNegativeNumber(usage.output_tokens, 0),
-                        }
-                        : undefined;
-                return abandonOpenCalls();
-            }
-            case "turn.failed": {
-                sawTurnFailed = true;
-                // The error message is itself a JSON string (finding 11); fall back to the held
-                // top-level error text when it is not.
-                const raw = typeof event.error === "object" && event.error !== null && !Array.isArray(event.error)
-                    ? event.error.message
-                    : undefined;
-                const inner = typeof raw === "string" ? parseJsonObject(raw) : undefined;
-                const cls = inner ? classifyTurnFailed(inner) : {};
-                const errorMessage = cls.errorMessage ?? (typeof raw === "string" ? raw : pendingFailureText);
-                const closes = abandonOpenCalls();
-                const message = { role: "assistant", content: [], stopReason: "error" };
-                if (errorMessage !== undefined)
-                    message.errorMessage = errorMessage;
-                const end = {
-                    type: "message_end",
-                    message,
-                    ...(cls.kind !== undefined ? { tumwaterKind: cls.kind } : {}),
-                    ...(cls.backendKind !== undefined ? { backendKind: cls.backendKind } : {}),
-                };
-                if (cls.kind === "transientRateLimit" && typeof cls.rateLimit?.retryAfterSeconds === "number")
-                    end.retryAfterSeconds = cls.rateLimit.retryAfterSeconds;
-                return [...(cls.rateLimit !== undefined ? [JSON.stringify(cls.rateLimit)] : []), ...closes, JSON.stringify(end)];
-            }
-            case "error": {
-                const message = typeof event.message === "string" ? event.message : undefined;
-                const reconnect = message === undefined ? undefined : RECONNECT.exec(message);
-                if (reconnect) {
-                    return [
-                        JSON.stringify({
-                            type: "auto_retry_start",
-                            attempt: Number(reconnect[1]),
-                            maxAttempts: Number(reconnect[2]),
-                            errorMessage: message,
-                        }),
-                    ];
-                }
-                // Other top-level `error` lines are not fatal (design §5): held as the fallback text
-                // for a following `turn.failed`.
-                if (message !== undefined)
-                    pendingFailureText = message;
-                return [];
-            }
+            case "thread.started": return handleThreadStarted(event);
+            case "turn.started": return [];
+            case "turn.completed": return handleTurnCompleted(event);
+            case "turn.failed": return handleTurnFailed(event);
+            case "error": return handleErrorLine(event);
             case "item.started":
-            case "item.completed": {
-                const item = objectOrEmpty(event.item);
-                const itemType = typeof item.type === "string" ? item.type : "unknown";
-                const started = type === "item.started";
-                if (itemType === "command_execution") {
-                    const command = typeof item.command === "string" ? item.command : "";
-                    if (started) {
-                        const id = typeof item.id === "string" ? item.id : `cmd-${openCalls.size}`;
-                        openCalls.set(id, "command_execution");
-                        const inner = innerCommand(command);
-                        out.push(JSON.stringify({
-                            type: "message_end",
-                            message: {
-                                role: "assistant",
-                                content: [{ type: "toolCall", id, name: "bash", arguments: { command: inner } }],
-                            },
-                        }));
-                        out.push(JSON.stringify({
-                            type: "tool_execution_start",
-                            toolCallId: id,
-                            toolName: "bash",
-                            args: { command: inner },
-                        }));
-                    }
-                    else {
-                        const id = typeof item.id === "string" ? item.id : "";
-                        openCalls.delete(id);
-                        const aggregated = typeof item.aggregated_output === "string" ? item.aggregated_output : "";
-                        const exitCode = nonNegativeNumber(item.exit_code, undefined);
-                        out.push(JSON.stringify({
-                            type: "tool_execution_end",
-                            toolCallId: id,
-                            isError: exitCode !== undefined ? exitCode !== 0 : item.status !== "completed",
-                            result: boundText(aggregated, bashLimit),
-                        }));
-                    }
-                    return out;
-                }
-                if (itemType === "file_change") {
-                    const changes = Array.isArray(item.changes) ? item.changes.filter((c) => typeof c === "object" && c !== null) : [];
-                    const id = typeof item.id === "string" ? item.id : "";
-                    if (!started) {
-                        const isError = typeof item.status === "string" && item.status !== "completed";
-                        for (let i = 0; i < changes.length; i++) {
-                            const callId = `${id}-${i}`;
-                            openCalls.delete(callId);
-                            out.push(JSON.stringify({ type: "tool_execution_end", toolCallId: callId, isError }));
-                        }
-                        return out;
-                    }
-                    const content = changes.map((c, i) => ({
-                        type: "toolCall",
-                        id: `${id}-${i}`,
-                        name: "edit",
-                        arguments: {
-                            path: typeof c.path === "string" ? c.path : undefined,
-                            kind: typeof c.kind === "string" ? c.kind : undefined,
-                        },
-                    }));
-                    if (content.length === 0)
-                        return out; // no changes to mirror, nothing else to emit
-                    out.push(JSON.stringify({ type: "message_end", message: { role: "assistant", content } }));
-                    for (let i = 0; i < content.length; i++) {
-                        const callId = `${id}-${i}`;
-                        openCalls.set(callId, "file_change");
-                        out.push(JSON.stringify({
-                            type: "tool_execution_start",
-                            toolCallId: callId,
-                            toolName: "edit",
-                            args: content[i].arguments,
-                        }));
-                    }
-                    return out;
-                }
-                if (itemType === "error") {
-                    // An error item is a non-fatal notice (finding 11); warned once per distinct message.
-                    const message = typeof item.message === "string" ? item.message : undefined;
-                    if (message !== undefined)
-                        recordErrorItem(message);
-                    return [];
-                }
-                if (itemType === "agent_message") {
-                    // The model's reply: one canonical `message_end` with one text block.
-                    const text = typeof item.text === "string" ? item.text : "";
-                    return [
-                        JSON.stringify({
-                            type: "message_end",
-                            message: { role: "assistant", content: [{ type: "text", text }] },
-                        }),
-                    ];
-                }
-                if (DROPPED_ITEM_TYPES.has(itemType))
-                    return [];
-                // mcp_tool_call / reasoning and any unknown item shape map to nothing canonical; a
-                // once-per-type warning only (design §5).
-                recordItem(item);
-                return [];
-            }
+            case "item.completed": return handleItem(event, type === "item.started");
             default:
                 recordEvent(type);
                 return [];

package/dist/src/agent/codex/{write-guard-hook.js → codex-write-guard-hook.js}

@@ -1,5 +1,6 @@
 /** The PreToolUse hook codex runs before each `apply_patch` in a team run (part 6/9 installs it
- * through `-c`): `node write-guard-hook.js` with codex's hook payload on stdin. To block the patch
+ * through `-c`): `node codex-write-guard-hook.js` with codex's hook payload on stdin. To block
+ * the patch
  * it prints a `deny` decision with the refusal as its reason, in the shape finding 5 showed codex
  * accepts: the model reads only the reason, so a denial by exit code would not carry it. It prints
  * nothing to let the patch run, and exits 0 either way. Any failure of its own (bad JSON, a throw)

package/dist/src/agent/codex/codex-write-guard.js

@@ -1,6 +1,6 @@
 /** codex's half of the write guard (src/agent/write-guard.ts holds the rule): a PreToolUse hook on
  * `apply_patch`, installed by part 6/9, refuses an `apply_patch` that writes under the team root
- * but outside the run's worktree. The entry point is write-guard-hook.ts beside this file.
+ * but outside the run's worktree. The entry point is codex-write-guard-hook.ts beside this file.
  *
  * Codex's hook takes no argument naming the worktree, unlike claude's: codex trusts a hook by a
  * hash of its whole definition, so a command constant per build needs one trust lookup, while a
@@ -63,11 +63,11 @@ export function tomlString(s) {
     return out + '"';
 }
 /** The codex write guard's definition: the PreToolUse hook on `apply_patch` that runs the
- * compiled write-guard-hook.js with this process's node, falling back to `node` on PATH when
+ * compiled codex-write-guard-hook.js with this process's node, falling back to `node` on PATH when
  * that binary has moved (as claude's and the notes shim do). The hook path resolves from this
  * module, so a staged build (.tumwater/build/<sha>) runs its own copy and gets its own hash. */
 export function codexWriteGuardDefinition(nodeBin = process.execPath) {
-    const hook = fileURLToPath(new URL("./write-guard-hook.js", import.meta.url));
+    const hook = fileURLToPath(new URL("./codex-write-guard-hook.js", import.meta.url));
     const command = `n=${shellQuote(nodeBin)}; [ -x "$n" ] || n=node; exec "$n" ${shellQuote(hook)}`;
     return { matcher: HOOK_MATCHER, command, timeout: HOOK_TIMEOUT_SECONDS };
 }