charness 3.2.0 → 3.3.0

package/dist/apiErrorRetry.d.ts

@@ -22,6 +22,21 @@ import type { AgentApiErrorClass } from './types';
 export declare const transientBackoffMinutes: readonly [5, 10, 20];
 /** Max transient attempts before giving up (= `transientBackoffMinutes.length`). */
 export declare const transientMaxAttempts: 3;
+/**
+ * A limit whose stated reset is at most this far ahead is a throttle: the first transient retry already outwaits it.
+ * Google's subscription quotas say "Your quota will reset after 2s" for a momentary cap and "after 146h52m11s" for a
+ * spent plan — the same words, told apart only by the duration.
+ */
+export declare const shortStatedResetMaxMs: number;
+/** @description Whether a stated reset (a parsed text reset or a Retry-After field) is within {@link shortStatedResetMaxMs} ahead. */
+export declare function checkIsShortStatedReset(resetAt: number, now: number): boolean;
+/**
+ * The retry of a request the provider refused because the conversation ended on the model's turn
+ * ({@link conversationTailRe}): the "continue" nudge is a user turn, which is all the provider asks for — so it goes at
+ * once (a moment, to let the failed turn settle), and only once: the same refusal right after it ends with the give-up.
+ */
+export declare const conversationTailRetryDelayMs = 2000;
+export declare const conversationTailMaxAttempts = 1;
 /**
  * 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
@@ -61,6 +76,13 @@ export declare const authErrorPhrasesRe: RegExp;
 export declare const usageLimitPhraseSource: string;
 /** {@link usageLimitPhraseSource} compiled for a whole-text `.test()`. */
 export declare const usageLimitPhrasesRe: RegExp;
+/**
+ * @description Whether a text is a usage WARNING (see {@link usageLimitWarningRe})
+ * — the account is still allowed, so it is never a usage-limit error. Shared with
+ * the Claude scrape detector (`getClaudeAgentErrorLine`), which skips such a row so
+ * a real block further down the same pane delta is still found.
+ */
+export declare function checkIsUsageLimitWarningText(text: string): boolean;
 /**
  * @description Whether an error text is a usage / session / window limit.
  *
@@ -84,8 +106,18 @@ export declare function checkIsUsageLimitText(text: string): boolean;
  *  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`.
+ *  1a. the refusal of a history that ends on the model's turn ({@link conversationTailRe}) → `conversationTail`.
+ *  1b. a usage WARNING ({@link checkIsUsageLimitWarningText}) → `null`: the
+ *     request went through; it names a window and a reset like the block does.
+ *  1b'. a stated reset ({@link parseResetAt}) within {@link shortStatedResetMaxMs} → `transient`;
+ *     a longer one keeps 1c from calling the limit short. A short one a RETRY verb states ("retry in 40s") that reaches
+ *     the usage-limit branches below (a long window named beside it) is a retry hint: their `resetAt` drops it.
+ *  1c. a SHORT-window throttle ({@link shortWindowThrottleRe}, reported as hit —
+ *     {@link limitHitRe}) that names no long
+ *     window ({@link longWindowRe}) → `transient`: per-minute quotas, concurrency,
+ *     "retry in 40s" — ahead of the quota codes, which they share with daily quotas.
  *  2. an exhausted-quota provider CODE ({@link exhaustedQuotaCodesRe}) or the observed
- *     subscription wording ({@link subscriptionLimitMessageRe}) → `usageLimit`.
+ *     subscription wording ({@link subscriptionLimitMessageRe}, flagged `isUnconfirmed`) → `usageLimit`.
  *     Ahead of transient because these ride a 429 (OpenAI `insufficient_quota`,
  *     Google `RESOURCE_EXHAUSTED`), which the next branch would read as a hiccup.
  *  3. transient (rate-limited, overloaded, 429/503/529, or a bare "rate limit" without an explicit
@@ -101,18 +133,48 @@ export declare function checkIsUsageLimitText(text: string): boolean;
  *   reset time for the usage class; the transient/auth branches ignore it.
  */
 export declare function classifyAgentApiError(text: string, now: number): AgentApiErrorClass | null;
+/**
+ * The short retry an UNCONFIRMED usage limit ({@link AgentApiErrorClass.isUnconfirmed}) gets first: long enough not to
+ * hammer an account that is really limited, short enough that a refused single request costs the topic two minutes, not
+ * the hours to the window's reset.
+ */
+export declare const unconfirmedLimitProbeDelayMs: number;
+/**
+ * @description What an UNCONFIRMED usage limit does: `probe` — a short retry ({@link unconfirmedLimitProbeDelayMs}),
+ * no limit notice; `waitForReset` — the usual usage-limit wait, once the limit is confirmed: it repeated right after
+ * the probe (`isRepeatAfterProbe`), or the account's usage reading shows a window at 100 % (`isUsageExhausted`).
+ */
+export declare function getUnconfirmedLimitAction(input: {
+    isRepeatAfterProbe: boolean;
+    isUsageExhausted: boolean;
+}): 'probe' | 'waitForReset';
+/**
+ * @description Whether a usage-limit error names a reset that is already behind
+ * `now`: the window is over. The boot recovery of a parked error (read against the
+ * time it was written) uses it to resume without announcing a limit; a live error
+ * is announced whatever its reset says.
+ */
+export declare function checkIsUsageLimitWindowOver(cls: AgentApiErrorClass, now: number): boolean;
 /**
  * @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`.
+ * caller treats as "use the fixed delay". Handles five shapes, in order:
+ *  - machine form: an epoch (`"resets_at":…` in a relayed ChatGPT body, Claude's
+ *    `limit reached|<epoch>`) or that body's `"resets_in_seconds":…` — exact, so
+ *    first ({@link parseStructuredResetAt}).
+ *  - relative: "resets in 2h" / "in 45m" / "in 2 hours 30 minutes" → `now` + the
+ *    sum of the parts.
+ *  - dated: "resets Oct 25, 3pm (Europe/Moscow)" — a weekly window, more than a
+ *    day ahead → that date and clock, in the stated zone (or the local one).
  *  - 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
+ *    suffix — an offset (`(UTC)`, `+05:00`) or a named zone (`(Europe/Moscow)`,
+ *    the way Claude Code writes it) — 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`.
+ *  - ISO timestamp anywhere in the text → that instant; a zone-less one only with
+ *    a zone right after it (see {@link resolveIsoResetTime}).
  *
  * 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.
@@ -142,6 +204,8 @@ export type RetryPlan = {
  * time never overflows the timer.
  *  - transient: {@link transientBackoffMinutes}[attempt-1]; giveUp once attempt
  *    exceeds {@link transientMaxAttempts}.
+ *  - conversationTail: {@link conversationTailRetryDelayMs}; giveUp once attempt exceeds
+ *    {@link conversationTailMaxAttempts}.
  *  - usageLimit: `resetAt` present → `resetAt - now + resetBufferMs`; else
  *    {@link usageLimitDefaultMs}; giveUp once attempt exceeds
  *    {@link usageLimitMaxAttempts}.

package/dist/apiErrorRetry.d.ts.map

@@ -1 +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;AA2CzG;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAiB1F;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"}
+{"version":3,"file":"apiErrorRetry.d.ts","sourceRoot":"","sources":["../src/apiErrorRetry.ts"],"names":[],"mappings":"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"}

package/dist/apiErrorRetry.js

@@ -16,15 +16,21 @@
  * 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.unconfirmedLimitProbeDelayMs = exports.usageLimitPhrasesRe = exports.usageLimitPhraseSource = exports.authErrorPhrasesRe = exports.resetBufferMs = exports.retryRecurrenceGraceMs = exports.usageLimitMaxAttempts = exports.usageLimitDefaultMs = exports.conversationTailMaxAttempts = exports.conversationTailRetryDelayMs = exports.shortStatedResetMaxMs = exports.transientMaxAttempts = exports.transientBackoffMinutes = void 0;
+exports.checkIsShortStatedReset = checkIsShortStatedReset;
+exports.checkIsUsageLimitWarningText = checkIsUsageLimitWarningText;
 exports.checkIsUsageLimitText = checkIsUsageLimitText;
 exports.classifyAgentApiError = classifyAgentApiError;
+exports.getUnconfirmedLimitAction = getUnconfirmedLimitAction;
+exports.checkIsUsageLimitWindowOver = checkIsUsageLimitWindowOver;
 exports.parseResetAt = parseResetAt;
 exports.getRetryPlan = getRetryPlan;
 exports.decideRetryAction = decideRetryAction;
 const engine_1 = require("./scheduler/engine");
+const timezone_1 = require("./utils/timezone");
+const msPerSecond = 1000;
 /** One minute in milliseconds — the unit the backoff schedules are expressed in. */
-const msPerMinute = 60_000;
+const msPerMinute = 60 * msPerSecond;
 /** One hour in milliseconds. */
 const msPerHour = 60 * msPerMinute;
 /**
@@ -34,6 +40,23 @@ const msPerHour = 60 * msPerMinute;
 exports.transientBackoffMinutes = [5, 10, 20];
 /** Max transient attempts before giving up (= `transientBackoffMinutes.length`). */
 exports.transientMaxAttempts = exports.transientBackoffMinutes.length;
+/**
+ * A limit whose stated reset is at most this far ahead is a throttle: the first transient retry already outwaits it.
+ * Google's subscription quotas say "Your quota will reset after 2s" for a momentary cap and "after 146h52m11s" for a
+ * spent plan — the same words, told apart only by the duration.
+ */
+exports.shortStatedResetMaxMs = exports.transientBackoffMinutes[0] * msPerMinute;
+/** @description Whether a stated reset (a parsed text reset or a Retry-After field) is within {@link shortStatedResetMaxMs} ahead. */
+function checkIsShortStatedReset(resetAt, now) {
+    return resetAt >= now && resetAt - now <= exports.shortStatedResetMaxMs;
+}
+/**
+ * The retry of a request the provider refused because the conversation ended on the model's turn
+ * ({@link conversationTailRe}): the "continue" nudge is a user turn, which is all the provider asks for — so it goes at
+ * once (a moment, to let the failed turn settle), and only once: the same refusal right after it ends with the give-up.
+ */
+exports.conversationTailRetryDelayMs = 2_000;
+exports.conversationTailMaxAttempts = 1;
 /**
  * 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
@@ -55,8 +78,23 @@ exports.retryRecurrenceGraceMs = 2 * msPerMinute;
  * 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;
+/**
+ * A reset relayed in MACHINE form — an exact epoch in seconds, read before any prose: `"resets_at":1781085600` in the
+ * ChatGPT subscription's `usage_limit_reached` 429 body (codex-rs `UsageErrorBody`), which OpenCode relays verbatim as
+ * the response body, and an older Claude Code's `Claude AI usage limit reached|1781085600`.
+ */
+const structuredResetEpochRegex = /"resets_at"\s*:\s*(\d{10})(?![\d.])|\blimit reached\|(\d{10})(?![\d.])/i;
+/** The same body's wait until that reset in seconds, `"resets_in_seconds":9000` — what an older body carries instead. */
+const structuredResetWaitRegex = /"resets_in_seconds"\s*:\s*(\d+)(?![\d.])/i;
+/** One part of a relative reset — `2 hours`, `30m`, `1 day`, `3s`, `40.15s` — closed by a non-letter (`1h30m` has no word break). */
+const relativeResetPartSource = String.raw `(\d+(?:\.\d+)?)\s*(d|days?|h|hours?|m|mins?|minutes?|s|secs?|seconds?)(?![a-z])`;
+/**
+ * Matches a relative reset — "resets in 2h", "in 45m", "in 90 min", "reset after 8h27m3s" — and every part that follows
+ * it: OpenCode Go writes "It will reset in 2 hours 30 minutes" / "in 1 day 3 hours"; Google's subscription quotas
+ * "Your quota will reset after 2s" / "after 146h52m11s".
+ */
+const relativeResetRegex = new RegExp(String.raw `\b(?:in|after)\s+((?:${relativeResetPartSource}(?:\s*(?:,|and)?\s*))+)`, 'i');
+const relativeResetPartRegex = new RegExp(relativeResetPartSource, 'gi');
 /**
  * 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
@@ -73,8 +111,22 @@ const clockResetRegex = /\b(?:reset(?:s|ting)?|at)\s+(\d{1,2})(?!\d)(?::(\d{2}))
  * `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/;
+/**
+ * A NAMED zone in parentheses right after the clock — Claude Code formats the reset in its own zone and says which:
+ * `resets 2:10pm (Europe/Moscow)`. An IANA name (`Area/Location`, possibly deeper); validated by `Intl` before use.
+ */
+const trailingNamedZoneRegex = /^\s*\(\s*([A-Za-z]+(?:\/[A-Za-z0-9_+-]+)+)\s*\)/;
+/**
+ * Matches a DATED reset — a window more than a day ahead, written by Claude Code as `toLocaleString('en-US', { month:
+ * 'short', day: 'numeric', hour: 'numeric' })`: `resets Oct 25, 3pm`, `resets Oct 25, 3:30pm`, `resets Jan 2, 2027,
+ * 3pm` (the year only when it is not this one); claude.ai's `It resets Oct 25 at 3pm` too. Tried BEFORE the bare clock,
+ * whose `at 3pm` would otherwise win and drop the date.
+ */
+const monthDayResetRegex = /\breset(?:s|ting)?\s+(?:on\s+)?(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\.?\s+(\d{1,2})(?:,\s*(\d{4}))?(?:\s*,\s*|\s+at\s+|\s+)(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b/i;
+/** The month abbreviations {@link monthDayResetRegex} captures, in calendar order. */
+const monthAbbreviations = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+/** Matches an ISO-8601 timestamp anywhere in the text: its date and clock, and its zone when it carries one. */
+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;
@@ -96,7 +148,8 @@ exports.authErrorPhrasesRe = /please run \/login|not logged in|invalid authentic
  */
 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`,
+    // "exceeded your RATE limit" / "your CONCURRENCY limit" is a throttle, not a window.
+    String.raw `(?:hit|reached|exceeded)\s+your\s+(?:(?!rate\b|concurren)[\w-]+\s+){0,3}limit`,
     String.raw `credit balance (?:is )?too low`,
     String.raw `out of (?:credits|usage)`,
     String.raw `quota`,
@@ -114,9 +167,35 @@ const exhaustedQuotaCodesRe = /insufficient_quota|exceeded your current quota|us
 /**
  * Observed subscription-window wording ("This request would exceed your account's rate limit. Please try
  * again later."); do not generalize it to every bare rate limit. Keyed on the distinctive head only, so a
- * relay that truncates the tail or types a curly apostrophe still matches.
+ * relay that truncates the tail or types a curly apostrophe still matches. UNCONFIRMED on its own: the same
+ * 429 comes at 0–84 % shown usage (claude-code#19673) — see {@link getUnconfirmedLimitAction}.
  */
 const subscriptionLimitMessageRe = /would exceed your account['\u2019]?s rate limit/i;
+/**
+ * Markers of a SHORT-window throttle — per minute / per second (spelled out, or in a Google quota id such as
+ * `GenerateRequestsPerMinutePerProjectPerModel`), RPM / TPM, concurrency, a retry hint in seconds (`Please retry in
+ * 40.15s`, Google's `"retryDelay": "40s"`), and Google's bare `Resource (has been) exhausted`. Such a limit clears by
+ * the next retry, so it is transient whatever quota vocabulary rides along: Google answers a used-up per-MINUTE quota
+ * with the same 429 RESOURCE_EXHAUSTED and "You exceeded your current quota" as a per-DAY one.
+ */
+const shortWindowThrottleRe = /\bper[\s_-]?(?:minute|min|second|sec)\b|per(?:minute|second)|\b(?:rpm|tpm|rps|tps|qpm|qps)\b|\bconcurren(?:t|cy)\b|\b(?:retry|try again)\s+(?:in|after)\s+\d+(?:\.\d+)?\s*(?:ms|s|secs?|seconds?)\b|"retryDelay"\s*:\s*"\d+(?:\.\d+)?s"|\bresource[\s_]+(?:has\s+been\s+)?exhausted\b/i;
+/**
+ * Markers of a LONG window — a day, a week, a month (spelled out, in a quota id such as `…PerDayPerProjectPerModel`,
+ * or as RPD / TPD), a session / N-hour / usage window, a used-up balance. Where one is named, a short retry hint beside
+ * it (Google's RetryInfo comes with a daily quota too) does not make the limit transient.
+ */
+const longWindowRe = /\bper[\s_-]?(?:day|week|month)\b|per(?:day|week|month)|\b(?:rpd|tpd)\b|\b(?:daily|weekly|monthly)\b|\b(?:session|usage|hourly|\d+-hours?)[\s_]+limit|usage_limit_reached|insufficient_quota|credit balance|out of (?:credits|usage)|billing\s+(?:hard\s+)?limit/i;
+/**
+ * That a text REPORTS a limit being hit rather than describing one — "the API limit is 5 requests per minute" is prose.
+ * The short-window rule needs it beside {@link shortWindowThrottleRe}.
+ */
+const limitHitRe = /\b(?:exceeded|exhausted|reached|hit your|too many|throttl\w*|retry|try again)\b/i;
+/**
+ * Gemini's refusal of a request whose `contents` end on a `model` turn (a 400 INVALID_ARGUMENT with no code of its
+ * own). OpenCode v1's agent loop sends one after a step that finished `unknown` or on its max-steps prompt (upstream
+ * fixed it in v2 only); the bot's prompts are always user turns, and its "continue" is one.
+ */
+const conversationTailRe = /requests ending with a model turn are not supported/i;
 /** Throttling markers that are transient whatever else the text says (the live "not your usage limit" trap). */
 const transientMarkersRe = /rate.?limited|temporarily limiting requests|too many requests|overloaded|\b(429|503|529)\b/i;
 /** A bare "rate limit" (no "-ed"): transient only when no explicit usage-window wording rides along. */
@@ -137,6 +216,27 @@ exports.usageLimitPhraseSource = [
 exports.usageLimitPhrasesRe = new RegExp(exports.usageLimitPhraseSource, 'i');
 /** {@link usageWindowPhrases} compiled — the {@link nonUsageLimitRe} exemption. */
 const usageWindowPhrasesRe = new RegExp(usageWindowPhrases.join('|'), 'i');
+/**
+ * Claude Code's NON-blocking usage notices: the `allowed_warning` status
+ * (`Approaching session limit · resets 11:29pm`, `You've used 90% of your weekly
+ * limit · resets …`, `You're close to your usage limit`) and the switch onto paid
+ * extra usage (`5-hour limit resets 11:29pm - continuing with usage credits`,
+ * `Now using extra usage`). They name the window and its reset exactly like the
+ * block does (`You've hit your session limit · resets …`, status `rejected`), but
+ * the request went through — read as a limit, they stopped a working topic until
+ * the reset. The warning lead-ins are anchored at the text start (after any glyph),
+ * the way the CLI renders them; the extra-usage wordings may sit anywhere.
+ */
+const usageLimitWarningRe = /^\W*(?:approaching\b|you['\u2019]ve used \d+%|you['\u2019]re close to\b)|continuing with (?:usage|extra) (?:credits|usage)|\b(?:now )?using (?:usage credits|extra usage|credits|your usage allocation)\b/i;
+/**
+ * @description Whether a text is a usage WARNING (see {@link usageLimitWarningRe})
+ * — the account is still allowed, so it is never a usage-limit error. Shared with
+ * the Claude scrape detector (`getClaudeAgentErrorLine`), which skips such a row so
+ * a real block further down the same pane delta is still found.
+ */
+function checkIsUsageLimitWarningText(text) {
+    return usageLimitWarningRe.test(text);
+}
 /**
  * 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
@@ -184,8 +284,18 @@ function checkIsUsageLimitText(text) {
  *  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`.
+ *  1a. the refusal of a history that ends on the model's turn ({@link conversationTailRe}) → `conversationTail`.
+ *  1b. a usage WARNING ({@link checkIsUsageLimitWarningText}) → `null`: the
+ *     request went through; it names a window and a reset like the block does.
+ *  1b'. a stated reset ({@link parseResetAt}) within {@link shortStatedResetMaxMs} → `transient`;
+ *     a longer one keeps 1c from calling the limit short. A short one a RETRY verb states ("retry in 40s") that reaches
+ *     the usage-limit branches below (a long window named beside it) is a retry hint: their `resetAt` drops it.
+ *  1c. a SHORT-window throttle ({@link shortWindowThrottleRe}, reported as hit —
+ *     {@link limitHitRe}) that names no long
+ *     window ({@link longWindowRe}) → `transient`: per-minute quotas, concurrency,
+ *     "retry in 40s" — ahead of the quota codes, which they share with daily quotas.
  *  2. an exhausted-quota provider CODE ({@link exhaustedQuotaCodesRe}) or the observed
- *     subscription wording ({@link subscriptionLimitMessageRe}) → `usageLimit`.
+ *     subscription wording ({@link subscriptionLimitMessageRe}, flagged `isUnconfirmed`) → `usageLimit`.
  *     Ahead of transient because these ride a 429 (OpenAI `insufficient_quota`,
  *     Google `RESOURCE_EXHAUSTED`), which the next branch would read as a hiccup.
  *  3. transient (rate-limited, overloaded, 429/503/529, or a bare "rate limit" without an explicit
@@ -204,8 +314,33 @@ function classifyAgentApiError(text, now) {
     if (exports.authErrorPhrasesRe.test(text)) {
         return { kind: 'auth' };
     }
-    if (exhaustedQuotaCodesRe.test(text) || subscriptionLimitMessageRe.test(text)) {
-        return { kind: 'usageLimit', resetAt: parseResetAt(text, now) };
+    if (conversationTailRe.test(text))
+        return { kind: 'conversationTail' };
+    if (checkIsUsageLimitWarningText(text))
+        return null;
+    // The reset the provider states decides a limit's length when it names one: within the first transient retry it is a
+    // throttle, beyond it a window — whatever short-window code (RESOURCE_EXHAUSTED) or quota words ride along. A NAMED
+    // long window (a daily quota id beside Google's "retry in 40s") still wins, and a reset already behind `now` decides
+    // nothing here (a live error naming one is still announced).
+    const statedResetAt = parseResetAt(text, now);
+    const statedResetInMs = statedResetAt === undefined ? null : statedResetAt - now;
+    const isShortStatedReset = statedResetAt !== undefined && checkIsShortStatedReset(statedResetAt, now);
+    const isLongStatedReset = statedResetInMs !== null && statedResetInMs > exports.shortStatedResetMaxMs;
+    const isLongWindowNamed = longWindowRe.test(text);
+    if (isShortStatedReset && limitHitRe.test(text) && !isLongWindowNamed)
+        return { kind: 'transient' };
+    if (shortWindowThrottleRe.test(text) && limitHitRe.test(text) && !isLongWindowNamed && !isLongStatedReset)
+        return { kind: 'transient' };
+    // Past this point it is a usage limit, and a SHORT reset a RETRY verb states beside one is a retry hint, not the
+    // window's end: Google sends a spent daily quota with the same "Please retry in 40.15s" as a per-minute one, and taken
+    // as the reset it set the wait at ~100 s and spent the attempts in minutes. What a "reset(s) in / after" or a clock
+    // states is the window's own end, however close.
+    const limitResetAt = isShortStatedReset && checkIsRetryHintReset(text, now) ? undefined : statedResetAt;
+    if (exhaustedQuotaCodesRe.test(text)) {
+        return { kind: 'usageLimit', resetAt: limitResetAt };
+    }
+    if (subscriptionLimitMessageRe.test(text)) {
+        return { kind: 'usageLimit', resetAt: limitResetAt, isUnconfirmed: true };
     }
     // The observed subscription wording is handled above, including a 429 wrapper.
     // Ordinary rate-limit errors must not fall into the generic limit + retry-hint branch,
@@ -214,22 +349,66 @@ function classifyAgentApiError(text, now) {
         return { kind: 'transient' };
     }
     if (checkIsUsageLimitText(text)) {
-        return { kind: 'usageLimit', resetAt: parseResetAt(text, now) };
+        return { kind: 'usageLimit', resetAt: limitResetAt };
     }
     return null;
 }
+/** A retry verb right before a relative reset: "Please retry in 40s", "try again after 30s". */
+const retryVerbBeforeResetRe = /\b(?:retry|try again)\s*$/i;
+/**
+ * @description Whether the reset {@link parseResetAt} reads in `text` is a retry hint — a relative one stated by a retry
+ * verb — rather than a reset ("Your quota will reset after 4m30s", "resets in 2 minutes"). A machine-form reset is read
+ * ahead of the relative shape and is the window's own end, whatever retry wording rides beside it.
+ */
+function checkIsRetryHintReset(text, now) {
+    if (parseStructuredResetAt(text, now) !== undefined)
+        return false;
+    const match = relativeResetRegex.exec(text);
+    return match !== null && retryVerbBeforeResetRe.test(text.slice(0, match.index));
+}
+/**
+ * The short retry an UNCONFIRMED usage limit ({@link AgentApiErrorClass.isUnconfirmed}) gets first: long enough not to
+ * hammer an account that is really limited, short enough that a refused single request costs the topic two minutes, not
+ * the hours to the window's reset.
+ */
+exports.unconfirmedLimitProbeDelayMs = 2 * msPerMinute;
+/**
+ * @description What an UNCONFIRMED usage limit does: `probe` — a short retry ({@link unconfirmedLimitProbeDelayMs}),
+ * no limit notice; `waitForReset` — the usual usage-limit wait, once the limit is confirmed: it repeated right after
+ * the probe (`isRepeatAfterProbe`), or the account's usage reading shows a window at 100 % (`isUsageExhausted`).
+ */
+function getUnconfirmedLimitAction(input) {
+    return input.isRepeatAfterProbe || input.isUsageExhausted ? 'waitForReset' : 'probe';
+}
+/**
+ * @description Whether a usage-limit error names a reset that is already behind
+ * `now`: the window is over. The boot recovery of a parked error (read against the
+ * time it was written) uses it to resume without announcing a limit; a live error
+ * is announced whatever its reset says.
+ */
+function checkIsUsageLimitWindowOver(cls, now) {
+    return cls.kind === 'usageLimit' && cls.resetAt !== undefined && cls.resetAt <= now;
+}
 /**
  * @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`.
+ * caller treats as "use the fixed delay". Handles five shapes, in order:
+ *  - machine form: an epoch (`"resets_at":…` in a relayed ChatGPT body, Claude's
+ *    `limit reached|<epoch>`) or that body's `"resets_in_seconds":…` — exact, so
+ *    first ({@link parseStructuredResetAt}).
+ *  - relative: "resets in 2h" / "in 45m" / "in 2 hours 30 minutes" → `now` + the
+ *    sum of the parts.
+ *  - dated: "resets Oct 25, 3pm (Europe/Moscow)" — a weekly window, more than a
+ *    day ahead → that date and clock, in the stated zone (or the local one).
  *  - 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
+ *    suffix — an offset (`(UTC)`, `+05:00`) or a named zone (`(Europe/Moscow)`,
+ *    the way Claude Code writes it) — 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`.
+ *  - ISO timestamp anywhere in the text → that instant; a zone-less one only with
+ *    a zone right after it (see {@link resolveIsoResetTime}).
  *
  * 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.
@@ -238,12 +417,24 @@ function classifyAgentApiError(text, now) {
  *   the next occurrence of an absolute clock time.
  */
 function parseResetAt(text, now) {
+    const structuredResetAt = parseStructuredResetAt(text, now);
+    if (structuredResetAt !== undefined)
+        return structuredResetAt;
     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);
+        let durationMs = 0;
+        for (const part of relativeMatch[1].matchAll(relativeResetPartRegex)) {
+            const amount = Number.parseFloat(part[1]);
+            const unit = part[2].toLowerCase();
+            durationMs += amount * (unit.startsWith('d') ? msPerDay : unit.startsWith('h') ? msPerHour : unit.startsWith('m') ? msPerMinute : msPerSecond);
+        }
+        return now + Math.round(durationMs);
+    }
+    const monthDayMatch = monthDayResetRegex.exec(text);
+    if (monthDayMatch) {
+        const resolved = resolveMonthDayResetTime(monthDayMatch, text, now);
+        if (resolved !== undefined)
+            return resolved;
     }
     const clockMatch = clockResetRegex.exec(text);
     if (clockMatch) {
@@ -252,13 +443,24 @@ function parseResetAt(text, now) {
             return resolved;
     }
     const isoMatch = isoTimestampRegex.exec(text);
-    if (isoMatch) {
-        const parsed = Date.parse(isoMatch[0]);
-        if (!Number.isNaN(parsed))
-            return parsed;
-    }
+    if (isoMatch)
+        return resolveIsoResetTime(isoMatch, text);
     return undefined;
 }
+/**
+ * The machine-form reset ({@link structuredResetEpochRegex}, {@link structuredResetWaitRegex}) as epoch ms, or
+ * `undefined` when there is none. An epoch not ahead of `now` is no reset, nor is a zero wait: a stale `|<epoch>` line or
+ * a clock ahead of the provider's would arm a zero delay and spend every attempt in seconds. (The boot recovery reads
+ * against the time the error was written, so the reset it judges over is still read.)
+ */
+function parseStructuredResetAt(text, now) {
+    const epochMatch = structuredResetEpochRegex.exec(text);
+    const epochMs = epochMatch ? Number.parseInt(epochMatch[1] ?? epochMatch[2], 10) * msPerSecond : 0;
+    if (epochMs > now)
+        return epochMs;
+    const waitSeconds = Number.parseInt(structuredResetWaitRegex.exec(text)?.[1] ?? '', 10);
+    return waitSeconds > 0 ? now + waitSeconds * msPerSecond : 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;
@@ -278,6 +480,79 @@ function getZoneOffsetMs(zone) {
     const sign = match[1] === '-' ? -1 : 1;
     return sign * (hours * msPerHour + minutes * msPerMinute);
 }
+/** @description A 12-hour clock (`3`, `pm`) as the hour of a 24-hour day; a bare hour is taken as written. */
+function getHourOfDay(rawHour, meridiem) {
+    const lowerMeridiem = meridiem?.toLowerCase();
+    if (lowerMeridiem === 'pm' && rawHour < 12)
+        return rawHour + 12;
+    if (lowerMeridiem === 'am' && rawHour === 12)
+        return 0;
+    return rawHour;
+}
+/**
+ * Resolve a dated reset ({@link monthDayResetRegex}) to its epoch ms: in the zone named or offset right after it, else
+ * in the process-local zone. Without a written year it is this year's date — or next year's once this year's has passed
+ * (a reset is always ahead). `undefined` for an out-of-range day or clock.
+ */
+function resolveMonthDayResetTime(match, text, now) {
+    const month = monthAbbreviations.indexOf(match[1].toLowerCase()) + 1;
+    const day = Number.parseInt(match[2], 10);
+    const writtenYear = match[3] ? Number.parseInt(match[3], 10) : null;
+    const hour = getHourOfDay(Number.parseInt(match[4], 10), match[6]);
+    const minute = match[5] ? Number.parseInt(match[5], 10) : 0;
+    if (day < 1 || day > 31 || hour >= hoursPerDay || minute >= minutesPerHour)
+        return undefined;
+    const textAfterClock = text.slice(match.index + match[0].length);
+    const namedZone = getTrailingNamedZone(textAfterClock);
+    const zoneMatch = namedZone === null ? trailingZoneRegex.exec(textAfterClock) : null;
+    const offsetMs = zoneMatch ? getZoneOffsetMs(zoneMatch[1]) : undefined;
+    const resolveInYear = (year) => {
+        if (namedZone !== null)
+            return (0, timezone_1.getEpochMsOfZonedWallClock)(namedZone, { year, month, day, hour, minute });
+        if (offsetMs !== undefined)
+            return Date.UTC(year, month - 1, day, hour, minute) - offsetMs;
+        return new Date(year, month - 1, day, hour, minute).getTime();
+    };
+    const currentYear = namedZone !== null ? (0, timezone_1.getZonedWallClock)(namedZone, now).year : new Date(now).getFullYear();
+    const resolved = resolveInYear(writtenYear ?? currentYear);
+    return writtenYear === null && resolved < now ? resolveInYear(currentYear + 1) : resolved;
+}
+/**
+ * Resolve an ISO stamp ({@link isoTimestampRegex}) to epoch ms. One with its own zone is that instant. A ZONE-LESS one
+ * says nothing about its zone (RFC 3339 requires an offset, and no provider documents a zone-less reset): read in the
+ * bot's own zone it could be hours off either way, so it counts only with a zone right after it (`… 23:29 UTC`,
+ * `… (Europe/Moscow)`) — else `undefined`, an unknown reset (the fixed delay, or OpenCode's own Retry-After), not a guess.
+ */
+function resolveIsoResetTime(match, text) {
+    if (match[6] !== undefined) {
+        const parsed = Date.parse(match[0]);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    const [year, month, day, hour, minute] = match.slice(1, 6).map((part) => Number.parseInt(part, 10));
+    const textAfterStamp = text.slice(match.index + match[0].length);
+    const namedZone = getTrailingNamedZone(textAfterStamp);
+    if (namedZone !== null)
+        return (0, timezone_1.getEpochMsOfZonedWallClock)(namedZone, { year, month, day, hour, minute });
+    const zoneMatch = trailingZoneRegex.exec(textAfterStamp);
+    const offsetMs = zoneMatch ? getZoneOffsetMs(zoneMatch[1]) : undefined;
+    return offsetMs === undefined ? undefined : Date.UTC(year, month - 1, day, hour, minute) - offsetMs;
+}
+/** The IANA zone named in parentheses at the start of `textAfterClock`, canonicalized; `null` when none or unknown. */
+function getTrailingNamedZone(textAfterClock) {
+    const zoneName = trailingNamedZoneRegex.exec(textAfterClock)?.[1];
+    return zoneName === undefined ? null : (0, timezone_1.getCanonicalTimezone)(zoneName);
+}
+/**
+ * The next instant at or after `now` at which `timezone` reads `hour:minute`: today's in that zone, or tomorrow's
+ * once today's has passed. Daylight saving is the zone's own (`Intl`), not a fixed offset.
+ */
+function resolveNextZonedClockTime(timezone, hour, minute, now) {
+    const today = (0, timezone_1.getZonedWallClock)(timezone, now);
+    const todayMs = (0, timezone_1.getEpochMsOfZonedWallClock)(timezone, { year: today.year, month: today.month, day: today.day, hour, minute });
+    if (todayMs >= now)
+        return todayMs;
+    return (0, timezone_1.getEpochMsOfZonedWallClock)(timezone, { year: today.year, month: today.month, day: today.day + 1, hour, minute });
+}
 /**
  * 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
@@ -286,18 +561,16 @@ function getZoneOffsetMs(zone) {
  * 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;
+    const hour = getHourOfDay(Number.parseInt(match[1], 10), match[3]);
     if (hour < 0 || hour >= hoursPerDay || minute < 0 || minute >= minutesPerHour) {
         return undefined;
     }
-    const zoneMatch = trailingZoneRegex.exec(text.slice(match.index + match[0].length));
+    const textAfterClock = text.slice(match.index + match[0].length);
+    const namedZone = getTrailingNamedZone(textAfterClock);
+    if (namedZone !== null)
+        return resolveNextZonedClockTime(namedZone, hour, minute, now);
+    const zoneMatch = trailingZoneRegex.exec(textAfterClock);
     const offsetMs = zoneMatch ? getZoneOffsetMs(zoneMatch[1]) : undefined;
     if (offsetMs !== undefined) {
         // Shift onto the zone's timeline, snap to that zone's midnight, then shift
@@ -326,6 +599,8 @@ function resolveNextClockTime(match, text, now) {
  * time never overflows the timer.
  *  - transient: {@link transientBackoffMinutes}[attempt-1]; giveUp once attempt
  *    exceeds {@link transientMaxAttempts}.
+ *  - conversationTail: {@link conversationTailRetryDelayMs}; giveUp once attempt exceeds
+ *    {@link conversationTailMaxAttempts}.
  *  - usageLimit: `resetAt` present → `resetAt - now + resetBufferMs`; else
  *    {@link usageLimitDefaultMs}; giveUp once attempt exceeds
  *    {@link usageLimitMaxAttempts}.
@@ -335,6 +610,9 @@ function getRetryPlan(args) {
     // reached); guard so it can never fall through into the usageLimit branch.
     if (args.kind === 'auth')
         return { giveUp: true };
+    if (args.kind === 'conversationTail') {
+        return args.attempt > exports.conversationTailMaxAttempts ? { giveUp: true } : { delayMs: exports.conversationTailRetryDelayMs };
+    }
     if (args.kind === 'transient') {
         if (args.attempt > exports.transientMaxAttempts)
             return { giveUp: true };