patchrelay 0.80.1 → 0.81.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.80.1",
-  "commit": "d2c60661d5fa",
-  "builtAt": "2026-06-10T22:15:08.651Z"
+  "version": "0.81.0",
+  "commit": "c1aa8b599ac8",
+  "builtAt": "2026-06-11T00:45:09.740Z"
 }

package/dist/codex-capacity.js

@@ -0,0 +1,42 @@
+// Classifies Codex turn failures that are capacity outages (account usage
+// limit, rate limit, quota) rather than evidence about the work itself.
+// A capacity failure must not consume repair budgets or escalate an issue —
+// the RunFailurePolicy defers the same wake behind a backoff instead
+// (see deferCapacityLimitedRun).
+// Known capacity phrasings. The real production string is
+// "You've hit your usage limit. Upgrade to Pro (...) or try again at 3:23 AM.";
+// rate-limit and quota phrasings are matched defensively for the API-key path.
+const CAPACITY_PATTERNS = [
+    /usage limit/i,
+    /rate limit/i,
+    /quota/i,
+];
+export function classifyCodexFailure(errorMessage, now = new Date()) {
+    const detail = errorMessage?.trim();
+    if (!detail)
+        return { kind: "other" };
+    if (!CAPACITY_PATTERNS.some((pattern) => pattern.test(detail))) {
+        return { kind: "other" };
+    }
+    const retryAtIso = parseRetryAt(detail, now);
+    return { kind: "capacity", detail, ...(retryAtIso ? { retryAtIso } : {}) };
+}
+// Parses "try again at 3:23 AM" into the NEXT such wall-clock time in the
+// host's local timezone (today if still ahead, otherwise tomorrow).
+function parseRetryAt(message, now) {
+    const match = /try again at (\d{1,2})(?::(\d{2}))?\s*([ap])\.?m\.?/i.exec(message);
+    if (!match)
+        return undefined;
+    const rawHour = Number(match[1]);
+    const minute = match[2] === undefined ? 0 : Number(match[2]);
+    if (rawHour < 1 || rawHour > 12 || minute > 59)
+        return undefined;
+    const isPm = match[3]?.toLowerCase() === "p";
+    const hour = (rawHour % 12) + (isPm ? 12 : 0);
+    const candidate = new Date(now);
+    candidate.setHours(hour, minute, 0, 0);
+    if (candidate.getTime() <= now.getTime()) {
+        candidate.setDate(candidate.getDate() + 1);
+    }
+    return candidate.toISOString();
+}

package/dist/db/issue-store.js

@@ -548,6 +548,9 @@ export function mapIssueRow(row) {
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
         zombieRecoveryAttempts: Number(row.zombie_recovery_attempts ?? 0),
         ...(row.last_zombie_recovery_at !== null && row.last_zombie_recovery_at !== undefined ? { lastZombieRecoveryAt: String(row.last_zombie_recovery_at) } : {}),
+        ...(row.capacity_backoff_until !== null && row.capacity_backoff_until !== undefined
+            ? { capacityBackoffUntil: String(row.capacity_backoff_until) }
+            : {}),
         ...(row.orchestration_settle_until !== null && row.orchestration_settle_until !== undefined
             ? { orchestrationSettleUntil: String(row.orchestration_settle_until) }
             : {}),

package/dist/db/issue-upsert-columns.js

@@ -70,6 +70,7 @@ export const ISSUE_COLUMN_DEFS = {
     reviewFixAttempts: { column: "review_fix_attempts", insertDefault: 0 },
     zombieRecoveryAttempts: { column: "zombie_recovery_attempts", insertDefault: 0 },
     lastZombieRecoveryAt: { column: "last_zombie_recovery_at" },
+    capacityBackoffUntil: { column: "capacity_backoff_until" },
     orchestrationSettleUntil: { column: "orchestration_settle_until" },
     deployStartedAt: { column: "deploy_started_at" },
 };

package/dist/db/migrations.js

@@ -369,6 +369,9 @@ export function runPatchRelayMigrations(connection) {
     // Optimistic-concurrency counter for issue-state writes (core
     // simplification plan, phase A). Bumped on every UPDATE by upsertIssue.
     addColumnIfMissing(connection, "issues", "version", "INTEGER NOT NULL DEFAULT 0");
+    // Codex capacity backoff: launches are deferred until this timestamp
+    // after a usage-limit / rate-limit / quota failure.
+    addColumnIfMissing(connection, "issues", "capacity_backoff_until", "TEXT");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/idle-reconciliation.js

@@ -579,6 +579,13 @@ export class IdleIssueReconciler {
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     ...buildPrStateUpdates(pr, gateCheckStatus, gateCheckNames[0] ?? "verify"),
+                    // A newly observed head is the poll-side equivalent of a lost
+                    // pr_synchronize: the webhook path resets the repair budgets for
+                    // the fresh head, so re-derivation must too — otherwise the new
+                    // head inherits the old head's consumed budget and escalates
+                    // earlier. Provenance clearing stays governed by
+                    // mayClearFailureProvenance at the advance sites below.
+                    ...(headAdvanced ? { ciRepairAttempts: 0, queueRepairAttempts: 0 } : {}),
                 },
             });
             // Continue the pass with the refreshed row so later version-checked

package/dist/run-budgets.js

@@ -44,3 +44,27 @@ export function getRemainingZombieRecoveryDelayMs(lastRecoveryAt, recoveryAttemp
     const delay = getZombieRecoveryDelayMs(recoveryAttempts);
     return Math.max(0, recoveredAtMs + delay - now);
 }
+// ─── Codex capacity backoff ──────────────────────────────────────────
+//
+// A run that failed on a Codex capacity outage (usage limit / rate limit /
+// quota) is re-enqueued, not escalated, and never consumes a repair budget.
+// The retry waits until the provider-announced retry time when one was
+// parsed from the error (plus a small jitter so a fleet of issues does not
+// stampede the moment the limit resets), else this fixed backoff.
+export const CAPACITY_RETRY_BACKOFF_MS = 10 * 60_000;
+const CAPACITY_RETRY_JITTER_MS = 60_000;
+export function resolveCapacityBackoffUntil(retryAtIso, now = Date.now(), jitterMs = Math.floor(Math.random() * CAPACITY_RETRY_JITTER_MS)) {
+    const retryAtMs = retryAtIso !== undefined ? Date.parse(retryAtIso) : Number.NaN;
+    const untilMs = Number.isFinite(retryAtMs) && retryAtMs > now
+        ? retryAtMs + jitterMs
+        : now + CAPACITY_RETRY_BACKOFF_MS;
+    return new Date(untilMs).toISOString();
+}
+export function getRemainingCapacityBackoffMs(capacityBackoffUntil, now = Date.now()) {
+    if (!capacityBackoffUntil)
+        return 0;
+    const untilMs = Date.parse(capacityBackoffUntil);
+    if (!Number.isFinite(untilMs))
+        return 0;
+    return Math.max(0, untilMs - now);
+}

package/dist/run-failure-policy.js

@@ -1,14 +1,16 @@
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
-import { getRemainingZombieRecoveryDelayMs, getZombieRecoveryBudget } from "./run-budgets.js";
+import { getRemainingZombieRecoveryDelayMs, getZombieRecoveryBudget, resolveCapacityBackoffUntil } from "./run-budgets.js";
+import { emitTelemetry, noopTelemetry } from "./telemetry.js";
 import { resolvePostRunFactoryState } from "./run-completion-policy.js";
 import { isRequestedChangesRunType } from "./reactive-pr-state.js";
 import { serializeRunContext } from "./run-context.js";
 import { settleRun } from "./run-settlement.js";
 const WRITER = "run-failure-policy";
-// Roll back the attempt counter consumed by the interrupted run and clear the
-// attempted-failure provenance for repair runs, as a single issue update so
-// the whole repair commits (and conflict-recomputes) atomically.
-function buildInterruptedAttemptRepairUpdate(runType, issue) {
+// Roll back the attempt counter consumed at launch and clear the
+// attempted-failure provenance for repair runs, so a run that died without
+// evidence about the work (interrupted turn, capacity outage) neither burns
+// a budget unit nor blocks the same failure from re-deriving a wake.
+function buildAttemptRefundFields(runType, issue) {
     const counter = runType === "ci_repair" && issue.ciRepairAttempts > 0
         ? { ciRepairAttempts: issue.ciRepairAttempts - 1 }
         : runType === "queue_repair" && issue.queueRepairAttempts > 0
@@ -25,11 +27,18 @@ function buildInterruptedAttemptRepairUpdate(runType, issue) {
         : undefined;
     if (!counter && !provenance)
         return undefined;
+    return { ...counter, ...provenance };
+}
+// The interrupted-run variant: same refund, committed as a single issue
+// update so the whole repair commits (and conflict-recomputes) atomically.
+function buildInterruptedAttemptRepairUpdate(runType, issue) {
+    const fields = buildAttemptRefundFields(runType, issue);
+    if (!fields)
+        return undefined;
     return {
         projectId: issue.projectId,
         linearIssueId: issue.linearIssueId,
-        ...counter,
-        ...provenance,
+        ...fields,
     };
 }
 function resolveRetryRunType(runType, context) {
@@ -63,7 +72,8 @@ export class RunFailurePolicy {
     completionPolicy;
     resolveProject;
     feed;
-    constructor(db, logger, linearSync, withHeldLease, releaseLease, appendWakeEventWithLease, wakeDispatcher, restoreIdleWorktree, completionPolicy, resolveProject, feed) {
+    telemetry;
+    constructor(db, logger, linearSync, withHeldLease, releaseLease, appendWakeEventWithLease, wakeDispatcher, restoreIdleWorktree, completionPolicy, resolveProject, feed, telemetry = noopTelemetry) {
         this.db = db;
         this.logger = logger;
         this.linearSync = linearSync;
@@ -75,6 +85,7 @@ export class RunFailurePolicy {
         this.completionPolicy = completionPolicy;
         this.resolveProject = resolveProject;
         this.feed = feed;
+        this.telemetry = telemetry;
     }
     // ─── Stranded runs (zombie / stale thread) ───────────────────────
     /**
@@ -233,6 +244,65 @@ export class RunFailurePolicy {
         this.wakeDispatcher.dispatchIfWakePending(fresh.projectId, fresh.linearIssueId);
         this.logger.info({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: re-enqueued with backoff");
     }
+    // ─── Capacity outages ────────────────────────────────────────────
+    /**
+     * A Codex capacity failure (usage limit / rate limit / quota) is not
+     * evidence that the work is impossible: settle the run as failed with the
+     * real error text, refund the attempt counter consumed at launch, return
+     * the issue to the state that routes the same work, and re-enqueue the
+     * same wake behind a capacity backoff — never a budget burn, never an
+     * escalation.
+     */
+    deferCapacityLimitedRun(params) {
+        const { run, capacity } = params;
+        const capacityBackoffUntil = resolveCapacityBackoffUntil(capacity.retryAtIso);
+        const deferred = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+            const settled = settleRun({
+                db: this.db,
+                run,
+                finish: {
+                    status: "failed",
+                    ...(params.threadId ? { threadId: params.threadId } : {}),
+                    ...(params.turnId ? { turnId: params.turnId } : {}),
+                    failureReason: params.failureReason,
+                },
+                lease,
+                buildIssueUpdate: (record) => ({
+                    ...buildAttemptRefundFields(run.runType, record),
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                    // The hold state that routes this work again, resolved from fresh
+                    // GitHub truth like the interrupted-run recovery path. Never a
+                    // terminal state: an unresolvable hold keeps the current one.
+                    factoryState: resolvePostRunFactoryState(record, run, { outcome: "recovered" })
+                        ?? (run.runType === "implementation" ? "delegated" : record.factoryState),
+                    capacityBackoffUntil,
+                }),
+            });
+            const wakeIssue = settled.issue ?? params.issue;
+            return this.appendWakeEventWithLease(lease, wakeIssue, run.runType, undefined, `capacity:${run.id}`);
+        });
+        this.linearSync.clearProgress(run.id);
+        if (!deferred) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping capacity deferral after losing issue-session lease");
+            this.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? params.issue;
+        this.logger.warn({ issueKey: issue.issueKey, runType: run.runType, detail: capacity.detail, capacityBackoffUntil }, "Codex capacity limit - deferring retry without consuming budget");
+        emitTelemetry(this.telemetry, {
+            type: "run.capacity_deferred",
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+            runId: run.id,
+            runType: run.runType,
+            detail: capacity.detail,
+            ...(capacity.retryAtIso ? { retryAtIso: capacity.retryAtIso } : {}),
+        });
+        void this.linearSync.syncSession(issue, { activeRunType: run.runType });
+        this.releaseLease(run.projectId, run.linearIssueId);
+    }
     // ─── Terminal decisions ──────────────────────────────────────────
     escalate(params) {
         const { issue, runType, reason } = params;

package/dist/run-notification-handler.js

@@ -1,5 +1,6 @@
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
-import { extractTurnId, resolveRunCompletionStatus } from "./run-reporting.js";
+import { buildFailedTurnFailureReason, extractTurnErrorMessage, extractTurnId, resolveRunCompletionStatus } from "./run-reporting.js";
+import { classifyCodexFailure } from "./codex-capacity.js";
 import { resolveFailureFactoryState } from "./reactive-pr-state.js";
 const WRITER = "run-notification-handler";
 const DEFAULT_PUBLISH_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
@@ -76,7 +77,25 @@ export class RunNotificationHandler {
         const completedTurnId = extractTurnId(notification.params);
         const status = resolveRunCompletionStatus(notification.params);
         if (status === "failed") {
-            const failureReason = "Codex reported the turn completed in a failed state";
+            const turnErrorMessage = extractTurnErrorMessage(notification.params);
+            const failureReason = buildFailedTurnFailureReason(turnErrorMessage);
+            // A capacity outage (usage limit / rate limit / quota) is not evidence
+            // about the work: defer the same wake behind a backoff instead of
+            // consuming an attempt budget or escalating. Only an actual error
+            // message classifies — interrupted turns stay on their own path.
+            const capacity = classifyCodexFailure(turnErrorMessage);
+            if (capacity.kind === "capacity" && this.options.deferCapacityLimitedRun) {
+                this.options.deferCapacityLimitedRun({
+                    run,
+                    issue,
+                    failureReason,
+                    capacity,
+                    threadId,
+                    ...(completedTurnId ? { turnId: completedTurnId } : {}),
+                });
+                this.activeThreadId = undefined;
+                return;
+            }
             const recovered = await this.runFinalizer.recoverFailedImplementationRun({
                 run,
                 issue,

package/dist/run-orchestrator.js

@@ -18,7 +18,7 @@ import { RunReconciler } from "./run-reconciler.js";
 import { RunWakePlanner } from "./run-wake-planner.js";
 import { WakeDispatcher } from "./wake-dispatcher.js";
 import { settleRun } from "./run-settlement.js";
-import { getRemainingZombieRecoveryDelayMs } from "./run-budgets.js";
+import { getRemainingCapacityBackoffMs, getRemainingZombieRecoveryDelayMs } from "./run-budgets.js";
 import { classifyIssue } from "./issue-class.js";
 import { buildIssueTriageHash, IssueTriageService } from "./issue-triage.js";
 import { loadConfig } from "./config.js";
@@ -129,8 +129,12 @@ export class RunOrchestrator {
         this.issueTriage = new IssueTriageService(codex, logger);
         this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.wakeDispatcher, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.recoveryPorts.failRunAndClear, this.runCompletionPolicy, this.completionCheck, feed);
         this.runLauncher = new RunLauncher(config, db, codex, logger, this.worktreeManager);
-        this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed, { interruptTurn: (options) => codex.interruptTurn(options) });
-        this.runFailurePolicy = new RunFailurePolicy(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.wakeDispatcher, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId) => this.config.projects.find((project) => project.id === projectId), feed);
+        this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed, {
+            interruptTurn: (options) => codex.interruptTurn(options),
+            // Lazy: the failure policy is constructed just below.
+            deferCapacityLimitedRun: (params) => this.runFailurePolicy.deferCapacityLimitedRun(params),
+        });
+        this.runFailurePolicy = new RunFailurePolicy(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.wakeDispatcher, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId) => this.config.projects.find((project) => project.id === projectId), feed, telemetry);
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.runFailurePolicy, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, feed, telemetry);
         this.runWakePlanner = new RunWakePlanner(db, logger);
         this.linearIssueProjection = new LinearIssueProjectionService(db, linearProvider, logger);
@@ -359,6 +363,16 @@ export class RunOrchestrator {
             this.releaseIssueSessionLease(item.projectId, item.issueId);
             return;
         }
+        // Codex capacity outage backoff: a usage-limit/rate-limit failure left a
+        // pending wake behind; the wake stays queued (the idle reconciler keeps
+        // re-poking it) and the launch waits until the backoff elapses.
+        const remainingCapacityDelayMs = getRemainingCapacityBackoffMs(issue.capacityBackoffUntil);
+        if (remainingCapacityDelayMs > 0) {
+            this.emitRunSkipped(item, "capacity_backoff", issue, { runType, remainingDelayMs: remainingCapacityDelayMs });
+            this.logger.debug({ issueKey: issue.issueKey, runType, remainingCapacityDelayMs }, "Deferring run launch until Codex capacity backoff elapses");
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
+            return;
+        }
         const baseContext = isRequestedChangesRunType(runType)
             ? await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context)
             : context;
@@ -488,8 +502,9 @@ export class RunOrchestrator {
             this.releaseIssueSessionLease(run.projectId, run.linearIssueId);
             return;
         }
-        // Reset zombie recovery counter — this run started successfully
-        if (issue.zombieRecoveryAttempts > 0) {
+        // Reset zombie recovery counter and capacity backoff — this run
+        // started successfully
+        if (issue.zombieRecoveryAttempts > 0 || issue.capacityBackoffUntil !== undefined) {
             this.db.issueSessions.commitIssueState({
                 writer: WRITER,
                 lease: { projectId: item.projectId, linearIssueId: item.issueId, leaseId },
@@ -498,6 +513,7 @@ export class RunOrchestrator {
                     linearIssueId: item.issueId,
                     zombieRecoveryAttempts: 0,
                     lastZombieRecoveryAt: null,
+                    capacityBackoffUntil: null,
                 },
             });
         }

package/dist/run-reconciler.js

@@ -3,6 +3,8 @@ import { TERMINAL_STATES } from "./factory-state.js";
 import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { getThreadTurns } from "./codex-thread-utils.js";
+import { classifyCodexFailure } from "./codex-capacity.js";
+import { buildFailedTurnFailureReason } from "./run-reporting.js";
 import { resolveEffectiveActiveRun } from "./effective-active-run.js";
 import { isThreadMaterializingError } from "./codex-thread-errors.js";
 import { fetchPullRequestSnapshot } from "./reconcile-pr-fetch.js";
@@ -213,6 +215,25 @@ export class RunReconciler {
             await this.failurePolicy.handleInterruptedRun(run, effectiveIssue);
             return;
         }
+        // A failed turn found during reconciliation (the live notification was
+        // lost, e.g. across a restart) whose error is a Codex capacity outage:
+        // defer the same wake instead of leaving the run dangling or burning a
+        // budget. Non-capacity failed turns keep the existing behavior — the
+        // notification path owns live settlement.
+        if (latestTurn?.status === "failed") {
+            const capacity = classifyCodexFailure(latestTurn.error?.message ?? undefined);
+            if (capacity.kind === "capacity") {
+                this.failurePolicy.deferCapacityLimitedRun({
+                    run,
+                    issue: effectiveIssue,
+                    failureReason: buildFailedTurnFailureReason(latestTurn.error?.message ?? undefined),
+                    capacity,
+                    threadId: run.threadId,
+                    ...(latestTurn.id ? { turnId: latestTurn.id } : {}),
+                });
+                return;
+            }
+        }
         if (latestTurn?.status === "completed") {
             await this.runFinalizer.finalizeCompletedRun({
                 source: "reconciliation",

package/dist/run-reporting.js

@@ -164,6 +164,26 @@ export function extractTurnId(params) {
     const id = turn.id;
     return typeof id === "string" ? id : undefined;
 }
+export const FAILED_TURN_FAILURE_REASON = "Codex reported the turn completed in a failed state";
+// Keeps the generic prefix (existing queries and tests key on it) and appends
+// the real Codex error so a capacity outage is distinguishable from a genuine
+// failure in the persisted run record.
+export function buildFailedTurnFailureReason(errorMessage) {
+    const trimmed = errorMessage?.trim();
+    return trimmed ? `${FAILED_TURN_FAILURE_REASON}: ${trimmed}` : FAILED_TURN_FAILURE_REASON;
+}
+export function extractTurnErrorMessage(params) {
+    const turn = params.turn;
+    if (!turn || typeof turn !== "object") {
+        return undefined;
+    }
+    const error = turn.error;
+    if (!error || typeof error !== "object") {
+        return undefined;
+    }
+    const message = error.message;
+    return typeof message === "string" && message.trim() ? message : undefined;
+}
 export function buildPendingMaterializationThread(stageRun, error) {
     return {
         id: stageRun.threadId ?? "pending-thread",

package/dist/telemetry.js

@@ -78,6 +78,19 @@ export class OperatorFeedTelemetrySink {
                     };
                 }
                 return undefined;
+            case "run.capacity_deferred":
+                return {
+                    level: "warn",
+                    kind: "workflow",
+                    ...(event.issueKey ? { issueKey: event.issueKey } : {}),
+                    ...(event.projectId ? { projectId: event.projectId } : {}),
+                    ...(event.runType ? { stage: event.runType } : {}),
+                    status: "capacity_deferred",
+                    summary: event.retryAtIso
+                        ? `Codex capacity limit; retrying ${event.runType ?? "run"} at ${event.retryAtIso}`
+                        : `Codex capacity limit; retrying ${event.runType ?? "run"} after backoff`,
+                    detail: event.detail,
+                };
             case "state.write_conflict":
                 return {
                     level: "warn",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.80.1",
+  "version": "0.81.0",
   "license": "MIT",
   "type": "module",
   "repository": {