@indigoai-us/hq-cli 5.345.127 → 5.345.129

package/dist/lib/lanes/quota-notice.d.ts

@@ -1,24 +1,24 @@
 /**
- * Tell a lane's senior when a provider 429 put an account on a quota hold.
+ * Tell a lane's senior that a provider usage limit ended that lane.
  *
- * An account-wide hold stops every lane on that account, so the senior needs
- * to see it with the provider's own words and the command that lifts it. One
- * message per (provider, account, hold), so several lanes failing on the same
- * hold produce one notice.
+ * A 429 never holds the account (owner decision 2026-10-14): the lane that
+ * hit it ends resumable and the senior decides. One message per lane exit,
+ * keyed by lane id and record version, so a re-read of the same exit or a
+ * retried append does not send it twice.
  */
-import type { QuotaState } from "./quota.js";
-import { type LaneProvider, type LaneRecord } from "./types.js";
-export interface QuotaHoldNotice {
+import type { QuotaSignal } from "./quota.js";
+import { type LaneRecord } from "./types.js";
+export interface QuotaNotice {
     message_id: string;
     text: string;
 }
-/** Build the notice for the account's current hold, or null when there is none. */
-export declare function quotaHoldNotice(state: QuotaState, provider: LaneProvider, accountId: string, laneId: string): QuotaHoldNotice | null;
+/** The notice for a lane that ended on a usage limit or a needs-credits refusal. */
+export declare function quotaLaneNotice(lane: Pick<LaneRecord, "lane_id" | "version" | "provider" | "account" | "model" | "state" | "terminal_reason" | "quota_reset_at">, quota: QuotaSignal | null): QuotaNotice;
 /**
  * Deliver the notice to the lane's senior inbox. A session senior gets it in
  * its monitor-session inbox, a lane senior in that lane's dropbox. The notice
  * is always written to stderr as well, so a senior with no inbox still has it
  * in the watcher log. Returns where it was delivered.
  */
-export declare function deliverQuotaHoldNotice(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "senior">, notice: QuotaHoldNotice, at: string): "session_inbox" | "lane_inbox" | "stderr_only";
+export declare function deliverQuotaNotice(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "senior">, notice: QuotaNotice, at: string): "session_inbox" | "lane_inbox" | "stderr_only";
 //# sourceMappingURL=quota-notice.d.ts.map

package/dist/lib/lanes/quota-notice.js

@@ -1,39 +1,30 @@
 /**
- * Tell a lane's senior when a provider 429 put an account on a quota hold.
+ * Tell a lane's senior that a provider usage limit ended that lane.
  *
- * An account-wide hold stops every lane on that account, so the senior needs
- * to see it with the provider's own words and the command that lifts it. One
- * message per (provider, account, hold), so several lanes failing on the same
- * hold produce one notice.
+ * A 429 never holds the account (owner decision 2026-10-14): the lane that
+ * hit it ends resumable and the senior decides. One message per lane exit,
+ * keyed by lane id and record version, so a re-read of the same exit or a
+ * retried append does not send it twice.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { monitorSessionDir } from "../monitor.js";
 import { appendDropboxMessageOnce, appendDropboxMessageOnceAtPath } from "./dropbox.js";
 import { LANE_PROVIDERS } from "./types.js";
-/** Build the notice for the account's current hold, or null when there is none. */
-export function quotaHoldNotice(state, provider, accountId, laneId) {
-    const account = state.providers[provider]?.[accountId];
-    const holdUntil = account?.all_models_quota_reset_at;
-    if (!account || !holdUntil)
-        return null;
-    const said = account.provider_text ? `Provider said: "${account.provider_text}".` : "Provider gave no message text.";
-    const clear = `If the account is not actually exhausted (check /usage), clear the hold with: hq lanes accounts clear-quota ${provider} ${accountId}`;
+/** The notice for a lane that ended on a usage limit or a needs-credits refusal. */
+export function quotaLaneNotice(lane, quota) {
+    const providerReset = quota?.provider_reset_at ?? quota?.quota_reset_at ?? lane.quota_reset_at;
+    const what = lane.terminal_reason === "account_model_unavailable"
+        ? `cannot run model ${lane.model ?? "(unknown)"}${quota?.marker ? ` (${quota.marker})` : ""}`
+        : "hit the provider usage limit";
     const lines = [
-        `Quota hold: ${provider} account ${accountId} is held until ${holdUntil}; no lane will run on it until then. Set by lane ${laneId}.`,
-        said,
+        `Lane ${lane.lane_id} ${what} on ${lane.provider} account ${lane.account ?? "(none)"} and stopped as ${lane.state}.`,
+        providerReset ? `The provider says the limit resets at ${providerReset}.` : "The provider did not name a reset time.",
     ];
-    if (account.reset_source === "unconfirmed" && account.unconfirmed_reset_at) {
-        lines.push(`The provider named a reset at ${account.unconfirmed_reset_at}. That is more than a day away, so this is a short hold; the account gets the full hold only if the next lane after it also gets a 429.`);
-    }
-    else if (account.reset_source === "derived") {
-        lines.push("The provider named no reset time, so this is the default hold.");
-    }
-    lines.push(clear);
-    return {
-        message_id: `quota-hold:${provider}:${accountId}:${holdUntil}`,
-        text: lines.join("\n"),
-    };
+    if (quota?.provider_text)
+        lines.push(`Provider said: "${quota.provider_text}".`);
+    lines.push("No account hold was set; other lanes keep using this account.", `To continue this lane: hq lanes resume ${lane.lane_id} (pass --account <id> to use another account).`);
+    return { message_id: `quota-limit:${lane.lane_id}:${lane.version}`, text: lines.join(" ") };
 }
 /**
  * Deliver the notice to the lane's senior inbox. A session senior gets it in
@@ -41,9 +32,9 @@ export function quotaHoldNotice(state, provider, accountId, laneId) {
  * is always written to stderr as well, so a senior with no inbox still has it
  * in the watcher log. Returns where it was delivered.
  */
-export function deliverQuotaHoldNotice(hqRoot, lane, notice, at) {
-    process.stderr.write(`hq lanes: ${notice.text.replace(/\n/g, " ")}\n`);
-    const message = { at, message_id: notice.message_id, kind: "quota_hold", text: notice.text };
+export function deliverQuotaNotice(hqRoot, lane, notice, at) {
+    process.stderr.write(`hq lanes: ${notice.text}\n`);
+    const message = { at, message_id: notice.message_id, kind: "quota_limit", text: notice.text };
     if (lane.senior.kind === "lane" && lane.senior.id) {
         appendDropboxMessageOnce(hqRoot, lane.senior.id, message);
         return "lane_inbox";

package/dist/lib/lanes/quota.d.ts

@@ -17,26 +17,14 @@
  * per (account, model), plus an account-wide reset when the text is a
  * usage limit rather than a switch-model refusal.
  *
- * A single 429 is not trusted with a multi-day hold. When the provider names
- * a reset more than a day away, the first 429 holds the account only for the
- * short default hold and keeps the named reset as `unconfirmed_reset_at`. A
- * second 429 from a lane that ran after that short hold expired confirms the
- * reset; a successful turn drops it. (Measured 2026-10-13: account a returned
- * "You've hit your weekly limit · resets Oct 16 at 1am (America/Denver)"
- * while the owner's /usage showed the week at 43%.)
+ * A recorded 429 never holds the account (owner decision 2026-10-14, after
+ * the 2026-10-13 incident where one 429 on account a blocked every Claude
+ * lane until Friday). The reset times and provider text stay here as
+ * information for `hq lanes capacity`, `hq lanes accounts list` and the
+ * senior notice; only a needs-credits marker skips an account, for that model.
  */
 import type { LaneProvider } from "./types.js";
 export declare const QUOTA_STATE_REL: string;
-/**
- * Claude quota holds are off. Removed by owner directive on 2026-10-14: a
- * false weekly-limit 429 held every Claude lane for days while the account
- * still had capacity. A Claude 429 still fails that lane over to another
- * account; it never blocks the account for later lanes, and stored Claude
- * holds are ignored on read. `HQ_LANES_CLAUDE_QUOTA_HOLDS=1` turns the old
- * behavior back on; the test suite sets it to keep the hold machinery covered.
- */
-export declare const CLAUDE_QUOTA_HOLDS_ENV = "HQ_LANES_CLAUDE_QUOTA_HOLDS";
-export declare function providerHasQuotaHolds(provider: LaneProvider): boolean;
 export declare const QUOTA_SCHEMA_VERSION = "hq-lanes-quota.v1";
 export interface ModelQuota {
     quota_reset_at?: string;
@@ -46,26 +34,27 @@ export interface ModelQuota {
 }
 /**
  * `parsed`: the provider's own reset. `derived`: the default hold for a 429
- * with no parseable reset. `unconfirmed`: a short hold standing in for a
- * provider reset more than a day away that a second 429 has not confirmed.
+ * with no parseable reset. `unconfirmed` is read from older quota files only.
  */
 export type QuotaResetSource = "parsed" | "derived" | "unconfirmed";
-/** A provider reset further away than this needs a second 429 before it holds. */
-export declare const QUOTA_CONFIRM_HORIZON_MS: number;
 export interface AccountQuota {
     /** Set when the 429 is an account-wide usage limit with a reset time. */
     all_models_quota_reset_at?: string;
     /**
-     * Whether `all_models_quota_reset_at` came from a parsed provider reset or
-     * the configured default hold applied to a 429 with no parseable reset.
+     * Whether `all_models_quota_reset_at` is the provider's own reset
+     * (`parsed`) or a shorter hold HQ chose (`derived`): the configured
+     * default hold for a 429 with no reset, or the capped first-strike hold
+     * when the provider's reset is further away than that.
      */
     reset_source?: QuotaResetSource;
     /**
-     * The provider's named reset, held back until a second 429 on a fresh
-     * probe confirms it. Set only while `reset_source` is `unconfirmed`.
+     * The provider's own reset time from the most recent 429, kept even when
+     * the recorded reset is shorter. Information only; nothing gates on it.
      */
-    unconfirmed_reset_at?: string;
-    /** Raw provider text from the 429 that set the current hold. */
+    provider_reset_at?: string;
+    /** When the most recent account-wide 429 was observed. */
+    last_quota_hit_at?: string;
+    /** Raw provider text from the most recent account-wide 429. */
     provider_text?: string;
     models: Record<string, ModelQuota>;
 }
@@ -83,18 +72,36 @@ export interface QuotaSignal {
     account_wide?: boolean;
     /** Set by applyDefaultQuotaHold: whether the reset is the provider's or the default hold. */
     reset_source?: QuotaResetSource;
-    /** The provider's raw result text, kept so the hold can be shown to the senior. */
+    /** The provider's own reset, parsed or structured, before any cap. */
+    provider_reset_at?: string;
+    /** When the 429 was observed. */
+    observed_at?: string;
+    /** The provider's raw result text, kept so the senior notice can quote it. */
     provider_text?: string;
 }
 /**
- * A 429 whose message names no reset time and no credits wording would
- * otherwise record no hold at all, and the next lane on the account would
- * hit the same 429. Give such a signal the provider's configured default
- * hold (`quota_default_hold_ms`, fifteen minutes unless set) as its reset,
- * marked `derived`; a signal that already carries a reset keeps it, marked
- * `parsed`. A per-model credits refusal is untouched.
+ * Decide the hold a 429 records (incident 2026-10-13: one 429 on the wrong
+ * subscription held the only Claude account for three days).
+ *
+ * - A per-model credits refusal is untouched.
+ * - A 429 with no reset gets the provider's configured default hold
+ *   (`quota_default_hold_ms`, fifteen minutes unless set), marked `derived`.
+ * - A 429 with a provider reset is capped to the same default hold on its
+ *   own. The provider reset is kept on the signal as `provider_reset_at`;
+ *   recordAccountQuota extends the hold to it only when a fresh probe hits a
+ *   repeat 429 before that reset. A reset nearer than the cap is used as is
+ *   and marked `parsed`.
  */
 export declare function applyDefaultQuotaHold(signal: QuotaSignal, defaultHoldMs: number, now: Date): QuotaSignal;
+/**
+ * True when the signal is a fresh 429 on an account whose previous 429 named
+ * a provider reset that has not arrived yet: the short first-strike hold
+ * expired (or was cleared and re-recorded), a new probe ran, and the
+ * provider refused again. The provider's reset is then believed.
+ */
+export declare function isRepeatQuotaHit(current: AccountQuota | undefined, signal: QuotaSignal, now: Date): boolean;
+/** "UTC" or an IANA zone the runtime knows, e.g. America/Denver. */
+export declare function isKnownTimeZone(zone: string): boolean;
 export declare function quotaStatePath(hqRoot: string): string;
 export declare function loadQuotaState(hqRoot: string): QuotaState;
 /**
@@ -112,11 +119,6 @@ export declare function loadQuotaState(hqRoot: string): QuotaState;
  * past. An explicit provider year is kept as stated.
  */
 export declare function parseProviderResetTime(text: string, now: Date): string | null;
-/**
- * Read only `api_error_status`, `is_error`, and `result` off the last
- * `type: "result"` object. Nothing else from the payload is returned, and
- * this function does not log.
- */
 export interface QuotaResultFields {
     api_error_status: unknown;
     is_error: unknown;
@@ -129,16 +131,15 @@ export interface QuotaResultFields {
 }
 /** Epoch seconds, epoch milliseconds, or an ISO string, to ISO; null otherwise. */
 export declare function normalizeStructuredReset(value: unknown): string | null;
+/**
+ * Read only `api_error_status`, `is_error`, `result`, and a structured
+ * reset off the last `type: "result"` object. Nothing else from the payload
+ * is returned, and this function does not log.
+ */
 export declare function quotaFieldsFromOutput(text: string): QuotaResultFields | null;
 export declare function quotaSignalFromFields(fields: QuotaResultFields, model: string | undefined, now: Date): QuotaSignal | null;
 export declare function readQuotaSignal(runDir: string, model: string | undefined, now: Date, workerOutOffset?: number): QuotaSignal | null;
-export interface RecordAccountQuotaOptions {
-    /** When the 429 was observed. Enables the far-reset confirmation gate. */
-    now: Date;
-    /** Hold applied while a far provider reset is unconfirmed (the default hold). */
-    unconfirmedHoldMs: number;
-}
-export declare function recordAccountQuota(hqRoot: string, provider: LaneProvider, accountId: string, incoming: QuotaSignal, options?: RecordAccountQuotaOptions): QuotaState;
+export declare function recordAccountQuota(hqRoot: string, provider: LaneProvider, accountId: string, incoming: QuotaSignal, now?: Date): QuotaState;
 export interface ClearedModelQuotaReset {
     model: string;
     quota_reset_at: string;
@@ -166,13 +167,31 @@ export interface QuotaBlock {
     model?: string;
 }
 /**
- * Skip an account only for the models it cannot run. An account-wide reset
- * blocks every model. A needs-credits marker blocks only that model, with
- * no expiry. A past reset does not block.
+ * Skip an account only for a model it cannot run at all: a needs-credits
+ * marker blocks that model, with no expiry.
+ *
+ * A recorded 429 never blocks (owner decision, incident 2026-10-13). The
+ * lane that hit it ends resumable and its senior decides; other lanes keep
+ * using the account. The reset times stay in quota.json as information
+ * (`accountQuotaView`, `quotaHitInfo`).
  */
-export declare function quotaBlockFor(state: QuotaState, provider: LaneProvider, accountId: string, model: string | undefined, now: Date): QuotaBlock;
+export declare function quotaBlockFor(state: QuotaState, provider: LaneProvider, accountId: string, model: string | undefined, _now: Date): QuotaBlock;
+/** The last recorded 429 on an account, for display only. */
+export interface QuotaHitInfo {
+    last_quota_hit_at?: string;
+    /** The provider's own reset time from the last 429, when it named one. */
+    provider_reset_at?: string;
+    /** True while the provider's reset is still ahead. Informational; nothing gates on it. */
+    provider_reset_pending: boolean;
+}
+export declare function quotaHitInfo(state: QuotaState, provider: LaneProvider, accountId: string, now: Date): QuotaHitInfo | undefined;
 export interface AccountQuotaView {
     quota_reset_at: string | null;
+    /** "parsed" when the hold is the provider's reset, "derived" when HQ shortened it. */
+    quota_reset_source?: QuotaResetSource;
+    /** The provider's own reset from the last 429, when the hold was capped below it. */
+    provider_reset_at?: string;
+    last_quota_hit_at?: string;
     model_quota: Array<{
         model: string;
         quota_reset_at?: string;