charness 0.0.0-stage → 3.0.0

package/dist/apiErrorRetry.d.ts

@@ -0,0 +1,209 @@
+/**
+ * @description Pure decision layer for the auto-retry-after-API-error feature
+ * (plan `agent/tasks/actual/2026-06-09-api-error-auto-retry.md`, S1). No I/O and
+ * no `Date.now()` inside: every caller passes `now` so the module is fully
+ * deterministic and unit-testable on a fixed clock.
+ *
+ * Two responsibilities:
+ *  - {@link classifyAgentApiError} — read a terminal error string and decide
+ *    whether (and how) it should be auto-retried. ORDER MATTERS (see the fn doc).
+ *  - {@link getRetryPlan} — given a class + the current attempt, decide the next
+ *    backoff delay or that we should give up.
+ *
+ * The same classifier serves BOTH backends: Claude surfaces the provider's
+ * "API Error" line in its TUI pane; OpenCode surfaces the same provider text
+ * through `session.error`.
+ */
+import type { AgentApiErrorClass } from './types';
+/**
+ * Transient backoff schedule (one entry per attempt): attempt 1 → 5m,
+ * 2 → 10m, 3 → 20m. After the last entry the retry gives up.
+ */
+export declare const transientBackoffMinutes: readonly [5, 10, 20];
+/** Max transient attempts before giving up (= `transientBackoffMinutes.length`). */
+export declare const transientMaxAttempts: 3;
+/**
+ * Fixed delay for a usage-limit error whose text exposed no reset time (the
+ * common case for Claude's "blocked" message): 60 minutes, re-armed on each
+ * repeat until {@link usageLimitMaxAttempts}.
+ */
+export declare const usageLimitDefaultMs: number;
+/** Max usage-limit attempts before giving up (~6h with the default delay). */
+export declare const usageLimitMaxAttempts = 6;
+/**
+ * Grace window after a retry fires: another API error within this window counts
+ * as the SAME error episode (escalate to attempt+1, longer backoff); an error
+ * later than this is a FRESH episode (reset to attempt 1). Decouples the
+ * decision from session-end events — a recovered turn just leaves a stale record
+ * that the next, much-later error resets to attempt 1.
+ */
+export declare const retryRecurrenceGraceMs: number;
+/**
+ * Padding added to a parsed reset time so the retry fires just AFTER the window
+ * actually rolls over, never a hair before it (which would re-error instantly).
+ */
+export declare const resetBufferMs = 60000;
+/**
+ * @description The auth / logged-out phrases (`please run /login`, `not logged
+ * in`, `invalid authentication credentials`). Shared with the Claude scrape
+ * detector (`getClaudeAgentErrorLine`) so the two never drift. NOT global — used
+ * with `.test()`, so lastIndex never carries between calls.
+ */
+export declare const authErrorPhrasesRe: RegExp;
+/**
+ * @description Alternation SOURCE (no anchors, no flags) of the explicit
+ * usage/session-limit wordings — {@link usageWindowPhrases} plus a bare
+ * `limit reached`. Exported as a source string — not just a compiled
+ * regex — because the Claude scrape detector (`getClaudeAgentErrorLine`) has to
+ * ANCHOR the same phrases at the start of a pane row, and a single source keeps
+ * the two from drifting (the `authErrorPhrasesRe` precedent).
+ */
+export declare const usageLimitPhraseSource: string;
+/** {@link usageLimitPhraseSource} compiled for a whole-text `.test()`. */
+export declare const usageLimitPhrasesRe: RegExp;
+/**
+ * @description Whether an error text is a usage / session / window limit.
+ *
+ * Two tiers, and the second one is the point: the explicit
+ * {@link usageLimitPhraseSource} list catches every wording we have actually
+ * seen, and the GENERIC fallback (a limit mention PLUS a reset/retry hint) still
+ * catches a wording the provider invents later — a rephrased limit message must
+ * not silently fall back to "relay the raw text and look hung", which is exactly
+ * what happened to `You've hit your session limit · resets 10:50pm (UTC)`.
+ *
+ * Ahead of both tiers sits {@link nonUsageLimitRe}: a context/token overflow is a
+ * limit no wait can clear, so it must never arm one.
+ */
+export declare function checkIsUsageLimitText(text: string): boolean;
+/**
+ * @description Classify a backend error string into an error class, or `null`
+ * when it is not a recognised provider error.
+ *
+ * ORDER IS LOAD-BEARING — branches are evaluated top to bottom and return on
+ * first match:
+ *  1. auth / logged out (login, bad credentials) → `{ kind: 'auth' }`. Must win:
+ *     a wait never fixes these (they need a re-login or server restart), so they
+ *     are SURFACED (a pinned notice), never auto-retried. Used to return `null`.
+ *  2. transient (rate-limited, overloaded, 429/503/529) → `{ kind: 'transient' }`.
+ *     Tested BEFORE usage on purpose: the live transient string literally reads
+ *     "...(not your usage limit)...", so a naive usage check would false-match it.
+ *     Because transient returns here, the usage branch never sees that substring.
+ *  3. usage / session / window limit → `{ kind: 'usageLimit', resetAt? }`, decided
+ *     by {@link checkIsUsageLimitText} (explicit wordings + a generic fallback).
+ * Anything else (normal prose, unrelated text) → `null`.
+ *
+ * @param now Current epoch ms — only consulted to resolve a relative/absolute
+ *   reset time for the usage class; the transient/auth branches ignore it.
+ */
+export declare function classifyAgentApiError(text: string, now: number): AgentApiErrorClass | null;
+/**
+ * @description Best-effort parse of a "reset time" out of a usage-limit message.
+ * Never throws: any unparseable / absent time yields `undefined`, which the
+ * caller treats as "use the fixed delay". Handles three shapes, in order:
+ *  - relative: "resets in 2h" / "in 45m" → `now + duration`.
+ *  - absolute clock: "resets at 3pm" / "at 15:00" / "resets 10:50pm (UTC)" → the
+ *    NEXT occurrence of that clock time at or after `now`. An EXPLICIT zone
+ *    suffix is load-bearing: the clock is then resolved IN THAT ZONE, not in the
+ *    instance/host zone. Without it a `10:50pm (UTC)` reset on a `+04:00` box
+ *    resolved four hours EARLY — the retry fires while the limit still holds,
+ *    re-errors, and burns one of the six attempts for nothing.
+ *  - ISO timestamp anywhere in the text → `Date.parse`.
+ *
+ * A clock shape that fails to resolve (out-of-range hour) falls THROUGH to the
+ * ISO branch rather than giving up, so a message carrying both still parses.
+ *
+ * @param now Current epoch ms, used to resolve relative durations and to pick
+ *   the next occurrence of an absolute clock time.
+ */
+export declare function parseResetAt(text: string, now: number): number | undefined;
+export interface RetryPlanArgs {
+    kind: AgentApiErrorClass['kind'];
+    /** 1-based attempt number for the delay we are about to schedule. */
+    attempt: number;
+    /** Parsed reset time (usage class only); absent → the fixed default delay. */
+    resetAt?: number;
+    /** Current epoch ms (to size a reset-time-relative delay). */
+    now: number;
+}
+export type RetryPlan = {
+    delayMs: number;
+} | {
+    giveUp: true;
+};
+/**
+ * @description Decide the next backoff for an attempt, or that the retry loop
+ * should give up. Every returned `delayMs` is clamped to `[0, maxTimeoutMs]`
+ * (the same `setTimeout` cap the scheduler engine uses) so a far-future reset
+ * time never overflows the timer.
+ *  - transient: {@link transientBackoffMinutes}[attempt-1]; giveUp once attempt
+ *    exceeds {@link transientMaxAttempts}.
+ *  - usageLimit: `resetAt` present → `resetAt - now + resetBufferMs`; else
+ *    {@link usageLimitDefaultMs}; giveUp once attempt exceeds
+ *    {@link usageLimitMaxAttempts}.
+ */
+export declare function getRetryPlan(args: RetryPlanArgs): RetryPlan;
+/**
+ * @description A read-only view of the bot's per-thread armed-retry record, fed
+ * into {@link decideRetryAction}. The bot owns the live `Map`; this snapshot is
+ * the only state the pure decision needs.
+ */
+export interface RetryEntrySnapshot {
+    /** 1-based attempt of the currently / last armed retry. */
+    attempt: number;
+    /** Epoch ms when the last armed retry actually fired, or `null` if still pending. */
+    firedAt: number | null;
+    /** True while a retry timer is armed and has not fired yet. */
+    pending: boolean;
+}
+/**
+ * @description The action the bot must take in response to one `apiError`:
+ *  - `surface` — an auth / logged-out error: post a pinned notice, arm NO timer
+ *    (a wait never fixes it). The bot dedups repeats via its own per-thread
+ *    auth-notice flag, so no attempt bookkeeping is needed here.
+ *  - `ignore`  — a retry is already armed and waiting; dedup this duplicate
+ *    error frame (Claude re-scrapes the same line; OpenCode can repeat
+ *    `session.error`).
+ *  - `arm`     — arm a timer for `attempt` after `delayMs` (firing at `fireAt`).
+ *  - `giveUp`  — the retry cap was reached; `attempts` is how many were already
+ *    made before giving up.
+ */
+export type RetryAction = {
+    action: 'surface';
+} | {
+    action: 'ignore';
+} | {
+    action: 'arm';
+    attempt: number;
+    delayMs: number;
+    fireAt: number;
+} | {
+    action: 'giveUp';
+    attempts: number;
+};
+export interface DecideRetryActionArgs {
+    kind: AgentApiErrorClass['kind'];
+    /** Parsed reset time (usage class only); absent → the fixed default delay. */
+    resetAt?: number;
+    /** Current epoch ms. */
+    now: number;
+    /** The thread's existing armed-retry snapshot, or `null` if none. */
+    prev: RetryEntrySnapshot | null;
+}
+/**
+ * @description Decide the bot's reaction to an incoming API error, combining the
+ * episode/attempt bookkeeping with {@link getRetryPlan}. Pure — the caller
+ * passes `now` and the `prev` snapshot, so the decision is deterministic.
+ *
+ * Rules (evaluated in order):
+ *  0. `auth` → `surface` (never a timer, no attempt bookkeeping — the bot posts
+ *     a deduped pinned notice; a wait can't recover a logged-out session).
+ *  1. `prev.pending` → `ignore` (a retry is already armed — dedup the episode;
+ *     this is what stops Claude's repeated scrape frames AND any duplicate
+ *     `session.error` from re-arming).
+ *  2. same episode (a `prev` that fired within {@link retryRecurrenceGraceMs}) →
+ *     escalate to `prev.attempt + 1`; otherwise a fresh episode → attempt 1.
+ *  3. ask {@link getRetryPlan}: `giveUp` → `giveUp` with `attempts` already made
+ *     (= attempt − 1); else `arm` at `now + delayMs`.
+ */
+export declare function decideRetryAction(args: DecideRetryActionArgs): RetryAction;
+//# sourceMappingURL=apiErrorRetry.d.ts.map

package/dist/apiErrorRetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiErrorRetry.d.ts","sourceRoot":"","sources":["../src/apiErrorRetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAQlD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,sBAAuB,CAAC;AAC5D,oFAAoF;AACpF,eAAO,MAAM,oBAAoB,GAAiC,CAAC;AAEnE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,QAAmB,CAAC;AACpD,8EAA8E;AAC9E,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,QAAkB,CAAC;AACtD;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAS,CAAC;AA2BpC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAyE,CAAC;AAmBzG;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,QAGxB,CAAC;AAEZ,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,QAA0C,CAAC;AAwB3E;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAI3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAW1F;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAsB1E;AA8DD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACjC,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,SAAS,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAe3D;AAOD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,+DAA+D;IAC/D,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnE;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACjC,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wBAAwB;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,qEAAqE;IACrE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,WAAW,CAW1E"}

package/dist/apiErrorRetry.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * @description Pure decision layer for the auto-retry-after-API-error feature
+ * (plan `agent/tasks/actual/2026-06-09-api-error-auto-retry.md`, S1). No I/O and
+ * no `Date.now()` inside: every caller passes `now` so the module is fully
+ * deterministic and unit-testable on a fixed clock.
+ *
+ * Two responsibilities:
+ *  - {@link classifyAgentApiError} — read a terminal error string and decide
+ *    whether (and how) it should be auto-retried. ORDER MATTERS (see the fn doc).
+ *  - {@link getRetryPlan} — given a class + the current attempt, decide the next
+ *    backoff delay or that we should give up.
+ *
+ * The same classifier serves BOTH backends: Claude surfaces the provider's
+ * "API Error" line in its TUI pane; OpenCode surfaces the same provider text
+ * through `session.error`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usageLimitPhrasesRe = exports.usageLimitPhraseSource = exports.authErrorPhrasesRe = exports.resetBufferMs = exports.retryRecurrenceGraceMs = exports.usageLimitMaxAttempts = exports.usageLimitDefaultMs = exports.transientMaxAttempts = exports.transientBackoffMinutes = void 0;
+exports.checkIsUsageLimitText = checkIsUsageLimitText;
+exports.classifyAgentApiError = classifyAgentApiError;
+exports.parseResetAt = parseResetAt;
+exports.getRetryPlan = getRetryPlan;
+exports.decideRetryAction = decideRetryAction;
+const engine_1 = require("./scheduler/engine");
+/** One minute in milliseconds — the unit the backoff schedules are expressed in. */
+const msPerMinute = 60_000;
+/** One hour in milliseconds. */
+const msPerHour = 60 * msPerMinute;
+/**
+ * Transient backoff schedule (one entry per attempt): attempt 1 → 5m,
+ * 2 → 10m, 3 → 20m. After the last entry the retry gives up.
+ */
+exports.transientBackoffMinutes = [5, 10, 20];
+/** Max transient attempts before giving up (= `transientBackoffMinutes.length`). */
+exports.transientMaxAttempts = exports.transientBackoffMinutes.length;
+/**
+ * Fixed delay for a usage-limit error whose text exposed no reset time (the
+ * common case for Claude's "blocked" message): 60 minutes, re-armed on each
+ * repeat until {@link usageLimitMaxAttempts}.
+ */
+exports.usageLimitDefaultMs = 60 * msPerMinute;
+/** Max usage-limit attempts before giving up (~6h with the default delay). */
+exports.usageLimitMaxAttempts = 6;
+/**
+ * Grace window after a retry fires: another API error within this window counts
+ * as the SAME error episode (escalate to attempt+1, longer backoff); an error
+ * later than this is a FRESH episode (reset to attempt 1). Decouples the
+ * decision from session-end events — a recovered turn just leaves a stale record
+ * that the next, much-later error resets to attempt 1.
+ */
+exports.retryRecurrenceGraceMs = 2 * msPerMinute;
+/**
+ * Padding added to a parsed reset time so the retry fires just AFTER the window
+ * actually rolls over, never a hair before it (which would re-error instantly).
+ */
+exports.resetBufferMs = 60_000;
+/** Matches reset phrasings like "resets in 2h", "in 45m", "in 90 min". */
+const relativeResetRegex = /\bin\s+(\d+)\s*(h|hours?|m|min|minutes?)\b/i;
+/**
+ * Matches absolute clock phrasings after a reset trigger word. The trigger is
+ * either `at` (`resets at 3pm`, `at 15:00`) OR a BARE `reset`/`resets` — Claude's
+ * session-limit render drops the "at" entirely (`resets 10:50pm (UTC)`), which
+ * the old `at`-only pattern missed, leaving the retry on its blind 60-min delay.
+ * The hour's `(?!\d)` guard stops a leading ISO date (`2026-09-24`) from being
+ * read as an hour before the ISO branch gets its turn.
+ */
+const clockResetRegex = /\b(?:reset(?:s|ting)?|at)\s+(\d{1,2})(?!\d)(?::(\d{2}))?\s*(am|pm)?/i;
+/**
+ * An EXPLICIT timezone immediately after the clock — `(UTC)`, ` UTC`, `Z`,
+ * `+05:00`, `-0700`. Anchored at the remainder's start so only a suffix of THAT
+ * clock counts, and `\b`-terminated so a word merely starting with `Z` (`Zulu`,
+ * `Zoom`) is not read as the Zulu zone.
+ */
+const trailingZoneRegex = /^\s*\(?\s*(UTC|GMT|Z|[+-]\d{2}:?\d{2})\b\s*\)?/i;
+/** Matches an ISO-8601 timestamp anywhere in the text. */
+const isoTimestampRegex = /\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/;
+const hoursPerDay = 24;
+const minutesPerHour = 60;
+const msPerDay = hoursPerDay * msPerHour;
+/**
+ * @description The auth / logged-out phrases (`please run /login`, `not logged
+ * in`, `invalid authentication credentials`). Shared with the Claude scrape
+ * detector (`getClaudeAgentErrorLine`) so the two never drift. NOT global — used
+ * with `.test()`, so lastIndex never carries between calls.
+ */
+exports.authErrorPhrasesRe = /please run \/login|not logged in|invalid authentication credentials/i;
+/**
+ * The wordings that name a usage WINDOW or an exhausted balance EXPLICITLY: the
+ * qualified window limits (`session limit`, `weekly limit`, `5-hour limit`), the
+ * `hit your … limit` phrasings Claude now uses, and the balance/quota exhaustion
+ * wordings that are not spelled as a "limit" at all. Kept apart from the bare
+ * `limit reached` below because this subset is what exempts a text from
+ * {@link nonUsageLimitRe} — "hit your weekly token limit" IS a usage window, a bare
+ * "context limit exceeded" is not.
+ */
+const usageWindowPhrases = [
+    String.raw `(?:session|usage|weekly|daily|monthly|hourly|\d+-hours?)\s+limit`,
+    String.raw `(?:hit|reached|exceeded)\s+your\s+(?:[\w-]+\s+){0,3}limit`,
+    String.raw `credit balance (?:is )?too low`,
+    String.raw `out of (?:credits|usage)`,
+    String.raw `quota`,
+];
+/**
+ * @description Alternation SOURCE (no anchors, no flags) of the explicit
+ * usage/session-limit wordings — {@link usageWindowPhrases} plus a bare
+ * `limit reached`. Exported as a source string — not just a compiled
+ * regex — because the Claude scrape detector (`getClaudeAgentErrorLine`) has to
+ * ANCHOR the same phrases at the start of a pane row, and a single source keeps
+ * the two from drifting (the `authErrorPhrasesRe` precedent).
+ */
+exports.usageLimitPhraseSource = [
+    ...usageWindowPhrases,
+    String.raw `limit\s+(?:reached|exceeded)`,
+].join('|');
+/** {@link usageLimitPhraseSource} compiled for a whole-text `.test()`. */
+exports.usageLimitPhrasesRe = new RegExp(exports.usageLimitPhraseSource, 'i');
+/** {@link usageWindowPhrases} compiled — the {@link nonUsageLimitRe} exemption. */
+const usageWindowPhrasesRe = new RegExp(usageWindowPhrases.join('|'), 'i');
+/**
+ * A limit that WAITING can never clear: a context / token / prompt-length overflow
+ * is fixed by sending less, not by sitting out a window. The real provider wording
+ * ("input length and `max_tokens` exceed context limit: … decrease input length …
+ * and try again") carries both a limit mention and a retry hint, so without this
+ * guard the generic fallback below classified it as `usageLimit` and armed a 6-hour
+ * futile wait instead of surfacing an error the operator has to act on.
+ */
+const nonUsageLimitRe = /\b(?:context|token|input|output|prompt|character)\s+(?:length\s+)?limits?\b/i;
+/**
+ * The GENERIC fallback's two required signals: the text mentions a limit AND
+ * carries a reset/retry hint. BOTH are required on purpose — "limit" alone
+ * matches ordinary prose ("the API limit is 5 requests per minute"), while the
+ * pairing is what every real limit message has (it always tells you when you get
+ * back in).
+ */
+const limitMentionRe = /\blimits?\b/i;
+const limitResetHintRe = /\breset(?:s|ting)?\b|\btry again\b|\bresumes?\b/i;
+/**
+ * @description Whether an error text is a usage / session / window limit.
+ *
+ * Two tiers, and the second one is the point: the explicit
+ * {@link usageLimitPhraseSource} list catches every wording we have actually
+ * seen, and the GENERIC fallback (a limit mention PLUS a reset/retry hint) still
+ * catches a wording the provider invents later — a rephrased limit message must
+ * not silently fall back to "relay the raw text and look hung", which is exactly
+ * what happened to `You've hit your session limit · resets 10:50pm (UTC)`.
+ *
+ * Ahead of both tiers sits {@link nonUsageLimitRe}: a context/token overflow is a
+ * limit no wait can clear, so it must never arm one.
+ */
+function checkIsUsageLimitText(text) {
+    if (nonUsageLimitRe.test(text) && !usageWindowPhrasesRe.test(text))
+        return false;
+    if (exports.usageLimitPhrasesRe.test(text))
+        return true;
+    return limitMentionRe.test(text) && limitResetHintRe.test(text);
+}
+/**
+ * @description Classify a backend error string into an error class, or `null`
+ * when it is not a recognised provider error.
+ *
+ * ORDER IS LOAD-BEARING — branches are evaluated top to bottom and return on
+ * first match:
+ *  1. auth / logged out (login, bad credentials) → `{ kind: 'auth' }`. Must win:
+ *     a wait never fixes these (they need a re-login or server restart), so they
+ *     are SURFACED (a pinned notice), never auto-retried. Used to return `null`.
+ *  2. transient (rate-limited, overloaded, 429/503/529) → `{ kind: 'transient' }`.
+ *     Tested BEFORE usage on purpose: the live transient string literally reads
+ *     "...(not your usage limit)...", so a naive usage check would false-match it.
+ *     Because transient returns here, the usage branch never sees that substring.
+ *  3. usage / session / window limit → `{ kind: 'usageLimit', resetAt? }`, decided
+ *     by {@link checkIsUsageLimitText} (explicit wordings + a generic fallback).
+ * Anything else (normal prose, unrelated text) → `null`.
+ *
+ * @param now Current epoch ms — only consulted to resolve a relative/absolute
+ *   reset time for the usage class; the transient/auth branches ignore it.
+ */
+function classifyAgentApiError(text, now) {
+    if (exports.authErrorPhrasesRe.test(text)) {
+        return { kind: 'auth' };
+    }
+    if (/rate.?limited?|temporarily limiting requests|too many requests|overloaded|\b(429|503|529)\b/i.test(text)) {
+        return { kind: 'transient' };
+    }
+    if (checkIsUsageLimitText(text)) {
+        return { kind: 'usageLimit', resetAt: parseResetAt(text, now) };
+    }
+    return null;
+}
+/**
+ * @description Best-effort parse of a "reset time" out of a usage-limit message.
+ * Never throws: any unparseable / absent time yields `undefined`, which the
+ * caller treats as "use the fixed delay". Handles three shapes, in order:
+ *  - relative: "resets in 2h" / "in 45m" → `now + duration`.
+ *  - absolute clock: "resets at 3pm" / "at 15:00" / "resets 10:50pm (UTC)" → the
+ *    NEXT occurrence of that clock time at or after `now`. An EXPLICIT zone
+ *    suffix is load-bearing: the clock is then resolved IN THAT ZONE, not in the
+ *    instance/host zone. Without it a `10:50pm (UTC)` reset on a `+04:00` box
+ *    resolved four hours EARLY — the retry fires while the limit still holds,
+ *    re-errors, and burns one of the six attempts for nothing.
+ *  - ISO timestamp anywhere in the text → `Date.parse`.
+ *
+ * A clock shape that fails to resolve (out-of-range hour) falls THROUGH to the
+ * ISO branch rather than giving up, so a message carrying both still parses.
+ *
+ * @param now Current epoch ms, used to resolve relative durations and to pick
+ *   the next occurrence of an absolute clock time.
+ */
+function parseResetAt(text, now) {
+    const relativeMatch = relativeResetRegex.exec(text);
+    if (relativeMatch) {
+        const amount = Number.parseInt(relativeMatch[1], 10);
+        const unit = relativeMatch[2].toLowerCase();
+        const isHours = unit.startsWith('h');
+        return now + amount * (isHours ? msPerHour : msPerMinute);
+    }
+    const clockMatch = clockResetRegex.exec(text);
+    if (clockMatch) {
+        const resolved = resolveNextClockTime(clockMatch, text, now);
+        if (resolved !== undefined)
+            return resolved;
+    }
+    const isoMatch = isoTimestampRegex.exec(text);
+    if (isoMatch) {
+        const parsed = Date.parse(isoMatch[0]);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+/**
+ * Read an explicit zone token to an offset from UTC in ms, or `undefined` when it
+ * is not a zone we can resolve arithmetically. `Z`/`UTC`/`GMT` are zero;
+ * `±HH:MM` / `±HHMM` are taken literally (a fixed offset needs no DST rules).
+ */
+function getZoneOffsetMs(zone) {
+    const upper = zone.toUpperCase();
+    if (upper === 'UTC' || upper === 'GMT' || upper === 'Z')
+        return 0;
+    const match = /^([+-])(\d{2}):?(\d{2})$/.exec(zone);
+    if (!match)
+        return undefined;
+    const hours = Number.parseInt(match[2], 10);
+    const minutes = Number.parseInt(match[3], 10);
+    if (hours >= hoursPerDay || minutes >= minutesPerHour)
+        return undefined;
+    const sign = match[1] === '-' ? -1 : 1;
+    return sign * (hours * msPerHour + minutes * msPerMinute);
+}
+/**
+ * Resolve a clock match to the next epoch ms at or after `now` that lands on that
+ * wall-clock time. When the text carries an explicit zone right after the clock
+ * the arithmetic is done in THAT zone (pure offset math, no `Intl`); otherwise it
+ * falls back to the process-local zone (which `/timezone` already re-bases).
+ * Returns `undefined` for an out-of-range hour/minute rather than guessing.
+ */
+function resolveNextClockTime(match, text, now) {
+    const rawHour = Number.parseInt(match[1], 10);
+    const minute = match[2] ? Number.parseInt(match[2], 10) : 0;
+    const meridiem = match[3]?.toLowerCase();
+    let hour = rawHour;
+    if (meridiem === 'pm' && rawHour < 12)
+        hour = rawHour + 12;
+    else if (meridiem === 'am' && rawHour === 12)
+        hour = 0;
+    if (hour < 0 || hour >= hoursPerDay || minute < 0 || minute >= minutesPerHour) {
+        return undefined;
+    }
+    const zoneMatch = trailingZoneRegex.exec(text.slice(match.index + match[0].length));
+    const offsetMs = zoneMatch ? getZoneOffsetMs(zoneMatch[1]) : undefined;
+    if (offsetMs !== undefined) {
+        // Shift onto the zone's timeline, snap to that zone's midnight, then shift
+        // back — `Date`'s local-zone getters are unusable for a foreign zone.
+        const shiftedNow = now + offsetMs;
+        const zoneDayStart = Math.floor(shiftedNow / msPerDay) * msPerDay;
+        let candidateShifted = zoneDayStart + hour * msPerHour + minute * msPerMinute;
+        if (candidateShifted < shiftedNow)
+            candidateShifted += msPerDay;
+        return candidateShifted - offsetMs;
+    }
+    const candidate = new Date(now);
+    candidate.setHours(hour, minute, 0, 0);
+    let candidateMs = candidate.getTime();
+    if (candidateMs < now) {
+        // Already past today — roll to the same clock time tomorrow.
+        candidate.setDate(candidate.getDate() + 1);
+        candidateMs = candidate.getTime();
+    }
+    return candidateMs;
+}
+/**
+ * @description Decide the next backoff for an attempt, or that the retry loop
+ * should give up. Every returned `delayMs` is clamped to `[0, maxTimeoutMs]`
+ * (the same `setTimeout` cap the scheduler engine uses) so a far-future reset
+ * time never overflows the timer.
+ *  - transient: {@link transientBackoffMinutes}[attempt-1]; giveUp once attempt
+ *    exceeds {@link transientMaxAttempts}.
+ *  - usageLimit: `resetAt` present → `resetAt - now + resetBufferMs`; else
+ *    {@link usageLimitDefaultMs}; giveUp once attempt exceeds
+ *    {@link usageLimitMaxAttempts}.
+ */
+function getRetryPlan(args) {
+    // auth is never retried (it is surfaced by `decideRetryAction` before this is
+    // reached); guard so it can never fall through into the usageLimit branch.
+    if (args.kind === 'auth')
+        return { giveUp: true };
+    if (args.kind === 'transient') {
+        if (args.attempt > exports.transientMaxAttempts)
+            return { giveUp: true };
+        const minutes = exports.transientBackoffMinutes[args.attempt - 1];
+        return { delayMs: clampDelay(minutes * msPerMinute) };
+    }
+    if (args.attempt > exports.usageLimitMaxAttempts)
+        return { giveUp: true };
+    const rawDelayMs = typeof args.resetAt === 'number' ? args.resetAt - args.now + exports.resetBufferMs : exports.usageLimitDefaultMs;
+    return { delayMs: clampDelay(rawDelayMs) };
+}
+/** Clamp a delay into `[0, maxTimeoutMs]` (the Node `setTimeout` safe range). */
+function clampDelay(delayMs) {
+    return Math.min(Math.max(0, delayMs), engine_1.maxTimeoutMs);
+}
+/**
+ * @description Decide the bot's reaction to an incoming API error, combining the
+ * episode/attempt bookkeeping with {@link getRetryPlan}. Pure — the caller
+ * passes `now` and the `prev` snapshot, so the decision is deterministic.
+ *
+ * Rules (evaluated in order):
+ *  0. `auth` → `surface` (never a timer, no attempt bookkeeping — the bot posts
+ *     a deduped pinned notice; a wait can't recover a logged-out session).
+ *  1. `prev.pending` → `ignore` (a retry is already armed — dedup the episode;
+ *     this is what stops Claude's repeated scrape frames AND any duplicate
+ *     `session.error` from re-arming).
+ *  2. same episode (a `prev` that fired within {@link retryRecurrenceGraceMs}) →
+ *     escalate to `prev.attempt + 1`; otherwise a fresh episode → attempt 1.
+ *  3. ask {@link getRetryPlan}: `giveUp` → `giveUp` with `attempts` already made
+ *     (= attempt − 1); else `arm` at `now + delayMs`.
+ */
+function decideRetryAction(args) {
+    const { kind, resetAt, now, prev } = args;
+    if (kind === 'auth')
+        return { action: 'surface' };
+    if (prev?.pending)
+        return { action: 'ignore' };
+    const sameEpisode = !!prev && prev.firedAt != null && now - prev.firedAt <= exports.retryRecurrenceGraceMs;
+    const attempt = sameEpisode ? prev.attempt + 1 : 1;
+    const plan = getRetryPlan({ kind, attempt, resetAt, now });
+    if ('giveUp' in plan)
+        return { action: 'giveUp', attempts: attempt - 1 };
+    return { action: 'arm', attempt, delayMs: plan.delayMs, fireAt: now + plan.delayMs };
+}
+//# sourceMappingURL=apiErrorRetry.js.map

package/dist/apiErrorRetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiErrorRetry.js","sourceRoot":"","sources":["../src/apiErrorRetry.ts"],"names":[],"mappings":"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"}