@indigoai-us/hq-cli 5.309.1 → 5.311.0

package/dist/lib/daemon/remote-control.js

@@ -22,7 +22,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-export const TMUX_SOCKET = "hq-daemon";
+const TMUX_SOCKET = "hq-daemon";
 export const TMUX_SESSION = "remote-control";
 export const CODEX_TMUX_SESSION = "codex-remote-control";
 export function remoteControlArgs(opts) {

package/dist/lib/daemon/supervisor.d.ts

@@ -25,9 +25,6 @@ import type { UnitPlan } from "./catalog.js";
 import type { MachineType } from "./machine-type.js";
 import type { ControlRequest } from "./requests.js";
 import { syncPassResult } from "./sync-runner.js";
-export declare const BACKOFF_BASE_MS = 1000;
-export declare const BACKOFF_MAX_MS = 60000;
-export declare const HEALTHY_RUN_MS = 60000;
 export declare const STOP_ESCALATION_MS = 10000;
 /** After a handoff, how long a replaced unit must stay up before the next one is replaced. */
 export declare const HANDOFF_STAGGER_MS = 15000;
@@ -42,8 +39,8 @@ export interface SupervisedChild {
     on(event: "error", handler: (err: Error) => void): unknown;
     kill(signal?: NodeJS.Signals | number): boolean;
 }
-export type UnitStatus = "running" | "waiting" | "unavailable" | "backoff" | "exited" | "idle" | "stopped";
-export interface UnitState {
+type UnitStatus = "running" | "waiting" | "unavailable" | "backoff" | "exited" | "idle" | "stopped";
+interface UnitState {
     id: string;
     service: string;
     kind: UnitPlan["kind"];
@@ -83,7 +80,7 @@ export interface AdoptedUnit {
     child: SupervisedChild;
 }
 /** A long-running service left running by release(). */
-export interface ReleasedUnit {
+interface ReleasedUnit {
     id: string;
     pid: number;
     key: string;
@@ -123,9 +120,6 @@ export interface Supervisor {
     /** Stop supervising without signalling any child; returns the long-running units left running. */
     release(): ReleasedUnit[];
 }
-/** Plan reads in a row that must find a running remote-control host blocked before it is paused. */
-export declare const BLOCKED_READS_BEFORE_PAUSE = 2;
-export declare function backoffMs(attempt: number): number;
 /**
  * What a unit's process was started from; a unit whose key changes is
  * restarted. The CLI version counts only for `hq` commands, so a CLI update
@@ -134,4 +128,5 @@ export declare function backoffMs(attempt: number): number;
  */
 export declare function planKey(plan: UnitPlan, cliVersion?: string): string;
 export declare function createSupervisor(deps: SupervisorDeps): Supervisor;
+export {};
 //# sourceMappingURL=supervisor.d.ts.map

package/dist/lib/daemon/supervisor.js

@@ -23,9 +23,9 @@
  */
 import { StringDecoder } from "node:string_decoder";
 import { SYNC_RUNNER_LEASE_CONFLICT_EXIT, SYNC_RUNNER_LEASE_RETRY_MS, parseSyncRunnerProtocolLine, syncPassResult, } from "./sync-runner.js";
-export const BACKOFF_BASE_MS = 1_000;
-export const BACKOFF_MAX_MS = 60_000;
-export const HEALTHY_RUN_MS = 60_000;
+const BACKOFF_BASE_MS = 1_000;
+const BACKOFF_MAX_MS = 60_000;
+const HEALTHY_RUN_MS = 60_000;
 export const STOP_ESCALATION_MS = 10_000;
 const MESH_OWNER_RECHECK_MS = 15_000;
 const MESH_OWNER_LOG_INTERVAL_MS = 10 * 60_000;
@@ -34,8 +34,8 @@ export const HANDOFF_STAGGER_MS = 15_000;
 /** How long a draining unit may take to finish its work before it gets SIGTERM. */
 export const HANDOFF_DRAIN_MAX_MS = 15 * 60_000;
 /** Plan reads in a row that must find a running remote-control host blocked before it is paused. */
-export const BLOCKED_READS_BEFORE_PAUSE = 2;
-export function backoffMs(attempt) {
+const BLOCKED_READS_BEFORE_PAUSE = 2;
+function backoffMs(attempt) {
     return Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** Math.max(0, attempt));
 }
 /**

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

@@ -1,4 +1,5 @@
 import type { AdmissionHost } from "./admission.js";
+import type { LaneHost } from "./types.js";
 export declare const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
 export declare const OUTPOST_DIR = "/etc/outpost";
 export type OutpostIdentity = {
@@ -16,4 +17,6 @@ export declare function resolveAdmissionHost(deps?: {
     existsSync?: (p: string) => boolean;
     readFileSync?: (p: string) => string;
 }): AdmissionHost;
+/** `primary` names the controller registry unless the caller is a different Outpost. */
+export declare function isControllerAliasOutpostId(outpostId: string, localHost: LaneHost): boolean;
 //# sourceMappingURL=admission-host.d.ts.map

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

@@ -30,4 +30,8 @@ export function resolveAdmissionHost(deps = {}) {
         outpostId: identity.kind === "id" ? identity.id : null,
     };
 }
+/** `primary` names the controller registry unless the caller is a different Outpost. */
+export function isControllerAliasOutpostId(outpostId, localHost) {
+    return outpostId === "primary" && !(localHost.kind === "outpost" && localHost.id !== "primary");
+}
 //# sourceMappingURL=admission-host.js.map

package/dist/lib/lanes/autopilot-registry.d.ts

@@ -0,0 +1,62 @@
+import type { LaneCompanyRef, LaneHost } from "./types.js";
+export declare const OUTPOST_LEAD_REGISTRY_SCHEMA = "hq-lanes-outpost-lead-registry.v1";
+export declare const OUTPOST_LEAD_REGISTRY_MAX_AGE_MS: number;
+export declare const OUTPOST_LEAD_REGISTRY_REFRESH_MS: number;
+export declare const LEAD_REGISTRY_REL: string;
+export declare const OUTPOST_LEAD_REGISTRY_STATE_REL: string;
+export declare const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
+export interface LeadRegistryRow {
+    team: string;
+    lane: string;
+    host: string;
+    status: string;
+    prd: string;
+}
+export interface OutpostLeadRegistry {
+    schema_version: typeof OUTPOST_LEAD_REGISTRY_SCHEMA;
+    outpost_id: string;
+    generated_at: string;
+    juniors: LeadRegistryRow[];
+}
+export declare function buildOutpostLeadRegistry(input: {
+    rows: readonly LeadRegistryRow[];
+    outpostId: string;
+    generatedAt: string;
+}): OutpostLeadRegistry;
+/** Stage a host-filtered registry on the Outpost using an atomic local rename. */
+export declare function buildOutpostLeadRegistryInstallCommand(registry: OutpostLeadRegistry): string;
+export declare function syncOutpostLeadRegistries(input: {
+    hqRoot: string;
+    outpostIds: readonly string[];
+    generatedAt: string;
+    localHost: LaneHost;
+    resolveCompany: (slug: string) => Promise<LaneCompanyRef>;
+    readFlag: (flag: string, options: {
+        company: LaneCompanyRef;
+    }) => Promise<boolean>;
+    dispatch: (request: {
+        outpostId: string;
+        command: string;
+        timeoutSeconds?: number;
+        waitMs?: number;
+    }) => Promise<{
+        done?: boolean;
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+    }>;
+}): Promise<Array<{
+    outpost_id: string;
+    row_count: number;
+    skipped: Array<{
+        lane: string;
+        reason: string;
+    }>;
+    dispatched: boolean;
+}>>;
+export declare function validateOutpostLeadRegistry(input: {
+    registry: unknown;
+    outpostId: string;
+    now: Date;
+}): OutpostLeadRegistry;
+//# sourceMappingURL=autopilot-registry.d.ts.map

package/dist/lib/lanes/autopilot-registry.js

@@ -0,0 +1,192 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { joinCommandParts, withRemoteHqDir } from "@indigoai-us/hq-cloud/outposts";
+import { isControllerAliasOutpostId } from "./admission-host.js";
+import { LanesError } from "./errors.js";
+export const OUTPOST_LEAD_REGISTRY_SCHEMA = "hq-lanes-outpost-lead-registry.v1";
+export const OUTPOST_LEAD_REGISTRY_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const OUTPOST_LEAD_REGISTRY_REFRESH_MS = 6 * 60 * 60 * 1000;
+export const LEAD_REGISTRY_REL = path.join("workspace", "lane-briefs", "juniors.json");
+export const OUTPOST_LEAD_REGISTRY_STATE_REL = path.join("workspace", "lane-briefs", "autopilot-outpost-registry-state.json");
+export const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseSourceRegistry(file) {
+    let parsed;
+    try {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("expected a regular file");
+        parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new LanesError("lead_autopilot_registry_unreadable", `Cannot read primary lead registry ${file}: ${error instanceof Error ? error.message : String(error)}`, { path: file });
+    }
+    // A retired-only registry has no leads, matching the autopilot reader.
+    if (isRecord(parsed) && parsed.juniors === undefined && Array.isArray(parsed.retired))
+        return [];
+    if (!isRecord(parsed) || !Array.isArray(parsed.juniors)) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Invalid primary lead registry ${file}: juniors must be an array`, { path: file });
+    }
+    return parsed.juniors.map((row, index) => {
+        if (!isRecord(row) ||
+            ["team", "lane", "host", "status", "prd"].some((key) => typeof row[key] !== "string" || !row[key].trim())) {
+            throw new LanesError("lead_autopilot_registry_invalid", `Invalid primary lead registry ${file}: juniors[${index}] must name team, lane, host, status, and prd`, { path: file, index });
+        }
+        return row;
+    });
+}
+export function buildOutpostLeadRegistry(input) {
+    if (!input.outpostId.trim() || !Number.isFinite(Date.parse(input.generatedAt))) {
+        throw new LanesError("lead_autopilot_registry_invalid", "Outpost registry target and generation time must be valid", { outpost_id: input.outpostId });
+    }
+    return {
+        schema_version: OUTPOST_LEAD_REGISTRY_SCHEMA,
+        outpost_id: input.outpostId,
+        generated_at: new Date(input.generatedAt).toISOString(),
+        juniors: input.rows.filter((row) => row.host === input.outpostId),
+    };
+}
+/** Stage a host-filtered registry on the Outpost using an atomic local rename. */
+export function buildOutpostLeadRegistryInstallCommand(registry) {
+    const encoded = Buffer.from(`${JSON.stringify(registry)}\n`, "utf8").toString("base64");
+    const script = [
+        'const fs=require("node:fs"),path=require("node:path");',
+        'const root=process.cwd(),dir=path.join(root,"workspace","lane-briefs"),file=path.join(dir,"juniors.json");',
+        "fs.mkdirSync(dir,{recursive:true});const realRoot=fs.realpathSync(root),realDir=fs.realpathSync(dir);",
+        'if(realDir!==realRoot&&!realDir.startsWith(realRoot+path.sep))throw Error("registry directory escapes HQ root");',
+        'try{const s=fs.lstatSync(file);if(!s.isFile()||s.isSymbolicLink())throw Error("registry destination must be a regular file")}catch(e){if(e.code!=="ENOENT")throw e}',
+        `const bytes=Buffer.from("${encoded}","base64"),tmp=file+"."+process.pid+".tmp";`,
+        'fs.writeFileSync(tmp,bytes,{mode:0o600,flag:"wx"});try{fs.renameSync(tmp,file)}catch(e){try{fs.unlinkSync(tmp)}catch{}throw e}',
+    ].join("");
+    return withRemoteHqDir(joinCommandParts(["node", "-e", script]));
+}
+function companySlug(row) {
+    const match = /^companies\/([a-z0-9][a-z0-9._-]*)\//i.exec(row.prd);
+    return match?.[1] ?? null;
+}
+function readDeliveryState(file) {
+    try {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("expected regular state file");
+        const value = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!isRecord(value) ||
+            value.schema_version !== "hq-lanes-outpost-registry-delivery-state.v1" ||
+            !isRecord(value.delivered)) {
+            throw new Error("invalid delivery state shape");
+        }
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { schema_version: "hq-lanes-outpost-registry-delivery-state.v1", delivered: {} };
+        }
+        throw new LanesError("lead_autopilot_registry_state_invalid", `Cannot read registry delivery state: ${error instanceof Error ? error.message : String(error)}`, { path: file });
+    }
+}
+function writeDeliveryState(file, state) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`;
+    try {
+        fs.writeFileSync(temp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        fs.renameSync(temp, file);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temp);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== "ENOENT")
+                throw cleanupError;
+        }
+        throw error;
+    }
+}
+export async function syncOutpostLeadRegistries(input) {
+    const sourceFile = path.join(input.hqRoot, LEAD_REGISTRY_REL);
+    // Most HQ installs have no lead registry. Nothing to deliver is not a reconcile failure.
+    if (!fs.existsSync(sourceFile))
+        return [];
+    const sourceRows = parseSourceRegistry(sourceFile);
+    const eligible = [];
+    const skipped = [];
+    const enabledByCompany = new Map();
+    for (const row of sourceRows) {
+        const slug = companySlug(row);
+        if (!slug) {
+            skipped.push({ lane: row.lane, reason: "company_unresolved" });
+            continue;
+        }
+        let enabled = enabledByCompany.get(slug);
+        if (enabled === undefined) {
+            const company = await input.resolveCompany(slug);
+            enabled = await input.readFlag(LEAD_AUTOPILOT_FLAG, { company });
+            enabledByCompany.set(slug, enabled);
+        }
+        if (!enabled) {
+            skipped.push({ lane: row.lane, reason: "flag_off" });
+            continue;
+        }
+        eligible.push(row);
+    }
+    const stateFile = path.join(input.hqRoot, OUTPOST_LEAD_REGISTRY_STATE_REL);
+    const state = readDeliveryState(stateFile);
+    const results = [];
+    const targets = [...new Set(input.outpostIds.map((id) => id.trim()))]
+        .filter((id) => id && !isControllerAliasOutpostId(id, input.localHost))
+        .sort();
+    for (const outpostId of targets) {
+        const registry = buildOutpostLeadRegistry({ rows: eligible, outpostId, generatedAt: input.generatedAt });
+        // Hash only the rows. A new generated_at alone does not trigger a remote write.
+        const hash = crypto.createHash("sha256").update(JSON.stringify(registry.juniors)).digest("hex");
+        const prior = state.delivered[outpostId];
+        const age = prior ? Date.parse(input.generatedAt) - Date.parse(prior.at) : Infinity;
+        const shouldDispatch = !prior ||
+            prior.hash !== hash ||
+            !Number.isFinite(age) ||
+            age < 0 ||
+            age >= OUTPOST_LEAD_REGISTRY_REFRESH_MS;
+        if (shouldDispatch) {
+            const result = await input.dispatch({
+                outpostId,
+                command: buildOutpostLeadRegistryInstallCommand(registry),
+                timeoutSeconds: 120,
+                waitMs: 120_000,
+            });
+            if (result.done !== true || result.exitCode !== 0) {
+                throw new LanesError("lead_autopilot_registry_sync_failed", `Could not sync lead registry to Outpost ${outpostId}`, { outpost_id: outpostId, exit_code: result.exitCode, done: result.done === true });
+            }
+            state.delivered[outpostId] = { hash, at: new Date(input.generatedAt).toISOString() };
+            writeDeliveryState(stateFile, state);
+        }
+        results.push({
+            outpost_id: outpostId,
+            row_count: registry.juniors.length,
+            skipped: skipped.filter(({ lane }) => sourceRows.some((row) => row.lane === lane && row.host === outpostId)),
+            dispatched: shouldDispatch,
+        });
+    }
+    return results;
+}
+export function validateOutpostLeadRegistry(input) {
+    const value = input.registry;
+    if (!isRecord(value) ||
+        value.schema_version !== OUTPOST_LEAD_REGISTRY_SCHEMA ||
+        value.outpost_id !== input.outpostId ||
+        typeof value.generated_at !== "string" ||
+        !Array.isArray(value.juniors)) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Outpost ${input.outpostId} has an invalid lead registry`, { outpost_id: input.outpostId });
+    }
+    const age = input.now.getTime() - Date.parse(value.generated_at);
+    if (!Number.isFinite(age) || age < 0 || age > OUTPOST_LEAD_REGISTRY_MAX_AGE_MS) {
+        throw new LanesError("lead_autopilot_registry_stale", `Outpost ${input.outpostId} lead registry is stale`, { outpost_id: input.outpostId, generated_at: value.generated_at });
+    }
+    if (value.juniors.some((row) => !isRecord(row) || row.host !== input.outpostId)) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Outpost ${input.outpostId} registry contains rows for another host`, { outpost_id: input.outpostId });
+    }
+    return value;
+}
+//# sourceMappingURL=autopilot-registry.js.map

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

@@ -43,6 +43,8 @@ export interface AutopilotPassResult {
         lead_lane: string;
         reason: string;
     }>;
+    /** Set on an Outpost that has not received a lead registry from the primary yet. */
+    registry?: "missing";
 }
 interface ProjectStory {
     id: string;

package/dist/lib/lanes/autopilot.js

@@ -1,6 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { laneRunsOnHost } from "./admission.js";
+import { isControllerAliasOutpostId } from "./admission-host.js";
+import { LEAD_REGISTRY_REL, validateOutpostLeadRegistry } from "./autopilot-registry.js";
 import { appendDropboxMessage } from "./dropbox.js";
 import { LanesError } from "./errors.js";
 import { resolveLaneCompany } from "./lane-company.js";
@@ -37,21 +39,28 @@ function readJsonFile(filePath, code) {
         throw new LanesError(code, `Cannot parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { path: filePath });
     }
 }
-function parseRegistry(hqRoot) {
-    const file = path.join(hqRoot, "workspace", "lane-briefs", "juniors.json");
+function parseRegistry(hqRoot, outpostId, now) {
+    const file = path.join(hqRoot, LEAD_REGISTRY_REL);
     let stat;
     try {
         stat = fs.lstatSync(file);
     }
     catch (error) {
-        if (error.code === "ENOENT")
+        if (error.code === "ENOENT") {
+            // An Outpost without a delivered registry reports it; it does not fail reconcile.
+            // The primary delivers nothing when it has no registry or every company is flagged off.
+            if (outpostId !== null && !isControllerAliasOutpostId(outpostId, { kind: "outpost", id: outpostId }))
+                return null;
             return [];
+        }
         throw new LanesError("lead_autopilot_registry_invalid", `Cannot inspect ${file}: ${error instanceof Error ? error.message : String(error)}`, { path: file });
     }
     if (!stat.isFile() || stat.isSymbolicLink()) {
         throw new LanesError("lead_autopilot_registry_invalid", `Invalid lead registry ${file}: expected a regular file`, { path: file });
     }
     const raw = readJsonFile(file, "lead_autopilot_registry_invalid");
+    if (outpostId !== null && !isControllerAliasOutpostId(outpostId, { kind: "outpost", id: outpostId }))
+        return validateOutpostLeadRegistry({ registry: raw, outpostId, now }).juniors;
     if (isRecord(raw) && raw.juniors === undefined && Array.isArray(raw.retired))
         return [];
     if (!isRecord(raw) || !Array.isArray(raw.juniors)) {
@@ -407,8 +416,12 @@ function recordOperatorEscalation(hqRoot, record) {
 }
 async function runLeadAutopilotPassUnlocked(input) {
     const { hqRoot, host, now } = input;
+    const effectiveOutpostId = input.outpostId !== null && isControllerAliasOutpostId(input.outpostId, { kind: "outpost", id: input.outpostId }) ? null : input.outpostId;
     const result = { ok: true, host, evaluated: 0, sent: [], started: [], escalated: [], skipped: [] };
-    const leads = parseRegistry(hqRoot);
+    const registered = parseRegistry(hqRoot, input.outpostId, now);
+    if (registered === null)
+        result.registry = "missing";
+    const leads = registered ?? [];
     const lanes = readAllLanes(hqRoot);
     const byId = new Map(lanes.map((lane) => [lane.lane_id, lane]));
     const stateFile = path.join(hqRoot, "workspace", "lane-briefs", "autopilot-state.json");
@@ -429,7 +442,7 @@ async function runLeadAutopilotPassUnlocked(input) {
             ? lead.host.kind === "local"
             : lead.host.kind === "outpost" && lead.host.id === registered.host && input.outpostId === registered.host;
         if (!hostMatchesRegistry ||
-            !laneRunsOnHost(lead, { hostname: input.hostname, outpostId: input.outpostId })) {
+            !laneRunsOnHost(lead, { hostname: input.hostname, outpostId: effectiveOutpostId })) {
             result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_host_mismatch" });
             continue;
         }

package/dist/lib/lanes/claude-balance.d.ts

@@ -1,6 +1,7 @@
 import type { AuthState } from "./accounts.js";
 import type { HostCapacityAccount, HostCapacitySnapshot } from "./host-capacity.js";
 import type { LaneHost, LaneRecord, LanesConfig } from "./types.js";
+import { type QuotaState } from "./quota.js";
 export declare const BALANCE_LIVE_STATES: readonly ["running", "queued", "awaiting_input"];
 export declare const BALANCE_MOVABLE_STATES: readonly ["interrupted", "done", "awaiting_input"];
 export declare const CLAUDE_RECENT_USAGE_WINDOW_MS: number;
@@ -37,6 +38,9 @@ export interface ClaudeAccountLoad {
     target_logged_in: boolean | null;
     eligible: boolean;
     ineligible_reason?: string;
+    quota_reset_at?: string;
+    quota_marker?: string;
+    quota_model?: string;
     live_lanes: number;
     counts_complete: boolean;
     usage: NonNullable<HostCapacityAccount["usage"]> | null;
@@ -74,6 +78,7 @@ export declare function selectClaudeAccount(input: {
     model?: string;
     /** Keep the recorded account eligible for its already-running CLI model. */
     recordedModelAccount?: string;
+    quotaState?: QuotaState;
     /** Recent completed-run tiebreak; callers pass the default-off hq-flags result. */
     recentUsageEnabled?: boolean;
     now?: Date;
@@ -83,6 +88,7 @@ export declare function selectClaudeAccount(input: {
 export declare function accountLoadsForReport(input: {
     hosts: readonly BalanceHostSnapshot[];
     config: LanesConfig;
+    quotaState?: QuotaState;
 }): ClaudeAccountLoad[];
 export declare function planClaudeBalanceMoves(input: {
     hosts: readonly BalanceHostSnapshot[];

package/dist/lib/lanes/claude-balance.js

@@ -1,4 +1,5 @@
 import { LanesError } from "./errors.js";
+import { quotaBlockFor } from "./quota.js";
 export const BALANCE_LIVE_STATES = ["running", "queued", "awaiting_input"];
 export const BALANCE_MOVABLE_STATES = ["interrupted", "done", "awaiting_input"];
 export const CLAUDE_RECENT_USAGE_WINDOW_MS = 5 * 60 * 60 * 1000;
@@ -126,10 +127,16 @@ function buildLoads(input) {
         const hosts = input.hosts.map((host) => accountHostLoad(host, account));
         const targetLoad = hosts.find((host) => sameHost(host.host, targetHost));
         const configuredModel = configAccounts[account]?.model;
+        const quotaModel = input.model ?? configuredModel ?? input.config.providers.claude.model;
+        const quotaBlock = input.quotaState === undefined
+            ? undefined
+            : quotaBlockFor(input.quotaState, "claude", account, quotaModel, input.now);
         const ineligible = targetIneligibilityReason(account, configAccounts[account]?.enabled === true, input.allowedAccounts, targetLoad) ?? (account !== input.recordedModelAccount &&
             input.model !== undefined && configuredModel !== undefined && configuredModel !== input.model
             ? "model_mismatch"
-            : undefined);
+            : quotaBlock?.blocked === true
+                ? "quota_held"
+                : undefined);
         if (ineligible !== undefined)
             skipped.push({ account, host: targetHost, reason: ineligible });
         const knownCounts = hosts.flatMap((host) => host.live_lanes === null ? [] : [host.live_lanes]);
@@ -139,6 +146,11 @@ function buildLoads(input) {
             target_logged_in: targetLoad.logged_in,
             eligible: ineligible === undefined,
             ...(ineligible !== undefined ? { ineligible_reason: ineligible } : {}),
+            ...(quotaBlock?.blocked ? {
+                ...(quotaBlock.quota_reset_at !== undefined ? { quota_reset_at: quotaBlock.quota_reset_at } : {}),
+                ...(quotaBlock.marker !== undefined ? { quota_marker: quotaBlock.marker } : {}),
+                ...(quotaBlock.model !== undefined ? { quota_model: quotaBlock.model } : {}),
+            } : {}),
             live_lanes: knownCounts.reduce((sum, count) => sum + count, 0),
             counts_complete: hosts.every((host) => host.live_lanes !== null && host.count_source !== "capacity_partial"),
             usage: input.target.capacity.providers.claude.accounts[account]?.usage ?? null,
@@ -193,6 +205,9 @@ export function selectClaudeAccount(input) {
             account_reasons: loads.map((load) => ({
                 account: load.account,
                 reason: load.ineligible_reason ?? "unavailable",
+                ...(load.quota_reset_at !== undefined ? { quota_reset_at: load.quota_reset_at } : {}),
+                ...(load.quota_marker !== undefined ? { marker: load.quota_marker } : {}),
+                ...(load.quota_model !== undefined ? { model: load.quota_model } : {}),
             })),
             unavailable_hosts: input.unavailableHosts ?? [],
         });
@@ -234,7 +249,7 @@ export function accountLoadsForReport(input) {
     const first = input.hosts[0];
     if (!first)
         return [];
-    return buildLoads({ hosts: input.hosts, target: first, config: input.config, now: new Date() }).loads.map((load) => ({
+    return buildLoads({ hosts: input.hosts, target: first, config: input.config, quotaState: input.quotaState, now: new Date() }).loads.map((load) => ({
         ...load,
         eligible: false,
         ineligible_reason: undefined,

package/dist/lib/lanes/keep-alive.d.ts

@@ -6,6 +6,9 @@ export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS: number;
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG = "lanes.keep-alive-immediate-first-resume";
+export declare const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS = 30000;
 export declare const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS: number;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
 export declare const LANE_SUPERSESSION_LINEAGE_AWARE_FLAG = "lanes.supersession-lineage-aware";

package/dist/lib/lanes/keep-alive.js

@@ -11,6 +11,9 @@ export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS = 24 * 60 * 60 * 1000;
 export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
 export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG = "lanes.keep-alive-immediate-first-resume";
+export const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS = 30_000;
 export const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS = 15 * 60 * 1000;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
 export const LANE_SUPERSESSION_LINEAGE_AWARE_FLAG = "lanes.supersession-lineage-aware";

package/dist/lib/lanes/reconcile.js

@@ -25,7 +25,7 @@ import { readLanesRegistryFlag } from "./registry-flag.js";
 import { resolveLaneCompany } from "./lane-company.js";
 import { appendDropboxMessage } from "./dropbox.js";
 import { DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG, listHostProcesses, runRunawayToolGuard, RUNAWAY_TOOL_GUARD_FLAG, } from "./runaway-tool-guard.js";
-import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, queueLaneTerminalResume, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, queueLaneTerminalResume, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
 import { providerSupportsSessionResume } from "./delivery.js";
 import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, readQuotaSignal, recordAccountQuota, } from "./quota.js";
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
@@ -1119,6 +1119,7 @@ export async function runPassBody(hqRoot, deps) {
     const keepAliveFlagByCompany = new Map();
     const nextCheckAtFlagByCompany = new Map();
     const blockedResumeFlagByCompany = new Map();
+    const immediateFirstResumeFlagByCompany = new Map();
     const supersessionLineageAwareByCompany = new Map();
     await Promise.all([...keepAliveFlagCompanies.entries()].map(async ([key, company]) => {
         const options = {
@@ -1129,7 +1130,7 @@ export async function runPassBody(hqRoot, deps) {
             lane.keep_alive === true &&
             laneRunsHere(lane, startDeps.host) &&
             keepAliveCompanyKey(resolveLaneCompany(hqRoot, lane).company) === key);
-        const [keepAliveEnabled, nextCheckAtEnabled, lineageAware, blockedResumeEnabled] = await Promise.all([
+        const [keepAliveEnabled, nextCheckAtEnabled, lineageAware, blockedResumeEnabled, immediateFirstResumeEnabled] = await Promise.all([
             readRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, options),
             nextCheckAtFlagCompanyKeys.has(key)
                 ? readRegistryFlag(LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, options)
@@ -1138,10 +1139,12 @@ export async function runPassBody(hqRoot, deps) {
             hasBlockedKeepAliveLane
                 ? readRegistryFlag(LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, options)
                 : Promise.resolve(false),
+            readRegistryFlag(LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, options),
         ]);
         keepAliveFlagByCompany.set(key, keepAliveEnabled);
         nextCheckAtFlagByCompany.set(key, nextCheckAtEnabled);
         blockedResumeFlagByCompany.set(key, blockedResumeEnabled);
+        immediateFirstResumeFlagByCompany.set(key, immediateFirstResumeEnabled);
         supersessionLineageAwareByCompany.set(key, lineageAware);
     }));
     const admissionThrottleDeps = startDeps.throttleDeps ?? defaultThrottleDeps(startDeps.env ?? process.env);
@@ -1162,7 +1165,7 @@ export async function runPassBody(hqRoot, deps) {
         const freshLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
         await closeInterruptedDoneStoryWorkers(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, storyCloseEnabledByCompany);
-        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany);
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany, immediateFirstResumeFlagByCompany);
         const drainLanes = loadLaneRecords(hqRoot, summary);
         await admitQueued(hqRoot, drainLanes, summary, admissionDeps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, admissionDeps);
@@ -2241,7 +2244,7 @@ function appendBlockedKeepAliveHistory(hqRoot, lane, terminalAt, at, reason, dep
         }),
     }), false);
 }
-async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany) {
+async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany, immediateFirstResumeFlagByCompany) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
@@ -2634,7 +2637,12 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
         const terminalAtMs = initialState === "done"
             ? Math.min(Date.parse(current.updated_at), currentEligibilityAtMs)
             : currentEligibilityAtMs;
-        const attemptEligibleMs = terminalAtMs + leadLaneKeepAliveBackoffMs(attempt);
+        const immediateFirstResumeEnabled = initialState === "done" &&
+            immediateFirstResumeFlagByCompany.get(keepAliveCompanyKey(companyForLane(current))) === true;
+        const attemptDelayMs = immediateFirstResumeEnabled && attempt === 1
+            ? LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS
+            : leadLaneKeepAliveBackoffMs(immediateFirstResumeEnabled ? Math.max(1, attempt - 1) : attempt);
+        const attemptEligibleMs = terminalAtMs + attemptDelayMs;
         const storedNextMs = resetByHuman
             ? Number.NaN
             : Date.parse(current.keep_alive_next_eligible_at ?? "");
@@ -2653,7 +2661,7 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
             recordKeepAliveSkipEvent(hqRoot, skipLane, "backoff", skipLane.version, summary, deps, new Date(nextEligibleMs).toISOString());
             continue;
         }
-        const nextEligibleAt = new Date(nowMs + leadLaneKeepAliveBackoffMs(attempt + 1)).toISOString();
+        const nextEligibleAt = new Date(nowMs + leadLaneKeepAliveBackoffMs(immediateFirstResumeEnabled ? attempt : attempt + 1)).toISOString();
         const queuedCount = loadLaneRecords(hqRoot, summary).filter((queuedLane) => queuedLane.state === "queued" &&
             queuedLane.provider === current.provider &&
             laneRunsHere(queuedLane, deps.host) &&

package/dist/lib/lanes/spawn.js

@@ -16,6 +16,7 @@ import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, selectBa
 import { effectiveAccountHome } from "./account-home.js";
 import { buildHostCapacitySnapshot } from "./host-capacity.js";
 import { selectClaudeAccount } from "./claude-balance.js";
+import { loadQuotaState } from "./quota.js";
 import { COMPACTION_PROMPT, compactionAfterUsage, compactionDue, compactLaneSession, } from "./compaction.js";
 import { installDrainHook } from "./hooks-install.js";
 import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } from "./config.js";
@@ -269,6 +270,7 @@ function selectSpawnAccount(input) {
             hosts: [{ capacity, lanes, laneListAvailable: true }],
             targetHost: lane.host,
             config,
+            quotaState: loadQuotaState(hqRoot),
             ...((recordedModel ?? pinnedModel ?? profileModel) !== undefined
                 ? { model: recordedModel ?? pinnedModel ?? profileModel }
                 : {}),