@indigoai-us/hq-cli 5.345.21 → 5.345.22

package/CHANGELOG.md

@@ -2,7 +2,12 @@
 
 ## [Unreleased]
 
+## [5.345.22] — 2026-10-06
+- Fix Claude quota holds so time-only reset messages keep accounts unavailable until the provider's stated UTC reset, and expose the hold state in host capacity output.
+
 ## [5.345.21] — 2026-10-06
+- `hq sync push --personal <path>` now waits up to 500 ms for the startup flag registry snapshot before evaluating `cli.personal-targeted-push-paths`, while preserving the legacy refusal when the registry is unavailable.
+
 - Hook timeout reports now show elapsed time against the configured budget and include available phase and hook attribution.
 - Reconcile hire-grant carve accounting across resume, reparent and grant updates; decreases no longer fail because sibling grants exceed the senior allocation.
 - Route eligible Linux pull-request checks and local release guards through the registered ARM64 self-hosted runner. Keep the shared npm/OIDC publish job on its existing runner.

package/dist/commands/cloud.js

@@ -840,7 +840,7 @@ export function registerCloudCommands(program) {
                     "to have already resolved entity + credentials. Pick one.");
             }
             // Closes hq-cli#25 — see `assertNoPersonalPositionalPaths` doc-block.
-            const targetedPersonalPathsEnabled = Boolean(options.personal && paths && paths.length > 0 && personalTargetedPushPathsEnabled());
+            const targetedPersonalPathsEnabled = Boolean(options.personal && paths && paths.length > 0 && await personalTargetedPushPathsEnabled());
             assertNoPersonalPositionalPaths(options, paths, targetedPersonalPathsEnabled);
             if (targetedPersonalPathsEnabled) {
                 explicitPersonalPaths = resolveExplicitPersonalPushPaths(options.hqRoot, paths);

package/dist/commands/lanes.js

@@ -5306,6 +5306,7 @@ async function runCapacity(ctx) {
         env: ctx.env,
         hostname: ctx.hostname(),
         now: ctx.now(),
+        quotaState: loadQuotaState(hqRoot),
     });
     printJson({
         ...snapshot,

package/dist/commands/personal-targeted-push-flag.d.ts

@@ -1,4 +1,4 @@
 export declare const CLI_PERSONAL_TARGETED_PUSH_PATHS_FLAG = "cli.personal-targeted-push-paths";
 /** The established full-scope behavior remains in force until an explicit hq-flags enablement. */
-export declare function personalTargetedPushPathsEnabled(): boolean;
+export declare function personalTargetedPushPathsEnabled(): Promise<boolean>;
 //# sourceMappingURL=personal-targeted-push-flag.d.ts.map

package/dist/commands/personal-targeted-push-flag.js

@@ -1,7 +1,11 @@
-import { resolveProcessFlagGate } from "../lib/flag-registry.js";
+import { resolveProcessFlagGate, waitForFlagRegistryRefresh, } from "../lib/flag-registry.js";
 export const CLI_PERSONAL_TARGETED_PUSH_PATHS_FLAG = "cli.personal-targeted-push-paths";
 /** The established full-scope behavior remains in force until an explicit hq-flags enablement. */
-export function personalTargetedPushPathsEnabled() {
+export async function personalTargetedPushPathsEnabled() {
+    // This command reads the gate immediately after startup. Give the existing
+    // unref'd registry worker one bounded window to publish its company snapshot.
+    // An unavailable registry leaves resolveProcessFlagGate on the legacy false.
+    await waitForFlagRegistryRefresh(500);
     return resolveProcessFlagGate(CLI_PERSONAL_TARGETED_PUSH_PATHS_FLAG, { fallback: false }, () => false);
 }
 //# sourceMappingURL=personal-targeted-push-flag.js.map

package/dist/lib/lanes/host-capacity.d.ts

@@ -1,4 +1,5 @@
 import { type AuthState } from "./accounts.js";
+import { type QuotaState } from "./quota.js";
 import type { LaneHost, LaneProvider, LaneRecord, LanesConfig } from "./types.js";
 export interface HostCapacityAccount {
     enabled: boolean;
@@ -8,6 +9,9 @@ export interface HostCapacityAccount {
     max_running: number;
     running: number;
     queued: number;
+    /** Account-wide quota status when this snapshot is produced on its host. */
+    quota_held?: boolean;
+    quota_reset_at?: string;
     /** Exact lane states used for Claude account balancing; absent on older Outposts. */
     lane_counts?: {
         running: number;
@@ -54,6 +58,7 @@ export declare function buildHostCapacitySnapshot(input: {
     env?: NodeJS.ProcessEnv;
     hostname?: string;
     now: Date;
+    quotaState?: QuotaState;
 }): HostCapacitySnapshot;
 /** Reject malformed remote snapshots before they can influence host selection. */
 export declare function parseHostCapacitySnapshot(raw: unknown): HostCapacitySnapshot;

package/dist/lib/lanes/host-capacity.js

@@ -2,6 +2,7 @@ import { accountStatus } from "./accounts.js";
 import { accountMaxRunning } from "./config.js";
 import { laneOccupiesRunningSlot, laneRunsOnHost, } from "./admission.js";
 import { LanesError } from "./errors.js";
+import { quotaBlockFor } from "./quota.js";
 function admissionHost(host) {
     return host.kind === "outpost"
         ? { hostname: "", outpostId: host.id }
@@ -33,6 +34,10 @@ export function buildHostCapacitySnapshot(input) {
             });
             const accountLanes = providerLanes.filter((lane) => lane.account === id);
             const liveLanes = accountLanes.filter((lane) => lane.state === "running" || lane.state === "queued" || lane.state === "awaiting_input");
+            const quotaBlock = input.quotaState
+                ? quotaBlockFor(input.quotaState, provider, id, undefined, input.now)
+                : undefined;
+            const quotaResetAt = input.quotaState?.providers[provider]?.[id]?.all_models_quota_reset_at;
             accounts[id] = {
                 enabled: account.enabled,
                 logged_in: status.logged_in,
@@ -40,6 +45,12 @@ export function buildHostCapacitySnapshot(input) {
                 max_running: accountMaxRunning(providerConfig, id),
                 running: running.filter((lane) => lane.account === id).length,
                 queued: queued.filter((lane) => lane.account === id).length,
+                ...(quotaBlock !== undefined
+                    ? {
+                        quota_held: quotaBlock.blocked,
+                        ...(quotaResetAt ? { quota_reset_at: quotaResetAt } : {}),
+                    }
+                    : {}),
                 lane_counts: {
                     running: liveLanes.filter((lane) => lane.state === "running").length,
                     queued: liveLanes.filter((lane) => lane.state === "queued").length,
@@ -108,6 +119,9 @@ export function parseHostCapacitySnapshot(raw) {
             if (id.trim() === "" || account === undefined ||
                 typeof account.enabled !== "boolean" ||
                 !(account.logged_in === null || typeof account.logged_in === "boolean") ||
+                (account.quota_held !== undefined && typeof account.quota_held !== "boolean") ||
+                (account.quota_reset_at !== undefined &&
+                    (typeof account.quota_reset_at !== "string" || !Number.isFinite(Date.parse(account.quota_reset_at)))) ||
                 (account.auth_state !== undefined &&
                     !["file", "status", "absent", "unknown", "home_missing"].includes(account.auth_state))) {
                 throw new LanesError("host_capacity_invalid", `Malformed ${provider} account capacity`, {
@@ -124,6 +138,10 @@ export function parseHostCapacitySnapshot(raw) {
                 max_running: requireCount(account.max_running, `${provider}.${id}.max_running`, true),
                 running: requireCount(account.running, `${provider}.${id}.running`),
                 queued: requireCount(account.queued, `${provider}.${id}.queued`),
+                ...(account.quota_held !== undefined ? { quota_held: account.quota_held } : {}),
+                ...(account.quota_reset_at !== undefined
+                    ? { quota_reset_at: account.quota_reset_at }
+                    : {}),
                 ...(account.lane_counts !== undefined
                     ? { lane_counts: parseLaneCounts(account.lane_counts, `${provider}.${id}.lane_counts`) }
                     : {}),

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

@@ -36,6 +36,8 @@ export interface ProviderRejection {
     retryable: boolean;
     /** Which event on the stream carried the failure. */
     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;
 }
 export declare function isProviderLoginFailure(failure: ProviderRejection | null): boolean;
 /**

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

@@ -271,9 +271,21 @@ export function parseProviderRejection(provider, text) {
 export function readProviderRejection(runDir, provider, workerOutOffset = 0) {
     const outPath = path.join(runDir, "logs", "worker.out");
     let text;
+    let outputAt;
     try {
         const bytes = fs.readFileSync(outPath);
         text = bytes.subarray(Math.min(workerOutOffset, bytes.length)).toString("utf8");
+        const outputMtime = fs.statSync(outPath).mtime;
+        let spawnMtime;
+        try {
+            spawnMtime = fs.statSync(path.join(runDir, "spawn.json")).mtime;
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        if (!spawnMtime || outputMtime >= spawnMtime)
+            outputAt = outputMtime.toISOString();
     }
     catch (err) {
         const code = err.code;
@@ -281,6 +293,9 @@ export function readProviderRejection(runDir, provider, workerOutOffset = 0) {
             return null;
         throw err;
     }
-    return parseProviderRejection(provider, text);
+    const failure = parseProviderRejection(provider, text);
+    return failure
+        ? { ...failure, ...(outputAt ? { output_at: outputAt } : {}) }
+        : null;
 }
 //# sourceMappingURL=provider-rejection.js.map

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

@@ -26,13 +26,13 @@ export interface ModelQuota {
     /** Operator-facing marker, e.g. "needs credits for claude-fable-5-1". */
     marker?: string;
 }
-export type QuotaResetSource = "provider" | "default_hold";
+export type QuotaResetSource = "parsed" | "derived";
 export interface AccountQuota {
     /** Set when the 429 is an account-wide usage limit with a reset time. */
     all_models_quota_reset_at?: string;
     /**
-     * Where `all_models_quota_reset_at` came from: the provider's own message,
-     * or the configured default hold applied to a 429 that named no reset.
+     * 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.
      */
     reset_source?: QuotaResetSource;
     models: Record<string, ModelQuota>;
@@ -57,8 +57,8 @@ export interface QuotaSignal {
  * 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 `default_hold`; a signal that already carries a reset keeps it,
- * marked `provider`. A per-model credits refusal is untouched.
+ * marked `derived`; a signal that already carries a reset keeps it, marked
+ * `parsed`. A per-model credits refusal is untouched.
  */
 export declare function applyDefaultQuotaHold(signal: QuotaSignal, defaultHoldMs: number, now: Date): QuotaSignal;
 export declare function quotaStatePath(hqRoot: string): string;

package/dist/lib/lanes/quota.js

@@ -27,19 +27,19 @@ export const QUOTA_SCHEMA_VERSION = "hq-lanes-quota.v1";
  * 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 `default_hold`; a signal that already carries a reset keeps it,
- * marked `provider`. A per-model credits refusal is untouched.
+ * marked `derived`; a signal that already carries a reset keeps it, marked
+ * `parsed`. A per-model credits refusal is untouched.
  */
 export function applyDefaultQuotaHold(signal, defaultHoldMs, now) {
     if (signal.reason !== "account_quota_exhausted" || signal.needs_credits)
         return signal;
     if (signal.quota_reset_at)
-        return { ...signal, reset_source: "provider" };
+        return { ...signal, reset_source: "parsed" };
     return {
         ...signal,
         quota_reset_at: new Date(now.getTime() + defaultHoldMs).toISOString(),
         account_wide: true,
-        reset_source: "default_hold",
+        reset_source: "derived",
     };
 }
 const MONTHS = {
@@ -119,8 +119,13 @@ export function loadQuotaState(hqRoot) {
             if (typeof raw.all_models_quota_reset_at === "string" &&
                 raw.all_models_quota_reset_at.length > 0) {
                 account.all_models_quota_reset_at = raw.all_models_quota_reset_at;
-                if (raw.reset_source === "provider" || raw.reset_source === "default_hold") {
-                    account.reset_source = raw.reset_source;
+                // Normalize values written by older CLI versions while preserving the
+                // distinction between provider-parsed and configured fallback times.
+                if (raw.reset_source === "provider" || raw.reset_source === "parsed") {
+                    account.reset_source = "parsed";
+                }
+                else if (raw.reset_source === "default_hold" || raw.reset_source === "derived") {
+                    account.reset_source = "derived";
                 }
             }
             accounts[id] = account;
@@ -145,6 +150,22 @@ function writeQuotaState(hqRoot, state) {
  * An explicit provider year is kept as stated.
  */
 export function parseProviderResetTime(text, now) {
+    const timeOnlyMatch = /\bresets\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(UTC\)/i.exec(text);
+    if (timeOnlyMatch) {
+        let hour = Number(timeOnlyMatch[1]);
+        const minute = Number(timeOnlyMatch[2] ?? 0);
+        const meridiem = (timeOnlyMatch[3] ?? "").toLowerCase();
+        if (!Number.isInteger(hour) || hour < 1 || hour > 12 || minute < 0 || minute > 59)
+            return null;
+        if (meridiem === "pm" && hour < 12)
+            hour += 12;
+        if (meridiem === "am" && hour === 12)
+            hour = 0;
+        const candidate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), hour, minute, 0, 0));
+        if (candidate.getTime() <= now.getTime())
+            candidate.setUTCDate(candidate.getUTCDate() + 1);
+        return candidate.toISOString();
+    }
     const resetMatch = /\bresets\s+([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?(?:,\s*(?:(\d{4})\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm))?(?:\s*\((UTC)\))?/i.exec(text);
     const codexMatch = /\btry\s+again\s+at\s+([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?,\s*(\d{4})\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)(?:\s*\((UTC)\))?/i.exec(text);
     const match = resetMatch ?? codexMatch;
@@ -263,9 +284,23 @@ export function quotaSignalFromFields(fields, model, now) {
 export function readQuotaSignal(runDir, model, now, workerOutOffset = 0) {
     const outPath = path.join(runDir, "logs", "worker.out");
     let text;
+    let outputAt;
     try {
         const bytes = fs.readFileSync(outPath);
         text = bytes.subarray(Math.min(workerOutOffset, bytes.length)).toString("utf8");
+        // worker.out is appended as provider output arrives. Its mtime anchors a
+        // time-only reset to the output event, not to a later reconcile pass.
+        outputAt = fs.statSync(outPath).mtime;
+        let spawnAt;
+        try {
+            spawnAt = fs.statSync(path.join(runDir, "spawn.json")).mtime;
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        if (outputAt > now || (spawnAt && outputAt < spawnAt))
+            outputAt = now;
     }
     catch (err) {
         const code = err.code;
@@ -276,7 +311,8 @@ export function readQuotaSignal(runDir, model, now, workerOutOffset = 0) {
     const fields = quotaFieldsFromOutput(text);
     if (!fields)
         return null;
-    return quotaSignalFromFields(fields, model, now);
+    const observedAt = Number.isFinite(outputAt.getTime()) ? outputAt : now;
+    return quotaSignalFromFields(fields, model, observedAt);
 }
 export function recordAccountQuota(hqRoot, provider, accountId, signal) {
     return withLaneRecordFileLock(quotaStatePath(hqRoot), () => {
@@ -303,11 +339,11 @@ export function recordAccountQuota(hqRoot, provider, accountId, signal) {
         if (signal.account_wide && signal.quota_reset_at) {
             if (shouldReplaceReset(current.all_models_quota_reset_at, signal.quota_reset_at)) {
                 account.all_models_quota_reset_at = signal.quota_reset_at;
-                account.reset_source = signal.reset_source ?? "provider";
+                account.reset_source = signal.reset_source ?? "parsed";
             }
             else if (current.all_models_quota_reset_at) {
                 account.all_models_quota_reset_at = current.all_models_quota_reset_at;
-                account.reset_source = current.reset_source ?? "provider";
+                account.reset_source = current.reset_source ?? "parsed";
             }
         }
         accounts[accountId] = account;

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

@@ -19,7 +19,7 @@ import { type LaneCompanyRef, type LaneProvider, type LaneRecord, type AccountHi
 export declare const LANES_RUNS_REL: string;
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
 export declare const ANSWERED_QUESTIONS_FILE = "answered-questions.json";
-export declare const SPAWN_TERMINAL_REASONS: readonly ["account_not_logged_in", "unknown_account", "account_disabled", "no_enabled_account", "spawn_failed", "not_detached", "watcher_not_armed", "model_unsupported"];
+export declare const SPAWN_TERMINAL_REASONS: readonly ["account_not_logged_in", "unknown_account", "account_disabled", "no_enabled_account", "spawn_failed", "not_detached", "watcher_not_armed", "model_unsupported", "account_quota_exhausted"];
 export type SpawnTerminalReason = (typeof SPAWN_TERMINAL_REASONS)[number];
 declare const PROVIDER_COMMAND: Record<LaneProvider, string>;
 export declare function providerCommandOnPath(command: string, pathEnv: string | undefined): boolean;

package/dist/lib/lanes/spawn.js

@@ -50,6 +50,7 @@ export const SPAWN_TERMINAL_REASONS = [
     "not_detached",
     "watcher_not_armed",
     "model_unsupported",
+    "account_quota_exhausted",
 ];
 const PROVIDER_COMMAND = {
     claude: "claude",

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

@@ -108,18 +108,6 @@ export declare function classifyLaneExit(input: {
      */
     providerRejection?: ProviderRejection | null;
 }): TerminalClassification;
-/**
- * One decision for an exited worker's output. An explicit provider status
- * wins over the quota text heuristics: a 429 from any provider (including
- * codex `turn.failed` and grok error objects, which the claude-shaped quota
- * reader never sees) becomes a quota signal; any other explicit status is a
- * rejection even when its text sounds like a quota message (a 402 "requires
- * usage credits" is a rejection, not a hold). A failure with no status at
- * all is matched against the quota text heuristics first: a status-less
- * "usage limit" / "rate limit" turn.failed still creates the account hold;
- * any other status-less message is a rejection. Only when the stream
- * carries no failure object does the quota reader's own read apply.
- */
 export declare function routeProviderFailure(failure: ProviderRejection | null, readQuota: () => QuotaSignal | null, model: string | undefined, now: Date): {
     quota: QuotaSignal | null;
     rejection: ProviderRejection | null;

package/dist/lib/lanes/watcher.js

@@ -139,15 +139,21 @@ export function classifyLaneExit(input) {
  * any other status-less message is a rejection. Only when the stream
  * carries no failure object does the quota reader's own read apply.
  */
+function validFailureOutputTime(value, fallback) {
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) && parsed.getTime() <= fallback.getTime()
+        ? parsed
+        : fallback;
+}
 export function routeProviderFailure(failure, readQuota, model, now) {
     if (failure && failure.status === QUOTA_STATUS) {
         return {
-            quota: quotaSignalFromFields({ api_error_status: QUOTA_STATUS, is_error: true, result: failure.message }, model, now),
+            quota: quotaSignalFromFields({ api_error_status: QUOTA_STATUS, is_error: true, result: failure.message }, model, failure.output_at ? validFailureOutputTime(failure.output_at, now) : now),
             rejection: null,
         };
     }
     if (failure && failure.status === null) {
-        const quota = quotaSignalFromFields({ api_error_status: undefined, is_error: true, result: failure.message }, model, now);
+        const quota = quotaSignalFromFields({ api_error_status: undefined, is_error: true, result: failure.message }, model, failure.output_at ? validFailureOutputTime(failure.output_at, now) : now);
         if (quota)
             return { quota, rejection: null };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.21",
+  "version": "5.345.22",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {