@indigoai-us/hq-cli 5.345.43 → 5.345.45

package/dist/lib/flag-snapshot-file.js

@@ -78,29 +78,38 @@ function isPermissionFailure(error) {
     const code = error?.code;
     return code === "EACCES" || code === "EPERM";
 }
-function fallbackSnapshotPath(companyUid, create) {
-    if (typeof process.getuid !== "function")
+function fallbackSnapshotPath(companyUid, create, env = process.env) {
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    const root = uid === undefined
+        ? env.LOCALAPPDATA?.trim()
+        : path.join(os.tmpdir(), `hq-cli-flag-snapshots-${uid}`);
+    if (!root)
         return undefined;
-    const uid = process.getuid();
-    const root = path.join(os.tmpdir(), `hq-cli-flag-snapshots-${uid}`);
-    const directories = [root, path.join(root, "hq"), path.join(root, "hq", "flags")];
+    const fallbackRoot = uid === undefined ? path.join(root, "hq-cli", "flag-snapshots") : root;
+    const directories = uid === undefined
+        ? [path.join(root, "hq-cli"), fallbackRoot]
+        : [fallbackRoot, path.join(fallbackRoot, "hq"), path.join(fallbackRoot, "hq", "flags")];
     for (const directory of directories) {
         try {
             if (create)
                 fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
             const stat = fs.lstatSync(directory);
-            if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== uid)
-                return undefined;
-            if (create)
-                fs.chmodSync(directory, 0o700);
-            else if ((stat.mode & 0o077) !== 0)
+            if (!stat.isDirectory() || stat.isSymbolicLink())
                 return undefined;
+            if (uid !== undefined) {
+                if (stat.uid !== uid)
+                    return undefined;
+                if (create)
+                    fs.chmodSync(directory, 0o700);
+                else if ((stat.mode & 0o077) !== 0)
+                    return undefined;
+            }
         }
         catch {
             return undefined;
         }
     }
-    return path.join(directories[2], `snapshot-${companyUid}.json`);
+    return path.join(directories[directories.length - 1], `snapshot-${companyUid}.json`);
 }
 function fallbackPersonSnapshotPath(create) {
     if (typeof process.getuid !== "function")
@@ -275,7 +284,7 @@ export function writeFlagSnapshotFile(companyUid, flags, options = {}) {
     }
     const cacheRootKind = env.XDG_CACHE_HOME?.trim() ? "xdg" : "home";
     const writeFallback = (originalError) => {
-        const fallbackFile = fallbackSnapshotPath(companyUid, true);
+        const fallbackFile = fallbackSnapshotPath(companyUid, true, env);
         if (!fallbackFile) {
             if (originalError) {
                 markFallbackFailed(originalError);
@@ -347,21 +356,20 @@ export function readFlagSnapshotFile(companyUid, options = {}) {
     const file = flagSnapshotPath(companyUid, options.env);
     if (!file)
         return null;
-    if (fallbackCacheUsed) {
-        const fallback = fallbackSnapshotPath(companyUid, false);
-        const snapshot = fallback ? parseSnapshotFile(companyUid, fallback, options) : null;
-        if (snapshot)
-            return snapshot;
-    }
     const primary = parseSnapshotFile(companyUid, file, options);
-    if (primary)
+    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
+    if (primary && !fallbackCacheUsed && uid !== undefined)
         return primary;
-    const fallback = fallbackSnapshotPath(companyUid, false);
-    if (!fallback)
-        return null;
-    const snapshot = parseSnapshotFile(companyUid, fallback, options);
-    if (snapshot)
+    const fallback = fallbackSnapshotPath(companyUid, false, options.env);
+    const fallbackSnapshot = fallback ? parseSnapshotFile(companyUid, fallback, options) : null;
+    // A process can restart after a denied Windows rename wrote a newer snapshot
+    // to LOCALAPPDATA. Compare both valid stores so an older primary does not
+    // mask that successful fallback write. Equal timestamps keep the primary.
+    if (fallbackSnapshot
+        && (!primary || Date.parse(fallbackSnapshot.fetched_at) > Date.parse(primary.fetched_at))) {
         fallbackCacheUsed = true;
-    return snapshot;
+        return fallbackSnapshot;
+    }
+    return primary;
 }
 //# sourceMappingURL=flag-snapshot-file.js.map

package/dist/lib/lanes/flag-keys.d.ts

@@ -1,5 +1,9 @@
 /** hq-flags keys used by lane command behavior. */
+export declare const LANE_FOCUS_GUARD_FLAG = "lanes-focus-guard";
+export declare const LANE_FOCUS_DASHBOARD_FLAG = "lanes-focus-dashboard";
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+/** Enables same-provider automatic lane recovery after provider quota exhaustion. */
+export declare const LANE_QUOTA_ACCOUNT_FAILOVER_FLAG = "lanes.quota-account-failover";
 /** Gives live senior lanes Claude admission precedence and reserves host capacity for them. */
 export declare const LANE_LEAD_ADMISSION_PRIORITY_FLAG = "lanes.lead-admission-priority";
 /** Refresh provider/model/effort from a worker profile when a done lane takes a new story. */

package/dist/lib/lanes/flag-keys.js

@@ -1,5 +1,9 @@
 /** hq-flags keys used by lane command behavior. */
+export const LANE_FOCUS_GUARD_FLAG = "lanes-focus-guard";
+export const LANE_FOCUS_DASHBOARD_FLAG = "lanes-focus-dashboard";
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+/** Enables same-provider automatic lane recovery after provider quota exhaustion. */
+export const LANE_QUOTA_ACCOUNT_FAILOVER_FLAG = "lanes.quota-account-failover";
 /** Gives live senior lanes Claude admission precedence and reserves host capacity for them. */
 export const LANE_LEAD_ADMISSION_PRIORITY_FLAG = "lanes.lead-admission-priority";
 /** Refresh provider/model/effort from a worker profile when a done lane takes a new story. */

package/dist/lib/lanes/focus-guard.d.ts

@@ -0,0 +1,65 @@
+import { LanesError } from "./errors.js";
+export declare const FOCUS_GUARD_MAX_PR_AGE_MS: number;
+export interface FocusGuardStory {
+    id: string;
+    focus_id?: unknown;
+    kpi?: unknown;
+    state?: unknown;
+    status?: unknown;
+    lane?: unknown;
+    lanes?: unknown;
+}
+export interface FocusGuardPullRequest {
+    number: number;
+    created_at: string;
+    repository?: string;
+}
+export interface FocusGuardLane {
+    lane_id: string;
+    state: string;
+}
+export type FocusGuardReason = {
+    code: "story_missing_focus";
+    story_id: string;
+} | {
+    code: "open_pr_over_48h";
+    number: number;
+    age_hours: number;
+    repository?: string;
+} | {
+    code: "stale_story";
+    story_id: string;
+    lane_id: string | null;
+} | {
+    code: "pr_lookup_failed";
+};
+export interface FocusGuardOverride {
+    reason: string;
+    by_lane: string;
+    at: string;
+    story: string;
+}
+export declare function appendLaneFocusOverride<T extends {
+    focus_overrides?: FocusGuardOverride[];
+}>(lane: T, override: FocusGuardOverride): T & {
+    focus_overrides: FocusGuardOverride[];
+};
+export declare function evaluateFocusGuard(input: {
+    storyIds: readonly string[];
+    stories: readonly FocusGuardStory[];
+    lanes: readonly FocusGuardLane[];
+    pullRequests?: readonly FocusGuardPullRequest[];
+    pullRequestLookupFailed?: boolean;
+    now: Date;
+    checkTeamBlockers: boolean;
+}): FocusGuardReason[];
+export declare function evaluateFocusGuardIfEnabled(enabled: boolean, input: Parameters<typeof evaluateFocusGuard>[0]): FocusGuardReason[];
+export declare function assertFocusGuardAllows(enabled: boolean, input: Parameters<typeof evaluateFocusGuard>[0], overrideReason?: string): FocusGuardReason[];
+export declare function focusGuardRefusal(reasons: readonly FocusGuardReason[]): LanesError;
+export declare function makeFocusOverride(input: {
+    reason?: string;
+    laneId: string;
+    at: string;
+    storyId: string;
+}): FocusGuardOverride | undefined;
+//# sourceMappingURL=focus-guard.d.ts.map

package/dist/lib/lanes/focus-guard.js

@@ -0,0 +1,91 @@
+import { LanesError } from "./errors.js";
+import { isTerminalLaneState } from "./types.js";
+export const FOCUS_GUARD_MAX_PR_AGE_MS = 48 * 60 * 60 * 1000;
+export function appendLaneFocusOverride(lane, override) {
+    return { ...lane, focus_overrides: [...(lane.focus_overrides ?? []), override].slice(-100) };
+}
+function nonempty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function storyLaneIds(story) {
+    const candidates = [story.lane, ...(Array.isArray(story.lanes) ? story.lanes : [])];
+    return [...new Set(candidates.flatMap((item) => {
+            if (typeof item === "string" && item.trim())
+                return [item.trim()];
+            if (item !== null && typeof item === "object" && typeof item.lane === "string") {
+                const lane = item.lane.trim();
+                return lane ? [lane] : [];
+            }
+            if (item !== null && typeof item === "object" && typeof item.lane_id === "string") {
+                const laneId = item.lane_id.trim();
+                return laneId ? [laneId] : [];
+            }
+            return [];
+        }))];
+}
+export function evaluateFocusGuard(input) {
+    const reasons = [];
+    const storyById = new Map(input.stories.map((story) => [story.id.trim(), story]));
+    for (const id of input.storyIds) {
+        const story = storyById.get(id);
+        if (!story || (!nonempty(story.focus_id) && !nonempty(story.kpi))) {
+            reasons.push({ code: "story_missing_focus", story_id: id });
+        }
+    }
+    if (!input.checkTeamBlockers)
+        return reasons;
+    if (input.pullRequestLookupFailed) {
+        reasons.push({ code: "pr_lookup_failed" });
+    }
+    else {
+        for (const pr of input.pullRequests ?? []) {
+            const ageMs = input.now.getTime() - Date.parse(pr.created_at);
+            if (Number.isFinite(ageMs) && ageMs > FOCUS_GUARD_MAX_PR_AGE_MS) {
+                reasons.push({
+                    code: "open_pr_over_48h",
+                    number: pr.number,
+                    age_hours: Math.floor(ageMs / (60 * 60 * 1000)),
+                    ...(pr.repository === undefined ? {} : { repository: pr.repository }),
+                });
+            }
+        }
+    }
+    const liveLaneIds = new Set(input.lanes
+        .filter((lane) => !isTerminalLaneState(lane.state))
+        .map((lane) => lane.lane_id));
+    for (const story of input.stories) {
+        const storyStatus = typeof story.state === "string" ? story.state : story.status;
+        if (storyStatus !== "in_progress")
+            continue;
+        const assigned = storyLaneIds(story);
+        if (assigned.length === 0 || assigned.every((laneId) => !liveLaneIds.has(laneId))) {
+            reasons.push({ code: "stale_story", story_id: story.id, lane_id: assigned[0] ?? null });
+        }
+    }
+    return reasons;
+}
+export function evaluateFocusGuardIfEnabled(enabled, input) {
+    return enabled ? evaluateFocusGuard(input) : [];
+}
+export function assertFocusGuardAllows(enabled, input, overrideReason) {
+    const reasons = evaluateFocusGuardIfEnabled(enabled, input);
+    if (enabled && reasons.length > 0 && overrideReason === undefined)
+        throw focusGuardRefusal(reasons);
+    return reasons;
+}
+export function focusGuardRefusal(reasons) {
+    return new LanesError("focus_guard_refused", `Lane launch refused by focus guard: ${reasons.map((reason) => reason.code).join(", ")}`, { reasons });
+}
+export function makeFocusOverride(input) {
+    if (input.reason === undefined)
+        return undefined;
+    const reason = input.reason.trim();
+    if (!reason) {
+        throw new LanesError("focus_override_reason_required", "--focus-override requires a non-empty reason", {
+            lane_id: input.laneId,
+            story_id: input.storyId,
+        });
+    }
+    return { reason, by_lane: input.laneId, at: input.at, story: input.storyId };
+}
+//# sourceMappingURL=focus-guard.js.map

package/dist/lib/lanes/grants.js

@@ -28,7 +28,7 @@ export function terminalChildResumeHireGrantError(current, snapshot, finishedChi
     }
     if (children.length >= parentGrant)
         return hireGrantCapacityError(parent, children);
-    const requestedGrant = current.hire_grant ?? 0;
+    const requestedGrant = current.released_hire_grant ?? current.hire_grant ?? 0;
     if (requestedGrant > availableChildGrant) {
         return new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining, but ${terminal ? "terminal" : "finished"} child ${current.lane_id} needs ${requestedGrant} to resume. Ask its senior for more: write an ask envelope with the desired total grant and why; the senior runs hq lanes grant ${parent.lane_id} --hire <n>.`, {
             senior_lane_id: parent.lane_id,

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -33,6 +33,7 @@ export interface OutpostLaneCommand {
     text?: string;
     project?: string;
     story?: string;
+    focusOverride?: string;
     account?: string;
     model?: string;
     effort?: string;

package/dist/lib/lanes/outpost-dispatch.js

@@ -199,6 +199,7 @@ export function buildOutpostLaneCommand(input) {
         ["--text", input.text],
         ["--project", input.project],
         ["--story", input.story],
+        ["--focus-override", input.focusOverride],
         ["--account", input.account],
         ["--model", input.model],
         ["--effort", input.effort],

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

@@ -35,6 +35,8 @@ export interface ReconcileChange {
     from?: string;
     to?: string;
     reason?: string;
+    account?: string;
+    quota_reset_at?: string;
     /** The attempted provider PATH when admission found no executable. */
     searched_path?: string;
 }

package/dist/lib/lanes/reconcile.js

@@ -23,7 +23,7 @@ import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecor
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, listQuestionIds, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyObservation, recordCpuBusyObservation, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "./registry-flag.js";
-import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_KEEP_ALIVE_DUE_WAKE_PRECISE_FLAG, LANE_LEAD_ADMISSION_PRIORITY_FLAG, } from "./flag-keys.js";
+import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_KEEP_ALIVE_DUE_WAKE_PRECISE_FLAG, LANE_LEAD_ADMISSION_PRIORITY_FLAG, LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, } from "./flag-keys.js";
 import { checkLaneDiskSpace, configuredCodexRolloutHomes, laneDiskAccount, retainCodexRollouts } from "./disk-guard.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { appendDropboxMessage } from "./dropbox.js";
@@ -66,6 +66,43 @@ function spawnDepsForHost(deps) {
         admissionHost: deps.host,
     };
 }
+async function resumeDueQuotaHeldLanes(hqRoot, lanes, summary, deps, now) {
+    const readFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
+    for (const lane of lanes) {
+        const resetAt = typeof lane.quota_reset_at === "string" ? Date.parse(lane.quota_reset_at) : NaN;
+        if (lane.state !== "interrupted" ||
+            !["quota_held", "account_quota_exhausted", "account_model_unavailable"].includes(lane.terminal_reason ?? "") ||
+            !Number.isFinite(resetAt) || resetAt > now.getTime() || !laneRunsHere(lane, deps.host))
+            continue;
+        try {
+            const company = resolveLaneCompany(hqRoot, lane);
+            const enabled = await readLanesRegistryFlagFailOff(LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, {
+                company: company.company,
+                companyUidSource: laneCompanyUidSource(company.source),
+                env: deps.env,
+            }, readFlag);
+            if (!enabled)
+                continue;
+            const recovered = await retryLaneOnAlternateAccount(hqRoot, lane, "usage_limit", "reconcile", { ...spawnDepsForHost(deps), now: () => now, quotaAccountFailoverEnabled: true, dryRun: deps.dryRun });
+            summary.resumed.push({
+                id: lane.lane_id,
+                from: "interrupted",
+                to: recovered.state,
+                account: recovered.account,
+                reason: recovered.terminal_reason === "quota_held" ? "quota_held" : "quota_reset",
+                ...(recovered.quota_reset_at ? { quota_reset_at: recovered.quota_reset_at } : {}),
+            });
+            if (!deps.dryRun)
+                summary.heartbeats.push(`${lane.lane_id}:quota-account-retry`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            summary.errors.push({ message: `${lane.lane_id}: quota retry failed: ${message}` });
+            summary.ok = false;
+            process.stderr.write(`hq lanes reconcile: quota retry failed for ${lane.lane_id}: ${message}\n`);
+        }
+    }
+}
 function logSkip(skip) {
     process.stderr.write(`hq lanes reconcile: skipped ${skip.kind}${skip.id ? ` ${skip.id}` : ""}: ${skip.why}\n`);
 }
@@ -940,6 +977,7 @@ export async function runPassBody(hqRoot, deps) {
     if (deps.terminalKeepAliveCandidate) {
         return runTerminalKeepAliveCandidatePass(hqRoot, lanes, summary, deps, now, deps.terminalKeepAliveCandidate);
     }
+    await resumeDueQuotaHeldLanes(hqRoot, lanes, summary, deps, now);
     let presenceConnected;
     try {
         presenceConnected =

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

@@ -66,6 +66,10 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    /** Test seam for the default-off quota account failover registry gate. */
+    quotaAccountFailoverEnabled?: boolean;
+    /** Return the selected retry transition without writing or starting a worker. */
+    dryRun?: boolean;
     /** Absolute CLI entry captured when the watcher is armed; tests may inject it. */
     hqCliEntry?: string;
     hostname?: string;

package/dist/lib/lanes/spawn.js

@@ -29,6 +29,9 @@ import { registryWorkerRecord } from "./registry-persona.js";
 import { resolveMachineIdentity, } from "./machine-identity.js";
 import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./store.js";
 import { managerStatusGateHeartbeat } from "./manager-status-gate.js";
+import { LANE_QUOTA_ACCOUNT_FAILOVER_FLAG } from "./flag-keys.js";
+import { readLanesRegistryFlagFailOff } from "./registry-flag.js";
+import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT } from "./keep-alive.js";
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
 import { ensureSessionHome } from "./session-relink.js";
@@ -516,6 +519,19 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
     const env = deps.env ?? process.env;
     const admissionHost = deps.admissionHost ?? resolveAdmissionHost();
     const hostname = deps.hostname?.trim() || admissionHost.hostname.trim() || resolveAdmissionHost().hostname;
+    const now = (deps.now ?? (() => new Date()))();
+    const at = now.toISOString();
+    const nowMs = now.getTime();
+    const retryFromState = lane.state === "interrupted" &&
+        (lane.terminal_reason === "quota_held" ||
+            lane.terminal_reason === "account_quota_exhausted" ||
+            lane.terminal_reason === "account_model_unavailable")
+        ? "interrupted"
+        : "running";
+    const retryingExpiredQuota = retryFromState === "interrupted" &&
+        typeof lane.quota_reset_at === "string" &&
+        Number.isFinite(Date.parse(lane.quota_reset_at)) &&
+        Date.parse(lane.quota_reset_at) <= nowMs;
     const modelDeps = {
         ...deps.modelDeps,
         env: deps.modelDeps?.env ?? env,
@@ -525,13 +541,38 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         env,
     };
     const profile = lane.worker_profile ? loadWorkerProfile(hqRoot, lane.worker_profile) : undefined;
+    let quotaFailoverEnabled = false;
+    if (reason === "usage_limit") {
+        if (deps.quotaAccountFailoverEnabled !== undefined) {
+            quotaFailoverEnabled = deps.quotaAccountFailoverEnabled;
+        }
+        else {
+            try {
+                const laneCompany = resolveLaneCompany(hqRoot, lane);
+                quotaFailoverEnabled = await readLanesRegistryFlagFailOff(LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, { company: laneCompany.company, companyUidSource: laneCompanyUidSource(laneCompany.source), env });
+            }
+            catch (error) {
+                process.stderr.write(`${JSON.stringify({
+                    event: "lanes.quota_account_failover.company_context_failed",
+                    error: error instanceof Error ? error.name : "NonError",
+                    fallback: false,
+                })}\n`);
+            }
+        }
+    }
     const profileModel = profile?.meta.provider === lane.provider ? profile.meta.model : undefined;
     const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
         : undefined;
     const unavailableAccounts = previouslyUnavailableAccounts(lane);
     const allowedAccounts = Object.entries(config.providers[lane.provider].accounts)
-        .filter(([id, account]) => id !== lane.account && !unavailableAccounts.has(id) && account.enabled)
+        .filter(([id, account]) => (id !== lane.account || (quotaFailoverEnabled && reason === "usage_limit" && retryingExpiredQuota)) &&
+        !unavailableAccounts.has(id) && account.enabled)
+        .filter(([id]) => !quotaFailoverEnabled ||
+        (profile?.meta.provider !== lane.provider ||
+            (profile.meta.accounts !== undefined
+                ? profile.meta.accounts.includes(id)
+                : profile.meta.account === undefined || profile.meta.account === id)))
         .filter(([id]) => accountStatus(lane.provider, id, config, {
         existsSync,
         hostname,
@@ -545,6 +586,7 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         existsSync,
         accountDeps,
         hostname,
+        now,
         ...(pinnedModel ?? profileModel ? { model: pinnedModel ?? profileModel } : {}),
         allowedAccounts,
     };
@@ -553,11 +595,96 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         target = selectBalancedAccount(lane.provider, config, modelContext);
     }
     catch (err) {
+        if (quotaFailoverEnabled &&
+            reason === "usage_limit" &&
+            err instanceof AccountResolutionError &&
+            err.error === "account_quota_exhausted") {
+            const quotaAccountReasons = Array.isArray(err.details.account_reasons)
+                ? err.details.account_reasons
+                : [];
+            const resetAt = quotaAccountReasons
+                .map((candidate) => candidate.quota_reset_at)
+                .filter((value) => typeof value === "string" && Number.isFinite(Date.parse(value)))
+                .sort((a, b) => Date.parse(a) - Date.parse(b))[0];
+            if (resetAt) {
+                const accountReasons = Object.entries(config.providers[lane.provider].accounts).map(([id, account]) => {
+                    const quotaReason = quotaAccountReasons.find((candidate) => candidate.account === id);
+                    if (quotaReason)
+                        return quotaReason;
+                    if (id === lane.account)
+                        return { account: id, reason: "source_account_quota_exhausted" };
+                    if (unavailableAccounts.has(id))
+                        return { account: id, reason: "previously_unavailable" };
+                    if (!account.enabled)
+                        return { account: id, reason: "disabled" };
+                    if (quotaFailoverEnabled && profile?.meta.provider === lane.provider &&
+                        profile.meta.account !== undefined && profile.meta.account !== id) {
+                        return { account: id, reason: "worker_profile_account_pin" };
+                    }
+                    if (quotaFailoverEnabled && profile?.meta.provider === lane.provider &&
+                        profile.meta.accounts !== undefined && !profile.meta.accounts.includes(id)) {
+                        return { account: id, reason: "worker_profile_account_not_allowed" };
+                    }
+                    if (accountStatus(lane.provider, id, config, {
+                        existsSync,
+                        hostname,
+                        ...(accountDeps?.probe ? { probe: accountDeps.probe } : {}),
+                        ...(accountDeps?.env ? { env: accountDeps.env } : {}),
+                    }).logged_in !== true)
+                        return { account: id, reason: "login_required" };
+                    if (!supportsSpawnModel(lane.provider, id, config, pinnedModel, profileModel, modelDeps, hostname)) {
+                        return { account: id, reason: "model_or_pin_incompatible" };
+                    }
+                    return { account: id, reason: "eligible_but_not_selected" };
+                });
+                const holdLane = (current) => {
+                    if (current.state !== retryFromState ||
+                        current.account !== lane.account ||
+                        current.provider_session_id !== lane.provider_session_id) {
+                        throw new LanesError("account_retry_conflict", `Lane ${lane.lane_id} changed while quota recovery was prepared`, { lane_id: lane.lane_id, state: current.state, account: current.account ?? null });
+                    }
+                    return {
+                        ...current,
+                        state: "interrupted",
+                        terminal_reason: "quota_held",
+                        terminal_details: {
+                            reason: err.error,
+                            account_reasons: accountReasons,
+                        },
+                        quota_reset_at: resetAt,
+                        interrupted_at: at,
+                    };
+                };
+                if (deps.dryRun)
+                    return holdLane(lane);
+                return retryUpdateLane(hqRoot, lane.lane_id, writer, holdLane);
+            }
+        }
         if (reason === "account_unavailable" || unavailableAccounts.size > 0) {
             throw new LanesError("account_not_logged_in", `Account ${lane.account ?? "(none)"} for ${lane.provider} is unavailable and no other logged-in account can serve this lane`, { provider: lane.provider, account: lane.account ?? null });
         }
         throw err;
     }
+    if (deps.dryRun) {
+        const entry = {
+            from: lane.account ?? null,
+            to: target.id,
+            at,
+            reason,
+        };
+        return {
+            ...lane,
+            state: "queued",
+            queued_reason: "account_retry",
+            queued_at: at,
+            terminal_reason: undefined,
+            terminal_details: undefined,
+            interrupted_at: undefined,
+            quota_reset_at: undefined,
+            account: target.id,
+            account_history: appendCappedHistory(lane.account_history ?? [], entry),
+        };
+    }
     const source = lane.account ? config.providers[lane.provider].accounts[lane.account] : undefined;
     const sessionId = providerSupportsSessionResume(lane.provider) &&
         typeof lane.provider_session_id === "string" &&
@@ -572,12 +699,9 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
             sessionId,
         }));
     }
-    const now = (deps.now ?? (() => new Date()))();
-    const at = now.toISOString();
-    const nowMs = now.getTime();
     return withLaneAdmissionLock(hqRoot, lane.provider, async () => {
         const current = readLane(hqRoot, lane.lane_id);
-        if (current.state !== "running" ||
+        if (current.state !== retryFromState ||
             current.account !== lane.account ||
             current.provider_session_id !== lane.provider_session_id) {
             throw new LanesError("account_retry_conflict", `Lane ${lane.lane_id} changed while account recovery was prepared`, {
@@ -603,6 +727,8 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
                 admission_reserved_at: undefined,
                 terminal_reason: undefined,
                 terminal_details: undefined,
+                interrupted_at: undefined,
+                quota_reset_at: undefined,
                 account: target.id,
                 account_history: appendCappedHistory(row.account_history ?? [], entry),
                 pending_resume: sessionId
@@ -621,7 +747,7 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         const capacityReason = laneAdmissionCapReason(admissionLanes, candidate, config, admissionHost, profile?.meta.max_concurrent, nowMs);
         const earlierEligibleLane = hasEarlierEligibleQueuedLane(admissionLanes, candidate, config, admissionHost, profileMaxFor, nowMs);
         const moved = retryUpdateLane(hqRoot, lane.lane_id, writer, (row) => {
-            if (row.state !== "running" ||
+            if (row.state !== retryFromState ||
                 row.account !== lane.account ||
                 row.provider_session_id !== lane.provider_session_id) {
                 throw new LanesError("account_retry_conflict", `Lane ${lane.lane_id} changed while account recovery was prepared`, {