@indigoai-us/hq-cli 5.345.43 → 5.345.44

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [5.345.44] — 2026-10-07
+- Quota-exhausted lanes can fail over within their provider, hold with per-account eligibility reasons when none is available, and retry when the earliest quota reset arrives. The default-off `lanes.quota-account-failover` gate controls the new recovery path.
+
+- When a company's plan does not include remote databases, `hq db provision`, `usage`, `sql`, `dump` and `destroy` now show which plan includes them, the $10 per database app price and the upgrade link.
+- `hq lanes report` can show a gated focus list, focus-guard override reasons, and per-team 24-hour focus share.
+- Return a child's hire grant to its senior when the lane becomes terminal, let the senior adjust or clear the saved grant, report grant updates correctly, and reject over-cap increases while allowing reductions that repair oversubscription.
+- Recover CLI startup when a package update temporarily removes a module from the installed command graph.
+
+
 ## [5.345.43] — 2026-10-07
 - The published core-command E2E workflow now retries the exact npm release install for up to 10 minutes while registry propagation completes.
 

package/dist/commands/db-remote-deps.js

@@ -42,6 +42,10 @@ export function describeRemoteError(error) {
     const status = error.status;
     const code = error.code;
     if (code === "REMOTE_DB_NOT_AVAILABLE" || status === 501) {
+        const reason = error.reason;
+        const message = error.message;
+        if (reason === "plan" && typeof message === "string" && message)
+            return message;
         return "Remote databases are not available yet.";
     }
     if (status === 402 || code === "PLAN_REQUIRED") {

package/dist/commands/lanes-checks.d.ts

@@ -22,6 +22,7 @@ export declare function mappingIncludesStory(mapping: ProjectMapping, storyId: s
 export interface ProjectReadResult {
     stories: Array<Record<string, unknown>>;
     mtime: number;
+    focus_overrides?: unknown;
     errors?: Array<{
         path: string;
         field: string;

package/dist/commands/lanes-checks.js

@@ -272,7 +272,12 @@ export function readProject(root, company, prdPath, tolerantStories = false) {
         return [story];
     });
     try {
-        return { stories, mtime: fs.statSync(prdPath).mtimeMs, ...(tolerantStories ? { errors } : {}) };
+        return {
+            stories,
+            mtime: fs.statSync(prdPath).mtimeMs,
+            ...(parsed.focus_overrides === undefined ? {} : { focus_overrides: parsed.focus_overrides }),
+            ...(tolerantStories ? { errors } : {}),
+        };
     }
     catch (err) {
         return fail("tracker_checks_input_unreadable", `Project task list could not be stat'ed: ${err instanceof Error ? err.message : String(err)}`, { path: prdPath });

package/dist/commands/lanes-report.d.ts

@@ -1,10 +1,11 @@
 import type { Command } from "commander";
 import { type QuestionBody } from "../lib/lanes/questions.js";
-import type { QuestionRecord } from "../lib/lanes/types.js";
+import type { LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
 import { type LaneChecksDeps } from "./lanes-checks.js";
 type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
 export interface LaneReportsDeps extends LaneChecksDeps {
     readQuestionBody: (root: string, question: QuestionRecord) => QuestionBody;
+    focusDashboardEnabled: (company: LaneCompanyRef) => Promise<boolean>;
 }
 export declare function registerLaneReportCommands(parent: Command, deps: LaneReportsDeps, wrap: WrapHandler): void;
 export {};

package/dist/commands/lanes-report.js

@@ -163,7 +163,7 @@ function issueFromError(err, fallbackPath, fallbackField, ids = {}) {
         ...(typeof details.question_id === "string" ? { question_id: details.question_id } : ids.question_id ? { question_id: ids.question_id } : {}),
     };
 }
-async function teamInput(root, company, project, questions, deps, errors = []) {
+async function teamInput(root, company, project, questions, deps, errors = [], includeFocusDashboard = false) {
     const projectDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
     const prdPath = path.join(projectDirectory, "prd.json");
     let prd = { stories: [], mtime: 0 };
@@ -213,10 +213,64 @@ async function teamInput(root, company, project, questions, deps, errors = []) {
             }
             normalizedUpdatedAt = normalized;
         }
+        const ownerValue = includeFocusDashboard ? story.owner ?? story.assignee : undefined;
+        let owner = null;
+        if (ownerValue !== undefined && ownerValue !== null) {
+            if (typeof ownerValue === "string" && ownerValue.trim())
+                owner = ownerValue.trim();
+            else
+                errors.push({ path: prdPath, field: "owner", story_id: id, message: "Story owner must be a non-empty string when present" });
+        }
+        const deadlineValue = includeFocusDashboard ? story.deadline ?? story.due_at ?? story.due_date : undefined;
+        let deadline = null;
+        if (deadlineValue !== undefined && deadlineValue !== null) {
+            if (typeof deadlineValue === "string" && deadlineValue.trim())
+                deadline = deadlineValue.trim();
+            else
+                errors.push({ path: prdPath, field: "deadline", story_id: id, message: "Story deadline must be a non-empty string when present" });
+        }
         const refs = storyReferences(story, prdPath, id, errors);
         pullRequests.push(...refs.pullRequests);
         releases.push(...refs.releases);
-        stories.push({ id, title, status, references: refs.references, ...(normalizedUpdatedAt ? { updated_at: normalizedUpdatedAt } : {}), source_path: prdPath });
+        stories.push({
+            id,
+            title,
+            status,
+            focus_id: story.focus_id,
+            kpi: story.kpi,
+            owner,
+            deadline,
+            references: refs.references,
+            ...(normalizedUpdatedAt ? { updated_at: normalizedUpdatedAt } : {}),
+            source_path: prdPath,
+        });
+    }
+    const focusOverrides = [];
+    if (includeFocusDashboard && prd.focus_overrides !== undefined) {
+        if (!Array.isArray(prd.focus_overrides)) {
+            errors.push({ path: prdPath, field: "focus_overrides", message: "Project focus_overrides must be an array" });
+        }
+        else {
+            for (const [index, raw] of prd.focus_overrides.entries()) {
+                if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+                    errors.push({ path: prdPath, field: `focus_overrides[${index}]`, message: "Focus override must be an object" });
+                    continue;
+                }
+                const record = raw;
+                if (["reason", "by_lane", "at", "story"].some((field) => typeof record[field] !== "string" || !record[field].trim())) {
+                    errors.push({ path: prdPath, field: `focus_overrides[${index}]`, message: "Focus override needs non-empty reason, by_lane, at, and story fields" });
+                    continue;
+                }
+                const at = normalizeIsoTimestamp(record.at);
+                if (at === null) {
+                    errors.push({ path: prdPath, field: `focus_overrides[${index}].at`, message: "Focus override at must be a valid timestamp" });
+                    continue;
+                }
+                const override = { reason: record.reason, by_lane: record.by_lane, at, story: record.story };
+                if (mappingIncludesStory(project, override.story))
+                    focusOverrides.push(override);
+            }
+        }
     }
     const teamQuestions = [];
     for (const record of questions.filter((question) => question.project_id === project.projectId
@@ -236,6 +290,7 @@ async function teamInput(root, company, project, questions, deps, errors = []) {
         team: project.team,
         project_id: project.projectId,
         stories,
+        focus_overrides: focusOverrides,
         pull_requests: pullRequests,
         releases,
         blockers: await trackerRecords(root, company, project, "blocker", errors),
@@ -246,7 +301,7 @@ async function teamInput(root, company, project, questions, deps, errors = []) {
         errors,
     };
 }
-async function allTeamInputs(root, company, deps) {
+async function allTeamInputs(root, company, deps, includeFocusDashboard) {
     const mappings = loadProjectMappings(root, company.slug);
     const teams = [];
     for (const project of [...mappings.values()].sort((a, b) => a.team.localeCompare(b.team) || a.projectId.localeCompare(b.projectId))) {
@@ -258,7 +313,7 @@ async function allTeamInputs(root, company, deps) {
         catch (err) {
             errors.push(issueFromError(err, path.join(root, "companies", company.slug, "projects", project.projectId), "questions"));
         }
-        teams.push(await teamInput(root, company, project, questions, deps, errors));
+        teams.push(await teamInput(root, company, project, questions, deps, errors, includeFocusDashboard));
     }
     return teams;
 }
@@ -282,6 +337,7 @@ export function registerLaneReportCommands(parent, deps, wrap) {
         const company = await resolveTrackerCompany(deps, options.company);
         const root = deps.hqRoot();
         const generatedAt = deps.now().toISOString();
+        const focusDashboardEnabled = await deps.focusDashboardEnabled(company);
         const previous = options.since === undefined ? readTrackerReportState(root, company.slug) : null;
         const since = options.since ?? previous?.last_report_at ?? FIRST_TRACKER_REPORT_SINCE;
         const input = {
@@ -289,7 +345,8 @@ export function registerLaneReportCommands(parent, deps, wrap) {
             generated_at: generatedAt,
             since,
             since_source: options.since !== undefined ? "explicit" : previous ? "previous_report" : "first_run",
-            teams: await allTeamInputs(root, company, deps),
+            focus_dashboard_enabled: focusDashboardEnabled,
+            teams: await allTeamInputs(root, company, deps, focusDashboardEnabled),
         };
         const report = buildTrackerOwnerReport(input);
         const hasErrors = report.teams.some((team) => team.errors.length > 0);
@@ -323,7 +380,7 @@ export function registerLaneReportCommands(parent, deps, wrap) {
         catch (err) {
             errors.push(issueFromError(err, path.join(root, "companies", company.slug, "projects", candidates[0].projectId), "questions"));
         }
-        const input = await teamInput(root, company, candidates[0], questions, deps, errors);
+        const input = await teamInput(root, company, candidates[0], questions, deps, errors, false);
         const page = buildTrackerTeamPage(input, company.slug, since, generatedAt);
         if (page.errors.length > 0)
             process.exitCode = 2;

package/dist/commands/lanes.js

@@ -37,7 +37,7 @@ import { laneDepthCap } from "../lib/lanes/depth-cap.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
-import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
+import { LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
 import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
@@ -5939,17 +5939,23 @@ async function applyHireGrant(ctx, laneId, hireGrant, authorization, grantContex
                 assigned_child_grants: allocated,
             });
         }
-        return retryUpdateLane(hqRoot, laneId, "command", (record) => ({
-            ...record,
-            hire_grant: hireGrant,
-        }));
+        return retryUpdateLane(hqRoot, laneId, "command", (record) => isTerminalLaneState(record.state)
+            ? { ...record, hire_grant: 0, released_hire_grant: hireGrant }
+            : { ...record, hire_grant: hireGrant });
     });
     return updated;
 }
 async function printGrantResult(ctx, hqRoot, updated, hierarchy) {
     const finishedChildrenDoNotCount = await hireGrantFinishedChildrenDoNotCount(ctx, updated);
     const fields = laneHireFields(updated, hierarchy ?? loadAllLanes(hqRoot), undefined, finishedChildrenDoNotCount);
-    printJson({ ok: true, action: "grant", lane_id: updated.lane_id, lane: updated, ...fields });
+    printJson({
+        ok: true,
+        action: "grant",
+        lane_id: updated.lane_id,
+        lane: updated,
+        ...fields,
+        hire_grant: updated.released_hire_grant ?? fields.hire_grant,
+    });
 }
 /**
  * `hq lanes set`: change the model or effort a lane uses from its next
@@ -8985,6 +8991,10 @@ export function registerLanesCommand(parent, deps = {}) {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
         now: ctx.now,
+        focusDashboardEnabled: (company) => readLanesRegistryFlagFailOff(LANE_FOCUS_DASHBOARD_FLAG, {
+            company,
+            env: ctx.env,
+        }, readLanesRegistryFlag),
         readQuestionBody: (root, question) => {
             const body = questionHandlers.requireQuestionBody(root, question);
             assertQuestionBodySecretSafe(body);

package/dist/index.js

@@ -12,6 +12,7 @@ import { CLI_COMMAND_HELP_CATALOG_FLAG } from "./lib/cli-flag-keys.js";
 // heavy import (main.js) is lazy and reached only when a rejection fires.
 import { installProcessRejectionBoundary } from "./unhandled-rejection-boundary.js";
 import { installFastPathStreamErrorHandlers } from "./utils/fast-stream-errors.js";
+import { fileURLToPath } from "node:url";
 // Install BEFORE any dispatch so a floated rejection on ANY path (the command
 // graph or the fast-core forwarder) becomes a non-zero exit. @sentry/node's
 // onUnhandledRejection integration defaults to 'warn' — it captures but does
@@ -20,6 +21,44 @@ import { installFastPathStreamErrorHandlers } from "./utils/fast-stream-errors.j
 // so runCli's finally still finalizes release health and flushes Sentry.
 installProcessRejectionBoundary();
 installFastPathStreamErrorHandlers();
+async function runMainWithInstallTreeRecovery() {
+    let runCli;
+    const { registerCommandsWithRecovery } = await import("./startup-registration.js");
+    try {
+        const result = await registerCommandsWithRecovery({
+            register: async () => {
+                runCli = (await import("./main.js")).runCli;
+            },
+            argv: process.argv,
+            env: process.env,
+            entryPath: fileURLToPath(import.meta.url),
+            stderr: process.stderr,
+        });
+        if (result.reexecStatus !== undefined) {
+            process.exitCode = result.reexecStatus;
+            return;
+        }
+        if (!runCli)
+            throw new Error("HQ CLI startup did not load its command runner");
+        await runCli();
+    }
+    catch (error) {
+        // main.js may be the module that is missing, so the global rejection
+        // reporter cannot import its usual handler to print the recovery remedy.
+        const installTree = await import("./utils/install-tree-torn.js");
+        if (installTree.isInstallTreeTornError(error)) {
+            process.stderr.write(`${installTree.installTreeTornStderrLine(error)}\n`);
+            const sentry = await import("./sentry.js");
+            sentry.initSentry();
+            sentry.Sentry.captureException(error, installTree.installTreeTornCaptureContext(error));
+            sentry.finishSentrySession();
+            await sentry.Sentry.flush(2_000);
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+}
 function dispatchCliEntry() {
     const versionRequest = isVersionRequest(process.argv);
     const helpRequest = !versionRequest && isCommandHelpRequest(process.argv);
@@ -51,8 +90,7 @@ function dispatchCliEntry() {
                 await runCommandHelp(process.argv);
                 return;
             }
-            const { runCli } = await import("./main.js");
-            await runCli();
+            await runMainWithInstallTreeRecovery();
         });
     }
     else if (parsedFastCore?.entry.kind === "native" &&
@@ -73,8 +111,7 @@ function dispatchCliEntry() {
                 await runFastCore(process.argv, parsedFastCore);
             }
             else {
-                const { runCli } = await import("./main.js");
-                await runCli();
+                await runMainWithInstallTreeRecovery();
             }
         });
     }
@@ -88,8 +125,7 @@ function dispatchCliEntry() {
                     return runSecretsEnvFastPath(request);
                 },
                 runCurrent: async () => {
-                    const { runCli } = await import("./main.js");
-                    await runCli();
+                    await runMainWithInstallTreeRecovery();
                 },
             });
         });
@@ -111,7 +147,7 @@ function dispatchCliEntry() {
         // successful command into exit 13 when that teardown promise remains pending.
         // A floated rejection here no longer exits 0 silently: the boundary installed
         // above turns it into a non-zero exit (HQ-CLI-W).
-        void import("./main.js").then(({ runCli }) => runCli());
+        void runMainWithInstallTreeRecovery();
     }
 }
 function isNpmPackageEntry(entryUrl) {

package/dist/lib/core-utils/sentry-report.js

@@ -147,8 +147,11 @@ const SAFE_SLOW_PHASES = new Set([
     "child_wait",
     "probe",
     "parse",
+    "no_phase_recorded",
 ]);
-const DEBUG_CONTEXT_PHASES = new Set(SAFE_SLOW_PHASES);
+// This sentinel describes an absent active-phase record, not a phase a hook
+// measures in phase_timings.
+const DEBUG_CONTEXT_PHASES = new Set([...SAFE_SLOW_PHASES].filter((phase) => phase !== "no_phase_recorded"));
 /**
  * The only hook diagnostics that can be attached as metadata. The list omits
  * command text, prompts, payloads, company names, and repositories. `hook_path`
@@ -278,6 +281,10 @@ function safeSlowPhase(value) {
 }
 function resolvedSlowPhase(metadata) {
     const reported = safeSlowPhase(metadata.slow_phase);
+    // The hook explicitly recorded that no phase was active. Do not replace that
+    // finding with a different phase inferred from aggregate timing data.
+    if (reported === "no_phase_recorded")
+        return reported;
     if (reported !== "unknown" && reported !== "other")
         return reported;
     // Which measured master-hook phase consumed the most time when the caller's

package/dist/lib/db/control-plane.d.ts

@@ -130,4 +130,9 @@ export declare class ControlPlaneDbClient {
         appId: string;
     }): Promise<RemoteDestroyAppResponse>;
 }
+export type ControlPlaneHttpError = Error & {
+    status?: number;
+    code?: string;
+    reason?: string;
+};
 //# sourceMappingURL=control-plane.d.ts.map

package/dist/lib/db/control-plane.js

@@ -48,6 +48,8 @@ export class ControlPlaneDbClient {
             err.status = res.status;
             if (typeof payload?.code === "string")
                 err.code = payload.code;
+            if (typeof payload?.reason === "string")
+                err.reason = payload.reason;
             throw err;
         }
         return JSON.parse(text);
@@ -145,12 +147,15 @@ export class ControlPlaneDbClient {
 function httpError(label, status, text) {
     let msg = `${label} failed (${status})`;
     let code;
+    let reason;
     try {
         const j = JSON.parse(text);
         if (typeof j.error === "string")
             msg = j.error;
         if (typeof j.code === "string")
             code = j.code;
+        if (typeof j.reason === "string")
+            reason = j.reason;
     }
     catch {
         /* keep */
@@ -159,6 +164,8 @@ function httpError(label, status, text) {
     err.status = status;
     if (code)
         err.code = code;
+    if (reason)
+        err.reason = reason;
     return err;
 }
 //# sourceMappingURL=control-plane.js.map

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

@@ -1,5 +1,8 @@
 /** hq-flags keys used by lane command behavior. */
+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,8 @@
 /** hq-flags keys used by lane command behavior. */
+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/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/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`, {

package/dist/lib/lanes/store.js

@@ -442,6 +442,16 @@ export function parseLaneRecord(raw, filePath) {
             value: raw.hire_grant,
         });
     }
+    if (raw.released_hire_grant !== undefined &&
+        (typeof raw.released_hire_grant !== "number" ||
+            !Number.isSafeInteger(raw.released_hire_grant) ||
+            raw.released_hire_grant < 0)) {
+        throw new LaneSchemaError("Expected non-negative safe integer for released_hire_grant", {
+            path: filePath,
+            field: "released_hire_grant",
+            value: raw.released_hire_grant,
+        });
+    }
     if (raw.keep_alive !== undefined && typeof raw.keep_alive !== "boolean") {
         throw new LaneSchemaError("keep_alive must be a boolean", {
             path: filePath,
@@ -1603,6 +1613,31 @@ export function updateLane(hqRoot, laneId, expectedVersion, writer, updater, dep
                 throw new LanesError("lane_writer_unauthorized", `Writer ${writer} cannot write lane field ${key}`, { writer, field: key });
             }
         }
+        if (!isTerminalLaneState(current.state) && isTerminalLaneState(updated.state)) {
+            const releasedGrant = updated.hire_grant ?? current.hire_grant ?? 0;
+            return {
+                ...updated,
+                released_hire_grant: releasedGrant,
+                hire_grant: 0,
+            };
+        }
+        if (isTerminalLaneState(current.state) && !isTerminalLaneState(updated.state) &&
+            current.released_hire_grant !== undefined) {
+            return {
+                ...updated,
+                hire_grant: current.released_hire_grant,
+                released_hire_grant: undefined,
+            };
+        }
+        if (isTerminalLaneState(updated.state) &&
+            (updated.hire_grant !== current.hire_grant ||
+                updated.released_hire_grant !== current.released_hire_grant)) {
+            return {
+                ...updated,
+                hire_grant: 0,
+                released_hire_grant: updated.released_hire_grant ?? updated.hire_grant ?? 0,
+            };
+        }
         return updated;
     }, deps, {
         beforeWrite: (current) => assertLaneStoreWriteAllowed(current, laneId, writer),

package/dist/lib/lanes/tracker-report.d.ts

@@ -12,10 +12,20 @@ interface TrackerReportStory {
     id: string;
     title: string;
     status: ReportStoryStatus;
+    focus_id?: unknown;
+    kpi?: unknown;
+    owner?: string | null;
+    deadline?: string | null;
     references?: string[];
     updated_at?: string;
     source_path: string;
 }
+export interface TrackerReportFocusOverride {
+    reason: string;
+    by_lane: string;
+    at: string;
+    story: string;
+}
 export interface TrackerReportIssue {
     path: string;
     field: string;
@@ -47,6 +57,7 @@ export interface TrackerReportTeamInput {
     team: string;
     project_id: string;
     stories: readonly TrackerReportStory[];
+    focus_overrides?: readonly TrackerReportFocusOverride[];
     pull_requests: readonly TrackerReportPullRequest[];
     releases: readonly TrackerReportRelease[];
     blockers: readonly TrackerReportRecord[];
@@ -61,8 +72,42 @@ export interface TrackerReportInput {
     generated_at: string;
     since: string;
     since_source: "explicit" | "previous_report" | "first_run";
+    focus_dashboard_enabled?: boolean;
     teams: readonly TrackerReportTeamInput[];
 }
+interface TrackerFocusItem {
+    team: string;
+    project_id: string;
+    story_id: string;
+    title: string;
+    owner: string | null;
+    deadline: string | null;
+    state: ReportStoryStatus;
+    focus_id: unknown;
+    kpi: unknown;
+    override_reason: string | null;
+}
+interface TrackerTeamFocusShare {
+    team: string;
+    project_id: string;
+    window_start: string;
+    window_end: string;
+    work_story_count: number;
+    focused_story_count: number;
+    share_percent: number | null;
+    status: "red" | "ok" | "no_work";
+}
+interface TrackerFocusOverride extends TrackerReportFocusOverride {
+    team: string;
+    project_id: string;
+}
+interface TrackerFocusDashboard {
+    window_start: string;
+    window_end: string;
+    focus_list: TrackerFocusItem[];
+    team_focus_shares: TrackerTeamFocusShare[];
+    overrides: TrackerFocusOverride[];
+}
 interface ReportTimedStory {
     id: string;
     title: string;
@@ -140,6 +185,7 @@ export interface TrackerOwnerReport {
     generated_at: string;
     since: string;
     since_source: TrackerReportInput["since_source"];
+    focus_dashboard?: TrackerFocusDashboard;
     teams: TrackerOwnerTeamReport[];
 }
 interface TrackerTeamKpi {

package/dist/lib/lanes/tracker-report.js

@@ -231,6 +231,73 @@ function validatedWindow(input) {
     }
     return { generatedAt, since, sinceTime, generatedAtTime };
 }
+function hasFocus(story) {
+    const present = (value) => typeof value === "string"
+        ? value.trim().length > 0
+        : value !== undefined && value !== null;
+    return present(story.focus_id) || present(story.kpi);
+}
+function recentlyWorked(story, sinceTime, throughTime) {
+    if (story.updated_at === undefined)
+        return false;
+    const at = Date.parse(validTimestamp(story.updated_at, "updated_at", story.source_path, { story_id: story.id }));
+    return at >= sinceTime && at <= throughTime;
+}
+function buildFocusDashboard(teams, generatedAt, generatedAtTime) {
+    const windowStartTime = generatedAtTime - 24 * 60 * 60 * 1000;
+    const windowStart = new Date(windowStartTime).toISOString();
+    const focusList = [];
+    const teamFocusShares = [];
+    const overrides = [];
+    for (const team of teams) {
+        const teamOverrides = [...(team.focus_overrides ?? [])]
+            .filter((override) => Number.isFinite(Date.parse(override.at)) && Date.parse(override.at) <= generatedAtTime)
+            .sort((a, b) => a.at.localeCompare(b.at) || a.story.localeCompare(b.story));
+        overrides.push(...teamOverrides.map((override) => ({ ...override, team: team.team, project_id: team.project_id })));
+        const latestOverrideByStory = new Map();
+        for (const override of teamOverrides)
+            latestOverrideByStory.set(override.story, override.reason);
+        for (const story of team.stories) {
+            if (story.status === "dropped")
+                continue;
+            const activeOrRecentlyWorked = story.status === "in_progress" || recentlyWorked(story, windowStartTime, generatedAtTime);
+            const overrideReason = latestOverrideByStory.get(story.id) ?? null;
+            if (activeOrRecentlyWorked && (hasFocus(story) || overrideReason !== null)) {
+                focusList.push({
+                    team: team.team,
+                    project_id: team.project_id,
+                    story_id: story.id,
+                    title: story.title,
+                    owner: story.owner ?? null,
+                    deadline: story.deadline ?? null,
+                    state: story.status,
+                    focus_id: story.focus_id ?? null,
+                    kpi: story.kpi ?? null,
+                    override_reason: overrideReason,
+                });
+            }
+        }
+        const workStories = team.stories.filter((story) => story.status === "in_progress" || (story.status !== "dropped" && recentlyWorked(story, windowStartTime, generatedAtTime)));
+        const focusedStoryCount = workStories.filter(hasFocus).length;
+        const sharePercent = workStories.length === 0
+            ? null
+            : Math.round((focusedStoryCount / workStories.length) * 1000) / 10;
+        teamFocusShares.push({
+            team: team.team,
+            project_id: team.project_id,
+            window_start: windowStart,
+            window_end: generatedAt,
+            work_story_count: workStories.length,
+            focused_story_count: focusedStoryCount,
+            share_percent: sharePercent,
+            status: sharePercent === null ? "no_work" : focusedStoryCount / workStories.length < 0.8 ? "red" : "ok",
+        });
+    }
+    focusList.sort((a, b) => (a.deadline ?? "\uffff").localeCompare(b.deadline ?? "\uffff") || a.team.localeCompare(b.team) || a.story_id.localeCompare(b.story_id));
+    teamFocusShares.sort((a, b) => a.team.localeCompare(b.team));
+    overrides.sort((a, b) => a.at.localeCompare(b.at) || a.team.localeCompare(b.team) || a.story.localeCompare(b.story));
+    return { window_start: windowStart, window_end: generatedAt, focus_list: focusList, team_focus_shares: teamFocusShares, overrides };
+}
 function removeInvalidEntity(team, err) {
     if (!(err instanceof LanesError))
         return null;
@@ -316,7 +383,7 @@ export function buildTrackerOwnerReport(input) {
         }
         seen.add(team.team);
     }
-    return {
+    const report = {
         schema_version: "hq-lanes-owner-report.v1",
         company: input.company,
         generated_at: window.generatedAt,
@@ -326,6 +393,10 @@ export function buildTrackerOwnerReport(input) {
             .map((team) => withRecoverableTeamErrors(team, (safeTeam) => teamOwnerReport(safeTeam, input.company, window.sinceTime, window.generatedAtTime)))
             .sort((a, b) => a.team.localeCompare(b.team)),
     };
+    if (input.focus_dashboard_enabled === true) {
+        report.focus_dashboard = buildFocusDashboard(eligibleTeams, window.generatedAt, window.generatedAtTime);
+    }
+    return report;
 }
 function teamKpis(team, company, throughTime) {
     return team.kpis
@@ -460,6 +531,19 @@ export function renderTrackerOwnerReportText(report) {
         `Owner report for ${report.company}`,
         `Reporting window: ${report.since} through ${report.generated_at} (${report.since_source.replaceAll("_", " ")})`,
     ];
+    if (report.focus_dashboard) {
+        lines.push("", `Focus dashboard (last 24h: ${report.focus_dashboard.window_start} through ${report.focus_dashboard.window_end})`, "Focus list:");
+        lines.push(...listOrNone(report.focus_dashboard.focus_list, (item) => `${item.team}/${item.story_id} — ${item.title}; owner: ${item.owner ?? "unknown"}; deadline: ${item.deadline ?? "none"}; state: ${item.state}${item.override_reason ? `; override: ${item.override_reason}` : ""}`));
+        lines.push("Team focus share:");
+        lines.push(...listOrNone(report.focus_dashboard.team_focus_shares, (share) => {
+            if (share.share_percent === null)
+                return `${share.team}: no in-progress or worked stories`;
+            const color = share.status === "red" ? "RED under 80%" : "OK";
+            return `${share.team}: ${share.share_percent}% (${share.focused_story_count}/${share.work_story_count}); ${color}`;
+        }));
+        lines.push("Focus guard overrides:");
+        lines.push(...listOrNone(report.focus_dashboard.overrides, (override) => `${override.team}/${override.story} by ${override.by_lane} (${override.at}): ${override.reason}`));
+    }
     for (const team of report.teams) {
         lines.push("", `${team.team} (${team.project_id})`, "Progress:", "  Stories moved to done:");
         lines.push(...listOrNone(team.progress.stories_moved_to_done, (story) => `${story.id} — ${story.title} (${story.at})${story.references.length ? `; references: ${story.references.join(", ")}` : ""}`));

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

@@ -584,6 +584,8 @@ export interface LaneRecord {
     keep_alive_exhausted_at?: string;
     /** Maximum number of direct child lanes this lane may keep alive; old records default to 0. */
     hire_grant?: number;
+    /** Hire grant returned to the senior while this terminal lane is inactive. */
+    released_hire_grant?: number;
     /** Content hash of the profile last applied to this lane. */
     worker_profile_hash?: string;
     /** Registry persona selected by the profile, pinned at lane creation. */

package/dist/lib/lanes/types.js

@@ -228,6 +228,7 @@ export const LANE_FIELD_WRITERS = {
     project_id: ["command"], story_id: ["command"], no_story_reason: ["creator", "command"], ledger_sync_error: ["story-ledger"], pending_question_ids: ["story-ledger"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator", "command"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     hire_grant: ["creator", "command"],
+    released_hire_grant: ["command"],
     state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "watcher", "reconcile"], queued_details: ["command", "reconcile", "spawn", "watcher"], queued_at: ["creator", "command", "spawn", "watcher", "reconcile"], admission_reserved_at: ["creator", "command", "reconcile", "spawn", "watcher"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],

package/dist/main.js

@@ -43,7 +43,7 @@ import { isCompanySelectionError } from "./utils/company-selection-error.js";
 import { canOfferTeamUpgrade, formatPlanGateError, offerTeamUpgrade, offerUpgradeLink, planGateErrorFromVaultError, } from "./utils/plan-gate-error.js";
 import { upgradeToTeam } from "./utils/team-upgrade.js";
 import { printCachedVersionNudge, printVersionAndNudge, refreshVersionCache, staleAgainstCachedLatest, } from "./utils/version-check.js";
-import { enforceVersionGate, isLocalDependencyInstall, resolveRunningInstall, shouldSkipGate, } from "./utils/version-gate.js";
+import { enforceVersionGate, getVersionGatePhase, isLocalDependencyInstall, resolveRunningInstall, shouldSkipGate, } from "./utils/version-gate.js";
 import { autoUpdateAndReexec } from "./utils/self-update.js";
 import { CLI_VERSION } from "./cli-version.js";
 import { findLazyCommand, registerCommandCatalog } from "./lazy-commands.js";
@@ -262,6 +262,10 @@ export async function runCli() {
             env: process.env,
             entryPath: RUNNING_ENTRY_PATH,
             stderr: process.stderr,
+            deps: {
+                resolveInstall: resolveRunningInstall,
+                versionGatePhase: getVersionGatePhase,
+            },
         });
         if (registration.reexecStatus !== undefined) {
             // The re-exec'd child ran the command on the settled tree; carry its exit

package/dist/startup-registration.d.ts

@@ -16,6 +16,7 @@
  * style of handleTopLevelError so the whole seam is unit-testable without real
  * spawns, waits, or a real install tree.
  */
+import type { VersionGatePhase } from "./utils/version-gate.js";
 import { type InstallRewriteSignalArgs, type WaitForInstallTreeSettledArgs, type WaitForInstallTreeSettledResult } from "./utils/install-tree-torn.js";
 /**
  * Set on the re-exec'd child so it can NEVER wait or re-exec again — distinct
@@ -74,6 +75,8 @@ export interface RegisterRecoveryDeps {
     waitForSettled?: (args: WaitForInstallTreeSettledArgs) => Promise<WaitForInstallTreeSettledResult>;
     /** Positive writer-signal probe for the eval-throw gate (defaults to installRewriteInProgress). */
     rewriteInProgress?: (args: InstallRewriteSignalArgs) => boolean;
+    /** Current version-gate phase for diagnostics; defaults to unknown for early entry recovery. */
+    versionGatePhase?: () => VersionGatePhase;
     /** node flags to forward to the re-exec child (defaults to process.execArgv). */
     execArgv?: readonly string[];
 }

package/dist/startup-registration.js

@@ -17,7 +17,6 @@
  * spawns, waits, or a real install tree.
  */
 import { spawnSync } from "node:child_process";
-import { getVersionGatePhase, resolveRunningInstall } from "./utils/version-gate.js";
 import { stringDerivedPackageRoot } from "./utils/hq-roots.js";
 import { updateLockPath, UPDATE_LOCK_STALE_MS } from "./utils/update-lock.js";
 import { classifyEvalThrow, classifyModuleNotFound, installRewriteInProgress, InstallTreeTornError, waitForInstallTreeSettled, } from "./utils/install-tree-torn.js";
@@ -122,7 +121,7 @@ export async function registerCommandsWithRecovery(args) {
                 cause: err,
                 classified,
                 packageRoot,
-                versionGatePhase: getVersionGatePhase(),
+                versionGatePhase: readVersionGatePhase(deps),
                 outcome: "guarded",
                 treeState: env[INSTALL_TREE_RECOVERY_TREE_STATE_ENV] === "stale" ? "stale" : "in_flight",
                 attempt: 2,
@@ -193,7 +192,7 @@ export async function registerCommandsWithRecovery(args) {
                 cause: err,
                 classified,
                 packageRoot,
-                versionGatePhase: getVersionGatePhase(),
+                versionGatePhase: readVersionGatePhase(deps),
                 outcome: "reexec-failed",
                 treeState,
                 attempt: 1,
@@ -225,11 +224,19 @@ export async function registerCommandsWithRecovery(args) {
 function resolvePackageRoot(deps) {
     let root;
     try {
-        root = (deps.resolveInstall ?? resolveRunningInstall)().packageRoot;
+        root = deps.resolveInstall?.().packageRoot ?? null;
     }
     catch {
         root = null;
     }
     return root ?? (deps.deriveInstallRoot ?? stringDerivedPackageRoot)();
 }
+function readVersionGatePhase(deps) {
+    try {
+        return deps.versionGatePhase?.() ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
 //# sourceMappingURL=startup-registration.js.map

package/package.json

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