@bridge4dev/runner 0.42.0 → 0.44.1

package/dist/adapters/claude-usage.d.ts

@@ -4,7 +4,28 @@ export interface UsageRow {
     /** «Weekly · Fable» for a per-model row; absent for the plain ones. */
     label: string | null;
     percent: number;
+    /** When this window resets, ISO UTC — or null when the line did not say (#289). */
+    resetsAt: string | null;
 }
+/**
+ * `· resets Aug 19, 4pm (Europe/Berlin)` → `2026-08-19T14:00:00.000Z` (#289).
+ *
+ * Three things the text does not say and one it says oddly:
+ *
+ *  - **No year.** Taken as the one that lands NEAREST to `now`, which is what
+ *    carries a weekly window across the December/January seam. Deliberately not
+ *    «the nearest FUTURE one»: a five-hour window whose reset already passed is
+ *    a normal thing to read, and preferring the future throws it a year ahead.
+ *    A moment slightly in the past is honest — the panel says «resetting now»
+ *    and the next probe corrects it.
+ *  - **Minutes are optional** — the same output prints `4pm` and `4:20am`.
+ *  - **The zone is a NAME, not an offset.** It is used as written; assuming the
+ *    dev server's own zone is the exact bug #258 refused to accept.
+ *
+ * Forgiving by contract: anything unreadable is `null`, never a throw and never
+ * a guess. A percentage we can show beats a clock we invented.
+ */
+export declare function parseResetTail(tail: string, now?: Date): string | null;
 /**
  * Every percentage `/usage` printed, in the order it printed them.
  *
@@ -14,13 +35,23 @@ export interface UsageRow {
  *
  * Deliberately forgiving: a line we cannot read is skipped, never thrown over.
  */
-export declare function parseUsageText(text: string): UsageRow[];
+export declare function parseUsageText(text: string, now?: Date): UsageRow[];
 /**
  * Merge fresh percentages into the windows we already know about.
  *
- * The RESET TIME is never taken from here — whatever the event said stays. A
- * window the event has not mentioned yet is created so the first probe is not
- * wasted, with no clock on it until the event supplies one.
+ * The RESET TIME parsed here never OVERRIDES what the event said — the event is
+ * machine-readable and carries epoch seconds, the text carries whole minutes, so
+ * where both exist the event is simply the better number. It only FILLS a window
+ * the event has not dated, which since #289 is the ordinary case: the event
+ * describes one window per message (whichever is closest to its ceiling), so the
+ * other window would otherwise never get a clock at any percentage.
+ *
+ * This does not put a text-parsed time anywhere near the auto-pause alarm, and
+ * that is a property of the code, not a convention: the wake-up is scheduled
+ * exclusively from `blocked.resetsAt`, which `claude.ts` builds from the event's
+ * own epoch seconds and never reads back out of this map. #258's rule — a
+ * reworded CLI must never be able to move a wake-up — therefore still holds.
+ * `claude-usage.test.ts` pins it.
  */
 export declare function applyUsagePercentages(windows: AgentRateLimitWindow[], rows: UsageRow[]): AgentRateLimitWindow[];
 /**

package/dist/adapters/claude-usage.js

@@ -25,15 +25,116 @@ import { log } from '../log.js';
  *   Current week (all models): 50% used · resets Aug 19, 3:59pm (Europe/Berlin)
  *   Current week (Fable): 0% used
  */
-/** «Current session» is the five-hour window; every «Current week» is a weekly one. */
-const SESSION_LINE = /current session:\s*(\d+(?:\.\d+)?)%\s*used/i;
-const WEEK_LINE = /current week(?:\s*\(([^)]+)\))?:\s*(\d+(?:\.\d+)?)%\s*used/gi;
+/**
+ * «Current session» is the five-hour window; every «Current week» is a weekly one.
+ *
+ * Each pattern now also captures the REST of the line, because the reset time
+ * lives in its tail (#289) — see `parseResetTail`. `[^\n]*` and not `.*`: the
+ * text is multi-line and a greedy dot would swallow the following rows.
+ */
+const SESSION_LINE = /current session:\s*(\d+(?:\.\d+)?)%\s*used([^\n]*)/i;
+const WEEK_LINE = /current week(?:\s*\(([^)]+)\))?:\s*(\d+(?:\.\d+)?)%\s*used([^\n]*)/gi;
+/** `· resets Aug 19, 4pm (Europe/Berlin)` — minutes optional, year absent, zone named. */
+const RESET_TAIL = /resets\s+([A-Za-z]{3})\s+(\d{1,2}),\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(([^)]+)\)/i;
+const MONTHS = {
+    jan: 0,
+    feb: 1,
+    mar: 2,
+    apr: 3,
+    may: 4,
+    jun: 5,
+    jul: 6,
+    aug: 7,
+    sep: 8,
+    oct: 9,
+    nov: 10,
+    dec: 11,
+};
 const clamp = (raw) => {
     if (raw === undefined)
         return null;
     const value = Number(raw);
     return Number.isFinite(value) ? Math.min(100, Math.max(0, value)) : null;
 };
+/**
+ * A wall-clock moment in a NAMED zone → the instant it denotes.
+ *
+ * `Intl` can only go the other way, so this goes there and back: format the
+ * guess in the target zone, see how far the result drifted, and subtract that
+ * drift. One round-trip is enough because the offset we need is the one in
+ * force AT that moment, which is exactly what the formatter applied.
+ *
+ * Throws `RangeError` on a zone name it does not know — the caller turns that
+ * into «no clock», never into the runner's own zone (#258's «three different
+ * clocks» is the mistake this file must not repeat).
+ */
+function zonedToUtc(zone, year, month, day, hour, minute) {
+    const guess = Date.UTC(year, month, day, hour, minute);
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone: zone,
+        hour12: false,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    }).formatToParts(new Date(guess));
+    const at = {};
+    for (const part of parts)
+        at[part.type] = part.value;
+    const asZone = Date.UTC(Number(at['year']), Number(at['month']) - 1, Number(at['day']), 
+    // `hour12:false` renders midnight as 24 in some ICU versions; 24 % 24 = 0.
+    Number(at['hour']) % 24, Number(at['minute']), Number(at['second']));
+    return guess - (asZone - guess);
+}
+/**
+ * `· resets Aug 19, 4pm (Europe/Berlin)` → `2026-08-19T14:00:00.000Z` (#289).
+ *
+ * Three things the text does not say and one it says oddly:
+ *
+ *  - **No year.** Taken as the one that lands NEAREST to `now`, which is what
+ *    carries a weekly window across the December/January seam. Deliberately not
+ *    «the nearest FUTURE one»: a five-hour window whose reset already passed is
+ *    a normal thing to read, and preferring the future throws it a year ahead.
+ *    A moment slightly in the past is honest — the panel says «resetting now»
+ *    and the next probe corrects it.
+ *  - **Minutes are optional** — the same output prints `4pm` and `4:20am`.
+ *  - **The zone is a NAME, not an offset.** It is used as written; assuming the
+ *    dev server's own zone is the exact bug #258 refused to accept.
+ *
+ * Forgiving by contract: anything unreadable is `null`, never a throw and never
+ * a guess. A percentage we can show beats a clock we invented.
+ */
+export function parseResetTail(tail, now = new Date()) {
+    const match = RESET_TAIL.exec(tail);
+    if (!match)
+        return null;
+    const month = MONTHS[(match[1] ?? '').toLowerCase()];
+    if (month === undefined)
+        return null;
+    const day = Number(match[2]);
+    const minute = match[4] ? Number(match[4]) : 0;
+    const zone = (match[6] ?? '').trim();
+    let hour = Number(match[3]) % 12;
+    if ((match[5] ?? '').toLowerCase() === 'pm')
+        hour += 12;
+    try {
+        let best = null;
+        const year = now.getUTCFullYear();
+        for (const candidate of [year - 1, year, year + 1]) {
+            const at = zonedToUtc(zone, candidate, month, day, hour, minute);
+            if (best === null || Math.abs(at - now.getTime()) < Math.abs(best - now.getTime()))
+                best = at;
+        }
+        return best === null ? null : new Date(best).toISOString();
+    }
+    catch {
+        // Unknown zone name. No clock is the right answer; the runner's own zone
+        // would be a wrong one.
+        return null;
+    }
+}
 /**
  * Every percentage `/usage` printed, in the order it printed them.
  *
@@ -43,11 +144,18 @@ const clamp = (raw) => {
  *
  * Deliberately forgiving: a line we cannot read is skipped, never thrown over.
  */
-export function parseUsageText(text) {
+export function parseUsageText(text, now = new Date()) {
     const rows = [];
-    const session = clamp(SESSION_LINE.exec(text)?.[1]);
-    if (session !== null)
-        rows.push({ key: 'five_hour', label: null, percent: session });
+    const session = SESSION_LINE.exec(text);
+    const sessionPercent = clamp(session?.[1]);
+    if (sessionPercent !== null) {
+        rows.push({
+            key: 'five_hour',
+            label: null,
+            percent: sessionPercent,
+            resetsAt: parseResetTail(session?.[2] ?? '', now),
+        });
+    }
     WEEK_LINE.lastIndex = 0;
     for (let match = WEEK_LINE.exec(text); match !== null; match = WEEK_LINE.exec(text)) {
         const percent = clamp(match[2]);
@@ -56,16 +164,32 @@ export function parseUsageText(text) {
         const scope = (match[1] ?? '').trim();
         // «all models» IS the weekly window; anything else is that model's own.
         const isAll = scope === '' || /^all models$/i.test(scope);
-        rows.push({ key: 'seven_day', label: isAll ? null : `Weekly · ${scope}`, percent });
+        rows.push({
+            key: 'seven_day',
+            label: isAll ? null : `Weekly · ${scope}`,
+            percent,
+            // The per-model rows print no tail at all, so this is legitimately null.
+            resetsAt: parseResetTail(match[3] ?? '', now),
+        });
     }
     return rows;
 }
 /**
  * Merge fresh percentages into the windows we already know about.
  *
- * The RESET TIME is never taken from here — whatever the event said stays. A
- * window the event has not mentioned yet is created so the first probe is not
- * wasted, with no clock on it until the event supplies one.
+ * The RESET TIME parsed here never OVERRIDES what the event said — the event is
+ * machine-readable and carries epoch seconds, the text carries whole minutes, so
+ * where both exist the event is simply the better number. It only FILLS a window
+ * the event has not dated, which since #289 is the ordinary case: the event
+ * describes one window per message (whichever is closest to its ceiling), so the
+ * other window would otherwise never get a clock at any percentage.
+ *
+ * This does not put a text-parsed time anywhere near the auto-pause alarm, and
+ * that is a property of the code, not a convention: the wake-up is scheduled
+ * exclusively from `blocked.resetsAt`, which `claude.ts` builds from the event's
+ * own epoch seconds and never reads back out of this map. #258's rule — a
+ * reworded CLI must never be able to move a wake-up — therefore still holds.
+ * `claude-usage.test.ts` pins it.
  */
 export function applyUsagePercentages(windows, rows) {
     // Keyed by window AND label: a per-model weekly row is its own line, not an
@@ -79,9 +203,9 @@ export function applyUsagePercentages(windows, rows) {
             key: row.key,
             windowMinutes: existing?.windowMinutes ?? (row.key === 'five_hour' ? 300 : 10_080),
             usedPercent: row.percent,
-            // The clock stays whatever the machine-readable event said — this file
-            // never sets it, so a wording change here can never move a wake-up.
-            resetsAt: existing?.resetsAt ?? null,
+            // Event first, text second, nothing third. See the docblock above for why
+            // this ordering is the whole safety argument.
+            resetsAt: existing?.resetsAt ?? row.resetsAt ?? null,
             ...(existing?.status ? { status: existing.status } : {}),
             ...(row.label ? { label: row.label } : {}),
         });

package/dist/adapters/claude.js

@@ -6,7 +6,7 @@ import { log } from '../log.js';
 import { mcpConfigPath } from '../paths.js';
 import { evaluateToolUse, maskSecrets, maskString, } from '../policy.js';
 import { availableModes, MODE_REFUSED_TEXT, MODE_WITHDRAWN_TEXT, } from './types.js';
-import { clampPercent, RATE_WINDOW_MINUTES, rateWindowKey } from './rate-limits.js';
+import { percentFromUtilization, RATE_WINDOW_MINUTES, rateWindowKey } from './rate-limits.js';
 import { applyUsagePercentages, parseUsageText, probeUsageText } from './claude-usage.js';
 import { claudeCliPath } from '../agent-binary.js';
 /** How often `/usage` may be read. Free, but still a process. */
@@ -301,6 +301,35 @@ class ClaudeSession {
      * false, which is exactly the moment the meter needs a fresh number.
      */
     contextProbedAfterFirstReply = false;
+    /**
+     * What the CLI last said, in machine-readable form, about why this turn broke.
+     *
+     * Kept because the cause and the ending travel on different messages: the
+     * closed enum rides on `assistant.error`, and the `result` that ends the turn
+     * has no such field. Without stashing it, the supervisor would be left with a
+     * sentence — and a decision made from a sentence can be made by prose (#252).
+     *
+     * Reset per turn in `endTaskTurn`, which already owns the turn epoch.
+     */
+    turnFailureCode = null;
+    turnFailureStatus = null;
+    /**
+     * Did this turn put ANYTHING on the wire — text, thinking, or a tool call?
+     *
+     * The one fact that separates «send it again» from «resume it»: a 529 on the
+     * seventh request of a turn arrives after six rounds of tools have already
+     * run. Counted here rather than inferred from the error's wording, because
+     * the wording is prose and this is arithmetic.
+     */
+    turnProduced = false;
+    /**
+     * Did this turn run something a repeat cannot take back?
+     *
+     * Deliberately coarse: any git subcommand that writes, and any MCP tool call.
+     * Over-including costs a stop the person clears with one click; under-
+     * including costs a second `git push`.
+     */
+    turnIrreversible = false;
     mode;
     /**
      * A launch-time mode this workspace does not allow, remembered so the feed
@@ -421,6 +450,12 @@ class ClaudeSession {
      */
     resumingTurn() {
         this.aborting = false;
+        // #252: the same «every path that starts a turn» property makes this the one
+        // correct place to forget what the PREVIOUS turn did. Reset any earlier and
+        // `turn_end` would report facts that had already been wiped; any later — say,
+        // in `endTaskTurn` — and one turn's «work was done» would veto every
+        // subsequent retry for the life of the session.
+        this.beginTurnFacts();
     }
     events = this.output;
     constructor(spec, queryFn) {
@@ -701,6 +736,41 @@ class ClaudeSession {
     limitBlockPending = false;
     /** When `/usage` was last read, so a busy session does not spawn a process a second. */
     usageProbedAt = 0;
+    /**
+     * The one key the window map is written under, from every source.
+     *
+     * Live 2026-08-15: the event wrote under the provider's raw name
+     * (`five_hour`) while the `/usage` merge wrote under `five_hour:` — so the
+     * same window arrived twice, once with the clock and once with the number,
+     * and the panel drew both rows. One scheme, one row.
+     */
+    static windowKey(key, label) {
+        return `${key}:${label ?? ''}`;
+    }
+    /**
+     * May a window named by the provider write the plan-wide row?
+     *
+     * Only `five_hour` and the bare `seven_day` may. The other four names the CLI
+     * uses — `seven_day_opus`, `seven_day_sonnet`, `seven_day_overage_included`,
+     * `overage` — describe a SINGLE MODEL's slice of the week, and letting them in
+     * silently overwrote the plan-wide number: `rateWindowKey()` folds every
+     * `seven_day*` onto `seven_day` (correctly — they really are all seven days),
+     * and the map is keyed by that folded name, so «Opus this week» and «the week»
+     * were the same cell, last writer winning.
+     *
+     * They are dropped rather than given rows of their own, and that is deliberate.
+     * The event names a FAMILY SLUG (`seven_day_opus`); `/usage` names a MODEL
+     * (`Current week (Fable)` → «Weekly · Fable»). Nothing in either stream maps
+     * one onto the other, so labelling the event's window would draw a second row
+     * for a window that already has one — the exact double-row defect fixed in
+     * 0.42.1. The per-model rows come from `/usage`, which names them properly.
+     *
+     * Dropping them costs nothing else: they still prove a plan exists, and the
+     * refusal payload (#258) is built from the event's own fields, not from here.
+     */
+    static ownsPlanWindow(providerName) {
+        return providerName === 'five_hour' || providerName === 'seven_day';
+    }
     /**
      * Read the percentages out of the CLI's own `/usage` (#279).
      *
@@ -731,7 +801,7 @@ class ClaudeSession {
             const merged = applyUsagePercentages([...this.rateLimitWindows.values()], rows);
             this.rateLimitWindows.clear();
             for (const window of merged) {
-                this.rateLimitWindows.set(`${window.key}:${window.label ?? ''}`, window);
+                this.rateLimitWindows.set(ClaudeSession.windowKey(window.key, window.label), window);
             }
             this.emitRateLimits();
         })
@@ -779,17 +849,55 @@ class ClaudeSession {
             for (const [name, window] of Object.entries(limits)) {
                 if (!window || typeof window.utilization !== 'number')
                     continue;
+                // Per-model weekly windows are not rows of their own here — see
+                // `ownsPlanWindow` for why the plan-wide row must not be written by them.
+                if (!ClaudeSession.ownsPlanWindow(name))
+                    continue;
                 const key = rateWindowKey(name);
-                this.rateLimitWindows.set(name, {
+                this.rateLimitWindows.set(ClaudeSession.windowKey(key), {
                     key,
                     windowMinutes: RATE_WINDOW_MINUTES[key] ?? null,
-                    usedPercent: clampPercent(window.utilization),
+                    usedPercent: percentFromUtilization(window.utilization),
                     resetsAt: typeof window.resets_at === 'string' ? window.resets_at : null,
                 });
             }
         }
         this.emitRateLimits();
     }
+    /**
+     * The CLI is retrying an API call by itself (#252).
+     *
+     * Not a failure and not one of our attempts — the turn is still alive. Two
+     * things happen here. The cause is stashed, because if the CLI does eventually
+     * give up we will need a machine-readable reason and the `result` that ends the
+     * turn carries none. And the feed gets told, because «Working…» for four silent
+     * minutes while the provider is down is precisely what sent the owner to the
+     * terminal to find out what was going on.
+     */
+    onApiRetry(msg) {
+        const info = msg;
+        if (typeof info.error === 'string' && info.error)
+            this.turnFailureCode = info.error;
+        if (typeof info.error_status === 'number')
+            this.turnFailureStatus = info.error_status;
+        const attempt = typeof info.attempt === 'number' ? info.attempt : null;
+        const max = typeof info.max_retries === 'number' ? info.max_retries : null;
+        const delayMs = typeof info.retry_delay_ms === 'number' ? info.retry_delay_ms : null;
+        const status = typeof info.error_status === 'number' ? info.error_status : null;
+        // Throttled to the first attempt and then every third: a ten-step ladder
+        // would otherwise write ten lines into the feed for one hiccup. The first
+        // line is the one that answers «why is nothing happening».
+        if (attempt !== null && attempt !== 1 && attempt % 3 !== 0)
+            return;
+        const cause = status !== null ? `${status}` : (this.turnFailureCode ?? 'a network error');
+        const count = attempt !== null && max !== null ? ` ${attempt} of ${max}` : '';
+        const wait = delayMs !== null ? `, next in ${Math.round(delayMs / 1000)}s` : '';
+        this.emit({
+            type: 'notice',
+            level: 'info',
+            text: `The provider returned ${cause} — the CLI is retrying${count}${wait}`,
+        });
+    }
     onRateLimitEvent(msg) {
         const info = msg.rate_limit_info;
         if (!info || typeof info !== 'object')
@@ -817,14 +925,27 @@ class ClaudeSession {
         // Keep whatever the previous event said about the percentage: the field
         // comes and goes between events about the same window, and dropping it on
         // the next silent one would make a number that was true flicker away.
-        const known = this.rateLimitWindows.get(name);
-        this.rateLimitWindows.set(name, {
-            key,
-            windowMinutes: RATE_WINDOW_MINUTES[key] ?? null,
-            usedPercent: typeof utilization === 'number' ? clampPercent(utilization) : (known?.usedPercent ?? null),
-            resetsAt: resetsAt ?? known?.resetsAt ?? null,
-            status: typeof info['status'] === 'string' ? info['status'] : null,
-        });
+        //
+        // A per-model week (`seven_day_opus` and friends) is skipped entirely rather
+        // than folded onto the plan-wide row — `ownsPlanWindow` explains why. The
+        // refusal below is NOT skipped with it: a refusal is a refusal whichever
+        // window ran out, and #258's clock is built from this event's own `resetsAt`
+        // a line further down, never from the window map.
+        if (ClaudeSession.ownsPlanWindow(name)) {
+            const known = this.rateLimitWindows.get(ClaudeSession.windowKey(key));
+            this.rateLimitWindows.set(ClaudeSession.windowKey(key), {
+                key,
+                windowMinutes: RATE_WINDOW_MINUTES[key] ?? null,
+                // `utilization` is a FRACTION here, not a percentage — see
+                // `percentFromUtilization`. Reading it as a percentage showed a window
+                // at 95% as «1%» until the next `/usage` probe corrected it.
+                usedPercent: typeof utilization === 'number'
+                    ? percentFromUtilization(utilization)
+                    : (known?.usedPercent ?? null),
+                resetsAt: resetsAt ?? known?.resetsAt ?? null,
+                status: typeof info['status'] === 'string' ? info['status'] : null,
+            });
+        }
         if (refused)
             this.limitBlockPending = true;
         this.emitRateLimits(refused ? { key, resetsAt } : null);
@@ -1537,6 +1658,47 @@ class ClaudeSession {
         this.taskPublishedAt = 0;
         this.flushTasks();
     }
+    /**
+     * Forget what the LAST turn did, now that a new one is starting (#252).
+     *
+     * Separate from `endTaskTurn` on purpose: that one runs when a turn ENDS, and
+     * the failure facts have to survive until `turn_end` has been emitted with
+     * them. This runs when the next turn begins, which is the first moment they
+     * are safely stale. Getting this backwards would let one turn's «work was
+     * done» veto the next turn's retry forever.
+     */
+    beginTurnFacts() {
+        this.turnFailureCode = null;
+        this.turnFailureStatus = null;
+        this.turnProduced = false;
+        this.turnIrreversible = false;
+    }
+    /**
+     * Remember a tool call as work that happened, and judge whether it can be
+     * taken back.
+     *
+     * The irreversible list is short and blunt: a write to someone else's world.
+     * `git` read subcommands (`status`, `diff`, `log`, `show`) are excluded — the
+     * agent runs them constantly and treating them as irreversible would suppress
+     * nearly every retry.
+     */
+    noteToolUse(name, input) {
+        this.turnProduced = true;
+        if (this.turnIrreversible)
+            return;
+        // Anything reaching outside this machine through MCP: we cannot know what it
+        // did, so we must not assume it can be repeated.
+        if (name.startsWith('mcp__')) {
+            this.turnIrreversible = true;
+            return;
+        }
+        if (name !== 'Bash')
+            return;
+        const command = typeof input['command'] === 'string' ? input['command'] : '';
+        if (/\bgit\s+(commit|push|tag|merge|rebase|reset|revert|cherry-pick)\b/.test(command)) {
+            this.turnIrreversible = true;
+        }
+    }
     async onCanUseTool(toolName, input, opts) {
         // The agent's interactive question tool assumes a terminal picker. There is
         // none here — so the call is PARKED and the dashboard becomes the picker.
@@ -1963,6 +2125,23 @@ class ClaudeSession {
                                 });
                             }
                         }
+                        else if (msg.subtype === 'api_retry') {
+                            // #252. The CLI hit a retryable error and is ALREADY retrying it
+                            // itself — this is telemetry, not a failure. Two jobs here, and the
+                            // second matters more than the first:
+                            //
+                            //  - say so in the feed, because «Working…» for four silent minutes
+                            //    while the provider is down is the thing that made the owner
+                            //    open the CLI to find out what was happening;
+                            //  - record the cause and status, so if the CLI eventually gives up
+                            //    we already hold a machine-readable reason. The `result` that
+                            //    ends the turn carries no such field.
+                            //
+                            // Deliberately NOT counted as one of our attempts, and it must not
+                            // arm our timer: retrying on top of a retry multiplies the wait and
+                            // doubles the traffic aimed at a provider that is already unwell.
+                            this.onApiRetry(msg);
+                        }
                         else {
                             // Ticket #113: subagents, background shells and dynamic workflows.
                             this.onTaskMessage(msg);
@@ -2010,14 +2189,31 @@ class ClaudeSession {
                         // field as a subagent would blank the transcript of every session on
                         // that CLI, which is a far worse failure than one leaked report.
                         const fromSubagent = typeof msg.parent_tool_use_id === 'string';
+                        // #252: the machine-readable cause the runner used to discard. It is
+                        // a closed enum (`overloaded`, `server_error`, `billing_error`, …),
+                        // and it is the ONLY thing allowed to open the door to a retry —
+                        // the sentence beside it is prose and prose can be written by agents.
+                        const failure = msg.error;
+                        if (typeof failure === 'string' && failure)
+                            this.turnFailureCode = failure;
                         for (const block of msg.message.content) {
                             if (block.type === 'text' && !fromSubagent && block.text.trim()) {
+                                // An API-error message is the CLI TELLING us the turn broke, not
+                                // the agent producing work — counting it as output would make
+                                // every failure look partial and suppress every clean retry.
+                                if (failure === undefined)
+                                    this.turnProduced = true;
                                 this.emit({ type: 'message', role: 'assistant', text: truncate(block.text) });
                             }
                             else if (block.type === 'thinking' && !fromSubagent && block.thinking.trim()) {
+                                this.turnProduced = true;
                                 this.emit({ type: 'thinking', text: truncate(block.thinking, 8_000) });
                             }
                             else if (block.type === 'tool_use') {
+                                // Counted even from a subagent: a subagent's `git push` is still
+                                // a push, and this is about what the machine did, not about whose
+                                // prose belongs in the feed.
+                                this.noteToolUse(block.name, block.input);
                                 this.emit({
                                     type: 'tool',
                                     phase: 'use',
@@ -2111,6 +2307,16 @@ class ClaudeSession {
                                 ok: false,
                                 errorMessage: failure,
                                 ...(this.consumeLimitBlock() ? { limitBlocked: true } : {}),
+                                // #252: the cause and the ending arrive on different messages —
+                                // the closed enum rides on the assistant message, this `result`
+                                // has no such field. Handed over so the supervisor can decide
+                                // from a code rather than from the sentence in `errorMessage`.
+                                ...(this.turnFailureCode !== null ? { failureCode: this.turnFailureCode } : {}),
+                                ...(this.turnFailureStatus !== null
+                                    ? { failureStatus: this.turnFailureStatus }
+                                    : {}),
+                                ...(this.turnProduced ? { produced: true } : {}),
+                                ...(this.turnIrreversible ? { irreversible: true } : {}),
                             });
                             this.refreshUsage();
                         }

package/dist/adapters/codex.js

@@ -153,6 +153,16 @@ class CodexSession {
     threadId = null;
     threadModel = null;
     activeTurnId = null;
+    /**
+     * Did this turn put anything on the wire before it broke, and was any of it
+     * beyond taking back? (#252, #257)
+     *
+     * The Claude adapter counts the same two facts for the same reason: a failure
+     * that arrives after six rounds of tools cannot be answered by re-sending the
+     * turn. Reset in `beginTurnWork`, called wherever a turn starts.
+     */
+    turnProduced = false;
+    turnIrreversible = false;
     /**
      * Last turn this thread finished (ticket #126).
      *
@@ -1099,6 +1109,9 @@ class CodexSession {
             }
             case 'turn/started': {
                 this.activeTurnId = str(params['turnId']) ?? str(asRecord(params['turn'])['id']) ?? null;
+                // #252: Codex announces its turns, so this is the exact boundary. Any
+                // later and one turn's «work was done» would veto every retry after it.
+                this.beginTurnWork();
                 return;
             }
             case 'turn/completed': {
@@ -1276,6 +1289,8 @@ class CodexSession {
             case 'commandExecution': {
                 const command = str(item['command']) ?? '';
                 if (!done) {
+                    // #252/#257: what separates «send the turn again» from «resume it».
+                    this.noteWork(command);
                     this.emit({
                         type: 'tool',
                         phase: 'use',
@@ -1438,6 +1453,26 @@ class CodexSession {
      * calls a human instead. Guessing a time here is the one outcome worth
      * avoiding: waking early burns a retry and changes nothing.
      */
+    /** A new turn is starting — forget what the previous one did (#252). */
+    beginTurnWork() {
+        this.turnProduced = false;
+        this.turnIrreversible = false;
+    }
+    /**
+     * Record a command as work that happened, and judge whether it can be undone.
+     *
+     * The same blunt list as the Claude adapter: writing git subcommands only.
+     * Read-only git is excluded deliberately — the agent runs `git status` all day
+     * and treating that as a write would suppress nearly every retry.
+     */
+    noteWork(command) {
+        this.turnProduced = true;
+        if (this.turnIrreversible)
+            return;
+        if (/\bgit\s+(commit|push|tag|merge|rebase|reset|revert|cherry-pick)\b/.test(command)) {
+            this.turnIrreversible = true;
+        }
+    }
     rateLimitRefusal(error) {
         const haystack = JSON.stringify(error).toLowerCase();
         const refused = haystack.includes('ratelimitreached') ||
@@ -1472,6 +1507,13 @@ class CodexSession {
             const blocked = this.rateLimitRefusal(error);
             if (blocked)
                 this.emitRateLimits(blocked);
+            // #252: the machine-readable cause, beside the sentence. `codexErrorInfo`
+            // is Codex's own enum (`usageLimitExceeded`, `httpConnectionFailed`,
+            // `responseStreamConnectionFailed`, `contextWindowExceeded`, …) and it is
+            // the ONLY thing allowed to open the door to an automatic retry — the
+            // message next to it is prose, and prose can be written by agents.
+            const failureCode = str(error['codexErrorInfo']);
+            const failureStatus = error['httpStatusCode'];
             this.emit({
                 type: 'turn_end',
                 ok: false,
@@ -1480,6 +1522,10 @@ class CodexSession {
                 // one line earlier would ring into a dead row and throw the person's
                 // queued words away instead of sending them.
                 ...(blocked ? { limitBlocked: true } : {}),
+                ...(failureCode !== undefined ? { failureCode } : {}),
+                ...(typeof failureStatus === 'number' ? { failureStatus } : {}),
+                ...(this.turnProduced ? { produced: true } : {}),
+                ...(this.turnIrreversible ? { irreversible: true } : {}),
             });
             return;
         }