@indigoai-us/hq-cli 5.345.123 → 5.345.125

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

@@ -10,6 +10,45 @@
 import { type LaneRecord, type LaneProvider } from "./types.js";
 import type { LanesConfig } from "./types.js";
 export declare const PROVIDER_HOME_ENV: Record<LaneProvider, string>;
+/**
+ * Claude Code keys its OS keychain credential by `CLAUDE_CONFIG_DIR`: with
+ * the variable unset it reads the plain `Claude Code-credentials` item, and
+ * with it set, even to the default `~/.claude`, it reads a hash-suffixed item
+ * for that path. Setting the variable for the default home therefore makes a
+ * lane use a different login than the interactive session (incident
+ * 2026-10-13). A Claude account whose home is the default is launched with
+ * the variable unset instead.
+ */
+export declare function isDefaultProviderHome(provider: LaneProvider, home: string, homedir?: () => string): boolean;
+/**
+ * Return a copy of `base` with the provider home variable set to `home`,
+ * or, for a Claude account on the default home, with the variable removed
+ * so the worker and the interactive session share one credential.
+ */
+export declare function withProviderHomeEnv(base: NodeJS.ProcessEnv, provider: LaneProvider, home: string, homedir?: () => string): NodeJS.ProcessEnv;
+/** Who `claude auth status` says a home is logged in as. Never a token. */
+export interface ClaudeIdentity {
+    email: string | null;
+    org_id: string | null;
+    org_name: string | null;
+    subscription_type: string | null;
+}
+/**
+ * Email and org from a `claude auth status` JSON payload. Only identity
+ * fields are kept; everything else in the payload is dropped.
+ */
+export declare function claudeIdentityFromProbe(result: AccountStatusProbeResult): ClaudeIdentity | null;
+/** "me@example.com (Acme)" label for hold and failover messages. */
+export declare function describeClaudeIdentity(identity: ClaudeIdentity | undefined | null): string | null;
+/**
+ * The identity the interactive session uses: `claude auth status` with no
+ * `CLAUDE_CONFIG_DIR`. Null when the probe fails or names nobody.
+ */
+export declare function probeInteractiveClaudeIdentity(probe: NonNullable<AccountDeps["probe"]>, base?: NodeJS.ProcessEnv): ClaudeIdentity | null;
+/** True when both identities are known and name different logins; null when unknown. */
+export declare function claudeIdentityDiffers(a: ClaudeIdentity | undefined | null, b: ClaudeIdentity | undefined | null): boolean | null;
+/** The operator command that lifts a recorded quota hold. */
+export declare function clearQuotaCommand(provider: LaneProvider, accountId: string): string;
 export declare const AUTH_JSON_NAME = "auth.json";
 export declare const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
 /**
@@ -28,6 +67,7 @@ export interface AccountStatusProbeResult {
 export interface AccountDeps {
     existsSync: (p: string) => boolean;
     hostname?: string;
+    homedir?: () => string;
     /** Provider status output is parsed for a boolean only; it is never printed. */
     probe?: (command: string, args: string[], env: NodeJS.ProcessEnv) => AccountStatusProbeResult;
     env?: NodeJS.ProcessEnv;
@@ -64,6 +104,8 @@ export interface AccountStatus {
     id: string;
     home: string;
     home_source?: "host" | "default";
+    /** Email and org from the provider status command, when it was consulted. */
+    identity?: ClaudeIdentity;
     enabled: boolean;
     disabled_reason?: string;
     /** Present in personal/lanes/config.json. */
@@ -112,6 +154,10 @@ export declare function resolveAccount(provider: LaneProvider, requestedId: stri
 export declare function authJsonPath(home: string): string;
 export declare function accountStatus(provider: LaneProvider, accountId: string, config: LanesConfig, deps?: AccountDeps): AccountStatus;
 export declare function listAccountStatuses(provider: LaneProvider, config: LanesConfig, deps?: AccountDeps): AccountStatus[];
-/** Environment assignment the worker process should receive. */
-export declare function accountEnv(resolved: ResolvedAccount): Record<string, string>;
+/**
+ * Environment assignment the worker process should receive. Empty for a
+ * Claude account on the default home, which runs with the variable unset
+ * (see isDefaultProviderHome).
+ */
+export declare function accountEnv(resolved: ResolvedAccount, homedir?: () => string): Record<string, string>;
 //# sourceMappingURL=accounts.d.ts.map

package/dist/lib/lanes/accounts.js

@@ -8,11 +8,12 @@
  * module never reads, prints, copies, or hashes credential files.
  */
 import * as fs from "node:fs";
+import * as os from "node:os";
 import { effectiveAccountHome } from "./account-home.js";
 import * as path from "node:path";
 import { AccountResolutionError } from "./errors.js";
 import { isTerminalLaneState } from "./types.js";
-import { accountMaxRunning } from "./config.js";
+import { DEFAULT_ACCOUNT_HOMES, accountMaxRunning, canonicalizeHome } from "./config.js";
 import { listLaneIds, readLane } from "./store.js";
 import { loadQuotaState, quotaBlockFor } from "./quota.js";
 export const PROVIDER_HOME_ENV = {
@@ -20,6 +21,112 @@ export const PROVIDER_HOME_ENV = {
     codex: "CODEX_HOME",
     grok: "GROK_HOME",
 };
+/**
+ * Claude Code keys its OS keychain credential by `CLAUDE_CONFIG_DIR`: with
+ * the variable unset it reads the plain `Claude Code-credentials` item, and
+ * with it set, even to the default `~/.claude`, it reads a hash-suffixed item
+ * for that path. Setting the variable for the default home therefore makes a
+ * lane use a different login than the interactive session (incident
+ * 2026-10-13). A Claude account whose home is the default is launched with
+ * the variable unset instead.
+ */
+export function isDefaultProviderHome(provider, home, homedir = () => os.homedir()) {
+    const deps = {
+        homedir,
+        realpathSync: (p) => fs.realpathSync(p),
+        existsSync: (p) => fs.existsSync(p),
+    };
+    try {
+        return canonicalizeHome(home, deps) === canonicalizeHome(DEFAULT_ACCOUNT_HOMES[provider], deps);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Return a copy of `base` with the provider home variable set to `home`,
+ * or, for a Claude account on the default home, with the variable removed
+ * so the worker and the interactive session share one credential.
+ */
+export function withProviderHomeEnv(base, provider, home, homedir) {
+    const next = { ...base };
+    const envVar = PROVIDER_HOME_ENV[provider];
+    if (provider === "claude" && isDefaultProviderHome(provider, home, homedir)) {
+        delete next[envVar];
+    }
+    else {
+        next[envVar] = home;
+    }
+    return next;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+/**
+ * Email and org from a `claude auth status` JSON payload. Only identity
+ * fields are kept; everything else in the payload is dropped.
+ */
+export function claudeIdentityFromProbe(result) {
+    const text = result.stdout.trim();
+    if (!text.startsWith("{"))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const rec = parsed;
+    const identity = {
+        email: optionalString(rec.email),
+        org_id: optionalString(rec.orgId),
+        org_name: optionalString(rec.orgName),
+        subscription_type: optionalString(rec.subscriptionType),
+    };
+    if (!identity.email && !identity.org_id && !identity.org_name)
+        return null;
+    return identity;
+}
+/** "me@example.com (Acme)" label for hold and failover messages. */
+export function describeClaudeIdentity(identity) {
+    if (!identity)
+        return null;
+    const org = identity.org_name ?? identity.org_id;
+    if (identity.email && org)
+        return `${identity.email} (${org})`;
+    return identity.email ?? org;
+}
+/**
+ * The identity the interactive session uses: `claude auth status` with no
+ * `CLAUDE_CONFIG_DIR`. Null when the probe fails or names nobody.
+ */
+export function probeInteractiveClaudeIdentity(probe, base = process.env) {
+    const bare = { ...base };
+    delete bare[PROVIDER_HOME_ENV.claude];
+    try {
+        return claudeIdentityFromProbe(probe("claude", ["auth", "status"], bare));
+    }
+    catch {
+        return null;
+    }
+}
+/** True when both identities are known and name different logins; null when unknown. */
+export function claudeIdentityDiffers(a, b) {
+    if (!a || !b)
+        return null;
+    if (a.email && b.email)
+        return a.email.toLowerCase() !== b.email.toLowerCase();
+    if (a.org_id && b.org_id)
+        return a.org_id !== b.org_id;
+    return null;
+}
+/** The operator command that lifts a recorded quota hold. */
+export function clearQuotaCommand(provider, accountId) {
+    return `hq lanes accounts clear-quota ${provider} ${accountId}`;
+}
 export const AUTH_JSON_NAME = "auth.json";
 export const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
 /**
@@ -161,23 +268,34 @@ function modelForAccount(provider, accountId, config, ctx) {
         return providerModel.trim();
     return undefined;
 }
-function throwIfQuotaBlocked(block, provider, accountId) {
+/** "account "a" (me@example.com (Acme))" when the identity is known. */
+function accountLabel(accountId, identity) {
+    const who = describeClaudeIdentity(identity);
+    return `Account ${JSON.stringify(accountId)}${who ? ` (${who})` : ""}`;
+}
+function throwIfQuotaBlocked(block, provider, accountId, identity) {
     if (!block.blocked || !block.reason)
         return;
     const model = block.model ?? "(no model)";
+    const label = accountLabel(accountId, identity);
+    const identityFields = identity ? { identity } : {};
     if (block.reason === "account_model_unavailable") {
-        throw new AccountResolutionError("account_model_unavailable", `Account ${JSON.stringify(accountId)} cannot run model ${model}: ${block.marker ?? "needs credits"}`, {
+        throw new AccountResolutionError("account_model_unavailable", `${label} cannot run model ${model}: ${block.marker ?? "needs credits"}`, {
             provider,
             account: accountId,
             model: block.model ?? null,
             marker: block.marker ?? null,
+            ...identityFields,
         });
     }
-    throw new AccountResolutionError("account_quota_exhausted", `Account ${JSON.stringify(accountId)} is out of quota${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""} for model ${model}`, {
+    const clear = clearQuotaCommand(provider, accountId);
+    throw new AccountResolutionError("account_quota_exhausted", `${label} is out of quota${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""} for model ${model}. Clear the hold with: ${clear}`, {
         provider,
         account: accountId,
         model: block.model ?? null,
         quota_reset_at: block.quota_reset_at ?? null,
+        clear_command: clear,
+        ...identityFields,
     });
 }
 function boundAccount(provider, id, account, hostname) {
@@ -205,15 +323,19 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
         throw new AccountResolutionError("no_enabled_account", `No enabled account for provider ${provider}`, { provider, ineligible: "none_enabled" });
     }
     const proven = [];
+    const identities = new Map();
     for (const id of enabled) {
         const status = accountStatus(provider, id, config, {
             existsSync,
             ...(ctx.accountDeps?.probe ? { probe: ctx.accountDeps.probe } : {}),
             ...(ctx.accountDeps?.env ? { env: ctx.accountDeps.env } : {}),
+            ...(ctx.accountDeps?.homedir ? { homedir: ctx.accountDeps.homedir } : {}),
             ...(ctx.hostname !== undefined ? { hostname: ctx.hostname } : {}),
         });
         if (status.logged_in === true)
             proven.push(id);
+        if (status.identity)
+            identities.set(id, status.identity);
     }
     if (proven.length === 0) {
         throw new AccountResolutionError("no_enabled_account", `No logged-in account for provider ${provider}`, { provider, ineligible: "none_logged_in", enabled });
@@ -247,17 +369,25 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
                 account: id,
                 reason: block.reason,
                 quota_reset_at: block.quota_reset_at ?? null,
+                identity: identities.get(id) ?? null,
+                clear_command: clearQuotaCommand(provider, id),
             }));
-            throw new AccountResolutionError("account_quota_exhausted", `All logged-in accounts for ${provider} are quota-limited for the selected model`, {
+            const held = blocked
+                .filter(({ block }) => block.reason === "account_quota_exhausted")
+                .map(({ id, block }) => `${accountLabel(id, identities.get(id))}${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""}; clear with: ${clearQuotaCommand(provider, id)}`)
+                .join("; ");
+            throw new AccountResolutionError("account_quota_exhausted", `All logged-in accounts for ${provider} are quota-limited for the selected model. ${held}`, {
                 provider,
                 account: earliest.id,
                 model: earliest.block.model ?? null,
                 quota_reset_at: resetTimes[0] ?? null,
                 account_reasons: resetsByAccount,
+                ...(identities.get(earliest.id) ? { identity: identities.get(earliest.id) } : {}),
+                clear_command: clearQuotaCommand(provider, earliest.id),
             });
         }
         const sample = proven[0];
-        throwIfQuotaBlocked(blocked[0].block, provider, sample);
+        throwIfQuotaBlocked(blocked[0].block, provider, sample, identities.get(sample));
     }
     const underCap = runnable.filter((id) => {
         const cap = accountMaxRunning(providerCfg, id);
@@ -298,6 +428,16 @@ export function resolveAccount(provider, requestedId, config, ctx = {}) {
         if (ctx.hqRoot !== undefined) {
             const now = ctx.now ?? new Date();
             const block = quotaBlockFor(loadQuotaState(ctx.hqRoot), provider, requestedId, modelForAccount(provider, requestedId, config, ctx), now);
+            if (block.blocked && provider === "claude" && ctx.accountDeps?.probe) {
+                const status = accountStatus(provider, requestedId, config, {
+                    existsSync: ctx.existsSync ?? ((p) => fs.existsSync(p)),
+                    probe: ctx.accountDeps.probe,
+                    ...(ctx.accountDeps.env ? { env: ctx.accountDeps.env } : {}),
+                    ...(ctx.accountDeps.homedir ? { homedir: ctx.accountDeps.homedir } : {}),
+                    ...(ctx.hostname !== undefined ? { hostname: ctx.hostname } : {}),
+                });
+                throwIfQuotaBlocked(block, provider, requestedId, status.identity);
+            }
             throwIfQuotaBlocked(block, provider, requestedId);
         }
         return boundAccount(provider, requestedId, account, ctx.hostname);
@@ -328,14 +468,16 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
     const present = homeExists && hasCredentialFile(provider, effective.home, deps.existsSync);
     let auth_state = homeExists ? authStateFor(provider, present) : "home_missing";
     let logged_in = homeExists ? loggedInFromAuthState(auth_state) : false;
+    let identity;
     if (homeExists && !present && provider === "claude" && deps.probe !== undefined) {
         try {
-            const result = deps.probe("claude", ["auth", "status"], { ...(deps.env ?? process.env), CLAUDE_CONFIG_DIR: effective.home });
+            const result = deps.probe("claude", ["auth", "status"], withProviderHomeEnv(deps.env ?? process.env, "claude", effective.home, deps.homedir));
             const providerStatus = claudeLoginStatus(result);
             if (providerStatus !== null) {
                 auth_state = "status";
                 logged_in = providerStatus;
             }
+            identity = claudeIdentityFromProbe(result) ?? undefined;
         }
         catch {
             process.stderr.write(`hq lanes: Claude auth status probe failed for account ${accountId}\n`);
@@ -352,6 +494,8 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
         auth_state,
         envVar,
     };
+    if (identity)
+        status.identity = identity;
     if (account.disabled_reason !== undefined) {
         status.disabled_reason = account.disabled_reason;
     }
@@ -381,8 +525,15 @@ function claudeLoginStatus(result) {
         return false;
     return null;
 }
-/** Environment assignment the worker process should receive. */
-export function accountEnv(resolved) {
+/**
+ * Environment assignment the worker process should receive. Empty for a
+ * Claude account on the default home, which runs with the variable unset
+ * (see isDefaultProviderHome).
+ */
+export function accountEnv(resolved, homedir) {
+    if (resolved.provider === "claude" && isDefaultProviderHome("claude", resolved.home, homedir)) {
+        return {};
+    }
     return { [resolved.envVar]: resolved.home };
 }
 //# sourceMappingURL=accounts.js.map

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

@@ -40,8 +40,8 @@ export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO,
 export type { CpuTimes, ThrottleAdmitReason, ThrottleDecision, ThrottleDeferReason, ThrottleDeps, ThrottleState, } from "./throttle.js";
 export { effectiveAccountHome, } from "./account-home.js";
 export type { EffectiveAccountHome, } from "./account-home.js";
-export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
-export type { AccountResolveContext, AccountStatus, AuthState, ResolvedAccount, } from "./accounts.js";
+export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, claudeIdentityDiffers, claudeIdentityFromProbe, clearQuotaCommand, credentialPaths, describeClaudeIdentity, hasCredentialFile, isCredentialProven, isDefaultProviderHome, isLoggedOut, probeInteractiveClaudeIdentity, withProviderHomeEnv, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
+export type { AccountResolveContext, AccountStatus, AuthState, ClaudeIdentity, ResolvedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
 export type { LivenessDeps, LivenessEventKind, LivenessIndex, SessionIndexEntry, } from "./liveness.js";
 export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";

package/dist/lib/lanes/index.js

@@ -22,7 +22,7 @@ export { ENVELOPE_INVALID_REASON, decideEnvelopeRepair, emitMeshSoft, envelopeQu
 export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, laneCanEmit, parseLaneMeshEvent, progressEventDue, toWireThreadEvent, } from "./mesh-events.js";
 export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, VM_STAT_BIN, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, parseVmStatAvailableMb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
 export { effectiveAccountHome, } from "./account-home.js";
-export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
+export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, claudeIdentityDiffers, claudeIdentityFromProbe, clearQuotaCommand, credentialPaths, describeClaudeIdentity, hasCredentialFile, isCredentialProven, isDefaultProviderHome, isLoggedOut, probeInteractiveClaudeIdentity, withProviderHomeEnv, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
 export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
 export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";

package/dist/lib/lanes/message-replay.js

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { probeProviderCompactionsSince, providerTranscriptSize, } from "./compaction.js";
 import { LanesError } from "./errors.js";
@@ -55,7 +56,11 @@ export function writeMessageReplayState(filePath, state) {
 function safeProviderTranscriptPath(transcriptPath, provider, env) {
     if (provider === "grok")
         return transcriptPath;
-    const home = provider === "claude" ? env.CLAUDE_CONFIG_DIR : env.CODEX_HOME;
+    // A Claude worker on the default home runs with CLAUDE_CONFIG_DIR unset
+    // (accounts.ts isDefaultProviderHome); its transcripts live under ~/.claude.
+    const home = provider === "claude"
+        ? env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude")
+        : env.CODEX_HOME;
     if (!home) {
         throw new LanesError("message_replay_provider_home_missing", `Cannot validate ${provider} transcript without its provider home`);
     }

package/dist/lib/lanes/provider-rejection.d.ts

@@ -38,6 +38,8 @@ export interface ProviderRejection {
     event: "codex.turn.failed" | "claude.result.is_error" | "claude.result.login_failure" | "grok.error";
     /** Filesystem time when the provider output was appended, when read from worker.out. */
     output_at?: string;
+    /** The provider's structured reset (`resetsAt`), when the result carried one. */
+    resets_at?: unknown;
 }
 export declare function isProviderLoginFailure(failure: ProviderRejection | null): boolean;
 /**
@@ -56,12 +58,6 @@ export declare function retryableFromStatus(status: number | null): boolean;
  * read when it parses; otherwise the outer text is the message.
  */
 export declare function parseCodexTurnFailed(text: string): ProviderRejection | null;
-/**
- * Claude `-p --output-format json`: the last `type: "result"` object with
- * `is_error: true` and a numeric `api_error_status`, or the CLI's explicit
- * unauthenticated message. Other status-less errors keep the existing
- * classification because they may be quota text or a worker failure.
- */
 export declare function parseClaudeResultRejection(text: string): ProviderRejection | null;
 /**
  * Grok `--output-format json` prints one object. Measured 2026-09-22 (lane

package/dist/lib/lanes/provider-rejection.js

@@ -166,6 +166,23 @@ export function parseCodexTurnFailed(text) {
  * unauthenticated message. Other status-less errors keep the existing
  * classification because they may be quota text or a worker failure.
  */
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** `resetsAt` on the result, or under `rate_limit_info` (directly or in the API error params). */
+function claudeStructuredReset(rec) {
+    const direct = rec.resets_at ?? rec.resetsAt;
+    if (direct !== undefined)
+        return direct;
+    for (const holder of [rec, rec.api_error_params, rec.apiErrorParams]) {
+        if (!isRecord(holder))
+            continue;
+        const info = holder.rate_limit_info ?? holder.rateLimitInfo;
+        if (isRecord(info) && info.resetsAt !== undefined)
+            return info.resetsAt;
+    }
+    return undefined;
+}
 export function parseClaudeResultRejection(text) {
     // The last `result` decides: a success or a status-less error there is
     // final (NOT_REJECTED), so the scan does not continue to earlier results.
@@ -182,6 +199,7 @@ export function parseClaudeResultRejection(text) {
         if (status === null && !loginFailure && !retryableProviderFailure(status, message)) {
             return NOT_REJECTED;
         }
+        const resetsAt = claudeStructuredReset(rec);
         return {
             reason: PROVIDER_REJECTED_REASON,
             provider: "claude",
@@ -192,6 +210,7 @@ export function parseClaudeResultRejection(text) {
             event: loginFailure && rec.is_error !== true
                 ? "claude.result.login_failure"
                 : "claude.result.is_error",
+            ...(resetsAt !== undefined ? { resets_at: resetsAt } : {}),
         };
     });
     return found === NOT_REJECTED ? null : found;

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

@@ -0,0 +1,24 @@
+/**
+ * Tell a lane's senior when a provider 429 put an account on a quota hold.
+ *
+ * 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.
+ */
+import type { QuotaState } from "./quota.js";
+import { type LaneProvider, type LaneRecord } from "./types.js";
+export interface QuotaHoldNotice {
+    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;
+/**
+ * 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";
+//# sourceMappingURL=quota-notice.d.ts.map

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

@@ -0,0 +1,61 @@
+/**
+ * Tell a lane's senior when a provider 429 put an account on a quota hold.
+ *
+ * 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.
+ */
+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}`;
+    const lines = [
+        `Quota hold: ${provider} account ${accountId} is held until ${holdUntil}; no lane will run on it until then. Set by lane ${laneId}.`,
+        said,
+    ];
+    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"),
+    };
+}
+/**
+ * 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 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 };
+    if (lane.senior.kind === "lane" && lane.senior.id) {
+        appendDropboxMessageOnce(hqRoot, lane.senior.id, message);
+        return "lane_inbox";
+    }
+    if (lane.senior.kind === "session" && lane.senior.id) {
+        const sessionId = lane.senior.id;
+        const dirs = LANE_PROVIDERS.map((p) => monitorSessionDir(hqRoot, p, sessionId)).filter((dir) => fs.existsSync(dir));
+        if (dirs.length === 1) {
+            appendDropboxMessageOnceAtPath(path.join(dirs[0], "dropbox"), message);
+            return "session_inbox";
+        }
+    }
+    return "stderr_only";
+}
+//# sourceMappingURL=quota-notice.js.map