@indigoai-us/hq-cli 5.185.0 → 5.186.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [5.186.0] — 2026-09-25
+
+### Changed
+
+- A local bot's scheduled jobs now live with the bot. `hq bot jobs` stores them in the bot's folder (`jobs.json`) and the running bot fires them itself, through the same path as a cloud-fired job. No cloud setting is involved. A run missed while the computer slept or the bot was stopped runs once as a catch-up; a job never overlaps itself. The 25-job cap per bot is unchanged.
+
+## [5.185.1] — 2026-09-25
+
+### Fixed
+
+- `lanes.hire-grants` resolves its company-scoped hq-flags value before gating.
+  A valid local override wins; missing rows or failed reads leave enforcement
+  off. Backfills check the unscoped value and each target company's value
+  before writing. `hire_grant_exhausted` names the grantor and includes the
+  same recovery message in JSON and on stderr.
+
 ## [5.185.0] — 2026-09-25
 
 ### Fixed

package/dist/commands/bot-jobs.js

@@ -18,9 +18,9 @@ import chalk from "chalk";
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { BotApi, BotApiError } from "../lib/bot/api.js";
+import { localJobsClient } from "../lib/bot/local-jobs.js";
+import { BotApiError } from "../lib/bot/api.js";
 import { effectiveBotKind } from "../lib/bot/config.js";
-import { identityMismatchMessage, tokenAgentUid } from "../lib/heartbeat-identity.js";
 // ─── Schedule translation ────────────────────────────────────────────────────
 /** Mirrors hq-pro-agents `MIN_RECURRING_INTERVAL_SECONDS`. */
 export const MIN_RECURRING_INTERVAL_SECONDS = 5 * 60;
@@ -365,16 +365,13 @@ export async function runBotJobs(nameArg, opts, deps) {
     const kind = effectiveBotKind(config);
     const out = deps.out ?? ((line) => console.log(line));
     const ctx = { botName: name, kind };
+    // The schedule lives with the bot: this bot runs on this computer, so its
+    // jobs live in its folder and it fires them itself.
     let client;
     const jobsApi = async () => {
         if (client)
             return client;
-        const token = await deps.botTokenSupplier(dir)();
-        const tokenUid = tokenAgentUid(token);
-        if (tokenUid && tokenUid !== config.agentUid) {
-            refuse(identityMismatchMessage("bot jobs", config.agentUid, tokenUid));
-        }
-        client = deps.apiFor ? deps.apiFor(dir) : new BotApi({ token: async () => token });
+        client = deps.apiFor ? deps.apiFor(dir) : localJobsClient(dir);
         return client;
     };
     if (opts.add !== undefined && opts.rm !== undefined) {
@@ -420,9 +417,8 @@ export async function runBotJobs(nameArg, opts, deps) {
         }
         const words = ("human" in schedule && schedule.human) || describeSchedule(created);
         out(chalk.green(`Scheduled ${created.jobId}: ${name} will ${body.prompt.replace(/\s+/g, " ").slice(0, 120)} — ${words}.`));
-        out(chalk.gray("If this computer is asleep or off when a run is due, it is picked up as a catch-up when the computer " +
-            "wakes, as long as it wakes within about an hour. After a longer outage that run is skipped and the " +
-            "job carries on at its next scheduled time."));
+        out(chalk.gray(`It runs on this computer while ${name} is running. If a run is due while the computer is asleep or ` +
+            `${name} is stopped, it runs once, as a catch-up, the next time ${name} is running.`));
         return;
     }
     let jobs;

package/dist/commands/bot.js

@@ -1,3 +1,4 @@
+import { withLocalJobs } from "../lib/bot/local-jobs.js";
 import { OwnerContextCache, lookupOwnerContext } from "../lib/bot/owner-context.js";
 import { hasActivePromotion } from "../lib/bot/promotion-receipt.js";
 import { readInflightTurns } from "../lib/bot/inflight.js";
@@ -866,7 +867,8 @@ async function runBotResident(nameArg) {
     if (healNodePathFromJob(name, dir, config))
         return;
     const token = botTokenSupplier(dir);
-    const api = new BotApi({ token });
+    // The bot's own schedule lives in its folder and fires from this loop.
+    const api = withLocalJobs(new BotApi({ token }), dir);
     const owner = new OwnerContextCache(() => lookupOwnerContext(config.ownerUid), Date.now, undefined, config.ownerUid);
     const handle = await runBot({
         dir,

package/dist/commands/lanes.d.ts

@@ -79,7 +79,7 @@ export interface LanesCommandDeps {
     /** Test seam for the default-off outpost placement rollout flag. */
     lanePlacementEnabled?: () => boolean;
     /** Test seam for the default-off lane hire-grants rollout gate. */
-    laneHireGrantsEnabled?: () => boolean;
+    laneHireGrantsEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
 }
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 export declare function parseSeniorRef(raw: string): SeniorRef;

package/dist/commands/lanes.js

@@ -13,6 +13,7 @@ import * as path from "node:path";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveProcessFlagGate } from "../lib/flag-registry.js";
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
@@ -52,8 +53,8 @@ export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 function defaultLanePlacementEnabled() {
     return resolveProcessFlagGate(LANE_OUTPOST_LOAD_BALANCING_FLAG, { fallback: false }, () => false);
 }
-function defaultLaneHireGrantsEnabled() {
-    return resolveProcessFlagGate(LANE_HIRE_GRANTS_FLAG, { fallback: false }, () => false);
+function defaultLaneHireGrantsEnabled(company) {
+    return readLanesRegistryFlag(LANE_HIRE_GRANTS_FLAG, { company });
 }
 function withoutProviderHome(value) {
     if (Array.isArray(value))
@@ -73,6 +74,9 @@ function printJson(value) {
 }
 function failJson(err) {
     if (isLanesError(err)) {
+        if (err.error === "hire_grant_exhausted") {
+            process.stderr.write(`hq lanes: ${err.message}\n`);
+        }
         printJson(err.toJSON());
         process.exit(1);
     }
@@ -515,12 +519,14 @@ const OUTPOST_HIRE_SUMMARY_WAIT_MS = 15_000;
 const OUTPOST_HIRE_SUMMARY_CONCURRENCY = 4;
 async function laneHirePresentation(ctx, lane, lanes) {
     const local = laneHireFields(lane, lanes);
-    if (!ctx.laneHireGrantsEnabled() ||
-        lane.host.kind !== "outpost" ||
+    if (lane.host.kind !== "outpost" ||
         isTerminalLaneState(lane.state) ||
         laneRunsHere(lane, reconcileHostFromCtx(ctx))) {
         return { ...local, hire_source: "local" };
     }
+    if (!await ctx.laneHireGrantsEnabled(lane.company)) {
+        return { ...local, hire_source: "local" };
+    }
     try {
         return { ...(await ownerLaneHireFields(ctx, lane)), hire_source: "owner" };
     }
@@ -548,14 +554,15 @@ async function mapWithConcurrency(values, concurrency, map) {
     await Promise.all(workers);
     return results;
 }
-function withResumeHireAdmission(ctx, lane, fn) {
+async function withResumeHireAdmission(ctx, lane, fn) {
     const hqRoot = ctx.hqRoot();
-    if (!ctx.laneHireGrantsEnabled() ||
-        !isTerminalLaneState(lane.state) ||
+    if (!isTerminalLaneState(lane.state) ||
         lane.senior.kind !== "lane" ||
         !lane.senior.id) {
         return fn();
     }
+    if (!await ctx.laneHireGrantsEnabled(lane.company))
+        return fn();
     return withHireGrantAdmission(hqRoot, lane.senior.id, ({ parent, children, parentGrant, availableChildGrant }) => {
         const current = readLane(hqRoot, lane.lane_id);
         // A different resume already reactivated this lane; it occupies the slot
@@ -588,11 +595,33 @@ function withResumeHireAdmission(ctx, lane, fn) {
 }
 function hireGrantCapacityError(parent, children) {
     const grant = parent.hire_grant ?? 0;
-    return new LanesError("hire_grant_exhausted", `Senior lane ${parent.lane_id} has hire grant ${grant} and ${children.length} alive direct children (${children.map((child) => child.lane_id).join(", ") || "none"}). 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>.`, {
+    const grantor = (parent.senior.kind === "lane" || parent.senior.kind === "session") &&
+        parent.senior.id
+        ? { kind: parent.senior.kind, id: parent.senior.id }
+        : null;
+    const grantorReason = grantor
+        ? undefined
+        : parent.senior.kind === "user"
+            ? "senior_is_user"
+            : "parent_senior_missing_id";
+    const capacity = children.length === grant
+        ? `is at its hire grant (${children.length} of ${grant} alive children)`
+        : `has exhausted its hire grant (${children.length} alive children; grant ${grant})`;
+    const grantCommand = `hq lanes grant ${parent.lane_id} --hire <n>`;
+    const authorityGuidance = grantor
+        ? `Its senior ${grantor.kind} ${grantor.id} can raise it with: ${grantCommand}`
+        : parent.senior.kind === "user"
+            ? `Its senior is the user and can raise it with: ${grantCommand}`
+            : `No senior is recorded, so an operator must resolve ownership before running: ${grantCommand}`;
+    const message = `Lane ${parent.lane_id} ${capacity}. ${authorityGuidance}`;
+    return new LanesError("hire_grant_exhausted", message, {
         senior_lane_id: parent.lane_id,
         parent_grant: grant,
         alive_children: children.map((child) => child.lane_id),
         alive_child_count: children.length,
+        grantor,
+        ...(grantorReason ? { grantor_reason: grantorReason } : {}),
+        message,
         ask_guidance: {
             envelope: "decision=ask; include the desired total grant and the reason",
             senior_command: `hq lanes grant ${parent.lane_id} --hire <n>`,
@@ -1858,7 +1887,12 @@ async function runCreate(ctx, opts) {
     }
     const senior = opts.senior ? parseSeniorRef(opts.senior) : defaultSenior(ctx);
     assertSeniorExists(hqRoot, senior, ctx);
-    const hireGrantsEnabled = ctx.laneHireGrantsEnabled();
+    // Resolve tenant context before the registry read so the flag evaluator
+    // applies the same company scope as this lane.
+    const company = companyFlag
+        ? await ctx.resolveCompany(companyFlag)
+        : null;
+    const hireGrantsEnabled = await ctx.laneHireGrantsEnabled(company);
     if (requestedHireGrant !== undefined &&
         !callerMatchesSenior(ctx, senior)) {
         throw new LanesError("hire_grant_unauthorized", `Only senior ${seniorKey(senior)} may set a lane's hire grant`, { senior, hire_grant: requestedHireGrant });
@@ -1874,9 +1908,6 @@ async function runCreate(ctx, opts) {
         throw new LanesError("max_lane_depth", `Lane depth ${laneDepth} exceeds cap ${MAX_LANE_DEPTH}`, { depth: laneDepth, max: MAX_LANE_DEPTH });
     }
     // A no-company lane must not call company resolution (openMeshTransport).
-    const company = companyFlag
-        ? await ctx.resolveCompany(companyFlag)
-        : null;
     let meshCompany = company;
     if (meshCompanyFlag) {
         const resolvedMeshCompany = await ctx.resolveCompany(meshCompanyFlag);
@@ -3024,6 +3055,17 @@ async function runList(ctx, opts) {
         return true;
     })
         .sort(compareLaneQueueOrder);
+    const companyContexts = new Map();
+    for (const lane of selectedLanes) {
+        if (lane.host.kind !== "outpost" ||
+            isTerminalLaneState(lane.state) ||
+            laneRunsHere(lane, host)) {
+            continue;
+        }
+        const company = lane.company;
+        companyContexts.set(JSON.stringify([company?.uid ?? null, company?.slug ?? null]), company);
+    }
+    await Promise.all([...companyContexts.values()].map((company) => ctx.laneHireGrantsEnabled(company)));
     const hireByLane = new Map(await mapWithConcurrency(selectedLanes, OUTPOST_HIRE_SUMMARY_CONCURRENCY, async (lane) => [
         lane.lane_id,
         await laneHirePresentation(ctx, lane, allLanes),
@@ -3545,6 +3587,7 @@ async function runGrant(ctx, laneId, opts) {
         await dispatchOutpostLaneCommand(ctx, initial, "grant", { hire: String(hireGrant) });
         return;
     }
+    const enforce = await ctx.laneHireGrantsEnabled(initial.company);
     const lockedLaneIds = [
         laneId,
         ...(initial.senior.kind === "lane" && initial.senior.id
@@ -3557,7 +3600,6 @@ async function runGrant(ctx, laneId, opts) {
             throw new LanesError("hire_grant_unauthorized", `Only senior ${seniorKey(current.senior)} may change lane ${laneId}'s hire grant`, { lane_id: laneId, senior: current.senior });
         }
         const hierarchy = loadAllLanes(hqRoot);
-        const enforce = ctx.laneHireGrantsEnabled();
         if (enforce && current.senior.kind === "lane") {
             if (!current.senior.id) {
                 throw new LanesError("hire_grant_senior_invalid", `Lane ${laneId} has a lane senior without an id`, {
@@ -3611,7 +3653,7 @@ async function runBackfillGrants(ctx, opts) {
     }
     const apply = Boolean(opts.apply);
     const hqRoot = ctx.hqRoot();
-    if (apply && ctx.laneHireGrantsEnabled()) {
+    if (apply && await ctx.laneHireGrantsEnabled(null)) {
         throw new LanesError("hire_grant_backfill_gate_enabled", "Backfill must be applied and verified before lanes.hire-grants is enabled", { flag: LANE_HIRE_GRANTS_FLAG });
     }
     if (apply && ctx.env.HQ_LANE_ID?.trim()) {
@@ -3642,6 +3684,24 @@ async function runBackfillGrants(ctx, opts) {
     }
     let rows = planHireGrantBackfill(allLanes, profileMaxConcurrent);
     if (apply) {
+        const lanesById = new Map(allLanes.map((lane) => [lane.lane_id, lane]));
+        const targetCompanies = new Map();
+        for (const row of rows) {
+            if (row.action === "unchanged")
+                continue;
+            const lane = lanesById.get(row.lane_id);
+            if (!lane) {
+                throw new LanesError("hire_grant_backfill_target_changed", `Backfill target lane ${row.lane_id} is unavailable`, { lane_id: row.lane_id });
+            }
+            const company = lane.company;
+            if (!company)
+                continue;
+            targetCompanies.set(JSON.stringify([company.uid ?? null, company.slug ?? null]), company);
+        }
+        const companyGates = await Promise.all([...targetCompanies.values()].map((company) => ctx.laneHireGrantsEnabled(company)));
+        if (companyGates.some(Boolean)) {
+            throw new LanesError("hire_grant_backfill_gate_enabled", "Backfill must be applied and verified before lanes.hire-grants is enabled", { flag: LANE_HIRE_GRANTS_FLAG });
+        }
         const shortfalls = rows.filter((row) => row.grant_shortfall > 0);
         if (shortfalls.length > 0) {
             throw new LanesError("hire_grant_backfill_allocation_shortfall", "Existing parent grants do not cover the grants allocated to alive children; resolve these rows before applying the backfill", { lanes: shortfalls });
@@ -4009,7 +4069,7 @@ async function prepareAccountMove(ctx, lane, input) {
         if (admission.action === "refuse" && admission.error)
             throw admission.error;
         const queued = admission.action === "queue";
-        const moved = withResumeHireAdmission(ctx, lane, () => casUpdateLane(hqRoot, laneId, (current) => {
+        const moved = await withResumeHireAdmission(ctx, lane, () => casUpdateLane(hqRoot, laneId, (current) => {
             // The copy and every check above were made from `lane`; a record
             // that moved on since (another move, a spawn, a cancel) invalidates
             // them, so the write is refused rather than applied to a state it
@@ -4061,7 +4121,7 @@ async function runMessage(ctx, laneId, opts) {
     assertLaneRunsHereForOperatorMutation(ctx, lane, "message");
     // Check before transcript recovery, account probing, or message writes.
     // The final state transition repeats this check under the senior lock.
-    withResumeHireAdmission(ctx, lane, () => undefined);
+    await withResumeHireAdmission(ctx, lane, () => undefined);
     lane = laneWithRecoveredProviderSession(hqRoot, lane);
     // An account move is refused on its own terms first: a running lane and a
     // provider without session resume get the move's named errors, not the
@@ -4341,7 +4401,7 @@ async function runResume(ctx, laneId, opts) {
     }
     // Fail before provider/session work if a terminal child would consume a
     // slot that its senior has already assigned elsewhere.
-    withResumeHireAdmission(ctx, lane, () => undefined);
+    await withResumeHireAdmission(ctx, lane, () => undefined);
     assertLaneRunsHereForOperatorMutation(ctx, lane, "resume");
     lane = laneWithRecoveredProviderSession(hqRoot, lane);
     if (opts.model !== undefined && opts.account === undefined) {
@@ -4913,14 +4973,19 @@ async function runReparent(ctx, laneId, opts) {
     const nextSenior = parseSeniorRef(opts.senior);
     assertSeniorExists(hqRoot, nextSenior, ctx);
     const initial = readLane(hqRoot, laneId);
+    const needsHireGrantGate = nextSenior.kind === "lane" &&
+        seniorKey(initial.senior) !== seniorKey(nextSenior);
+    const hireGrantsEnabled = needsHireGrantGate
+        ? await ctx.laneHireGrantsEnabled(initial.company)
+        : false;
     const lockIds = [
         laneId,
         ...(initial.senior.kind === "lane" && initial.senior.id ? [initial.senior.id] : []),
         ...(nextSenior.kind === "lane" && nextSenior.id ? [nextSenior.id] : []),
     ];
-    withLaneHireLocks(hqRoot, lockIds, () => runReparentLocked(ctx, laneId, opts));
+    withLaneHireLocks(hqRoot, lockIds, () => runReparentLocked(ctx, laneId, opts, hireGrantsEnabled));
 }
-function runReparentLocked(ctx, laneId, opts) {
+function runReparentLocked(ctx, laneId, opts, hireGrantsEnabled) {
     const hqRoot = ctx.hqRoot();
     if (!opts.senior) {
         throw new LanesError("missing_senior", "--senior is required", {});
@@ -4934,7 +4999,7 @@ function runReparentLocked(ctx, laneId, opts) {
     }
     const seniorCompany = companyOfSenior(hqRoot, nextSenior, ctx);
     assertSameTenant(lane.company, nextSenior, seniorCompany, { lane_id: laneId });
-    if (ctx.laneHireGrantsEnabled() &&
+    if (hireGrantsEnabled &&
         nextSenior.kind === "lane" &&
         seniorKey(lane.senior) !== seniorKey(nextSenior)) {
         const parent = readLane(hqRoot, nextSenior.id);

package/dist/lib/bot/local-jobs.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Scheduled jobs for a bot that runs on this computer.
+ *
+ * The schedule lives with the bot. A local bot keeps its jobs in `jobs.json`
+ * in its own folder and fires them itself, from the same loop that checks its
+ * inbox. A due job becomes an ordinary `channel: "job"` inbox item, so it runs
+ * through exactly the path a cloud-fired job does (own session, "scheduled
+ * job" header in the owner's DM, catch-up label when late). Only the three
+ * calls that talk to the cloud about a run are answered here instead:
+ * pulling due runs, acking them, and recording how they finished.
+ *
+ * Rules:
+ * - Jobs fire only while the bot is running. After a sleep or an outage, a job
+ *   runs ONCE for its newest missed time, labelled a catch-up; older missed
+ *   times are not replayed.
+ * - A job never overlaps itself. A new fire waits until the previous run of
+ *   the same job has finished (or has been silent for an hour).
+ * - A fire is recorded before it is handed over, so a crash never runs the
+ *   same due time twice.
+ */
+import { type BotApi, type BotJobRecord, type InboxItem, type JobRunCompletion } from "./api.js";
+export declare const LOCAL_JOBS_FILE = "jobs.json";
+export declare const LOCAL_JOB_MESSAGE_PREFIX = "localjob-";
+export interface LocalJob {
+    jobId: string;
+    prompt: string;
+    /** Standard 5-field cron, evaluated in `timezone`. */
+    cron: string;
+    timezone: string;
+    context?: Record<string, unknown>;
+    createdAt: string;
+    /** The newest due time already handed to the bot. */
+    lastFiredAt?: string;
+    /** The run in progress, if any. */
+    inFlight?: {
+        messageId: string;
+        since: string;
+    };
+    lastRunAt?: string;
+    lastStatus?: string;
+    runCount?: number;
+}
+export declare function localJobsPath(dir: string): string;
+export declare function readLocalJobs(dir: string): LocalJob[];
+export declare function writeLocalJobs(dir: string, jobs: LocalJob[]): void;
+/**
+ * Run a read-change-write of `jobs.json` under an exclusive lock. The running
+ * bot (firing, finishing) and `hq bot jobs` (add, remove) are separate
+ * processes; without the lock one can write back a stale copy and silently
+ * undo the other's change.
+ */
+export declare function withJobsLock<T>(dir: string, fn: () => T): T;
+export interface CronMatcher {
+    minutes: Set<number>;
+    hours: Set<number>;
+    days: Set<number>;
+    months: Set<number>;
+    weekdays: Set<number>;
+    dayRestricted: boolean;
+    weekdayRestricted: boolean;
+}
+/**
+ * The job's schedule as a standard 5-field cron. Jobs are stored in the same
+ * form the cloud uses (`cron(m h dom mon dow year)`, Sunday = 1, `?` for the
+ * unused day field), so the same `hq bot jobs` input works for either home.
+ */
+export declare function toStandardCron(expr: string): string | null;
+/** Parse a standard 5-field cron, or null when it is not one. */
+export declare function parseCron(expr: string): CronMatcher | null;
+export declare function cronMatches(cron: CronMatcher, date: Date, timeZone: string): boolean;
+/**
+ * The newest time this job was due, at or before `now` and after the last one
+ * already fired. Null when nothing new is due.
+ */
+/** `rate(5 minutes)` / `rate(1 hour)` / `rate(2 days)` as milliseconds. */
+export declare function rateIntervalMs(expr: string): number | null;
+export declare function isRunnableSchedule(expr: string): boolean;
+export declare function latestDueFire(job: LocalJob, now: Date): Date | null;
+/** The next time this job is due after `now`, within a week; null otherwise. */
+export declare function nextDueFire(job: LocalJob, now: Date): Date | null;
+export declare function toJobRecord(job: LocalJob, now?: Date): BotJobRecord;
+export declare function addLocalJob(dir: string, input: {
+    prompt: string;
+    cron: string;
+    timezone: string;
+    context?: Record<string, unknown>;
+}, now?: Date): LocalJob;
+/** Remove a job. Returns false when the bot has no job with that id. */
+export declare function removeLocalJob(dir: string, jobId: string): boolean;
+/** Forget the once-per-minute check (tests, and a bot restarted in-process). */
+export declare function resetLocalJobChecks(): void;
+export declare function takeDueLocalJobRuns(dir: string, now?: Date): InboxItem[];
+export declare function isLocalJobMessage(messageId: string): boolean;
+/** Record how a local run finished and release the job for its next fire. */
+export declare function finishLocalJobRun(dir: string, jobId: string, messageId: string, completion: Pick<JobRunCompletion, "status">, now?: Date): void;
+/**
+ * The bot's cloud client, with its scheduled runs answered on this computer:
+ * due local jobs join the inbox, and their ack and completion are recorded
+ * locally instead of being sent to the cloud.
+ */
+export declare function withLocalJobs(api: BotApi, dir: string, clock?: () => Date): BotApi;
+/** The most jobs one bot may hold (the same cap the cloud uses). */
+export declare const MAX_LOCAL_JOBS = 25;
+/**
+ * `hq bot jobs` against the bot's own folder: the same three calls the cloud
+ * client offers, answered from `jobs.json`.
+ */
+export declare function localJobsClient(dir: string, clock?: () => Date): Pick<BotApi, "listJobs" | "createJob" | "cancelJob">;
+//# sourceMappingURL=local-jobs.d.ts.map

package/dist/lib/bot/local-jobs.js

@@ -0,0 +1,459 @@
+/**
+ * Scheduled jobs for a bot that runs on this computer.
+ *
+ * The schedule lives with the bot. A local bot keeps its jobs in `jobs.json`
+ * in its own folder and fires them itself, from the same loop that checks its
+ * inbox. A due job becomes an ordinary `channel: "job"` inbox item, so it runs
+ * through exactly the path a cloud-fired job does (own session, "scheduled
+ * job" header in the owner's DM, catch-up label when late). Only the three
+ * calls that talk to the cloud about a run are answered here instead:
+ * pulling due runs, acking them, and recording how they finished.
+ *
+ * Rules:
+ * - Jobs fire only while the bot is running. After a sleep or an outage, a job
+ *   runs ONCE for its newest missed time, labelled a catch-up; older missed
+ *   times are not replayed.
+ * - A job never overlaps itself. A new fire waits until the previous run of
+ *   the same job has finished (or has been silent for an hour).
+ * - A fire is recorded before it is handed over, so a crash never runs the
+ *   same due time twice.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { BotApiError } from "./api.js";
+export const LOCAL_JOBS_FILE = "jobs.json";
+export const LOCAL_JOB_MESSAGE_PREFIX = "localjob-";
+/** How far back a missed fire is still looked for (one week). */
+const LOOKBACK_MINUTES = 7 * 24 * 60;
+/** A run that never reported back releases its job after this long. */
+const IN_FLIGHT_RELEASE_MS = 60 * 60 * 1000;
+/** A fire is "late" (a catch-up) once this long past its due time. */
+const STALE_AFTER_MS = 10 * 60 * 1000;
+export function localJobsPath(dir) {
+    return path.join(dir, LOCAL_JOBS_FILE);
+}
+export function readLocalJobs(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(localJobsPath(dir), "utf8"));
+        return Array.isArray(parsed.jobs) ? parsed.jobs.filter((job) => !!job && typeof job.jobId === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function writeLocalJobs(dir, jobs) {
+    const file = localJobsPath(dir);
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ v: 1, jobs }, null, 2));
+    fs.renameSync(tmp, file);
+}
+// ─── Lock ────────────────────────────────────────────────────────────────────
+/** A lock older than this belongs to a process that died holding it. */
+const LOCK_STALE_MS = 30_000;
+const LOCK_WAIT_MS = 5_000;
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/**
+ * Run a read-change-write of `jobs.json` under an exclusive lock. The running
+ * bot (firing, finishing) and `hq bot jobs` (add, remove) are separate
+ * processes; without the lock one can write back a stale copy and silently
+ * undo the other's change.
+ */
+export function withJobsLock(dir, fn) {
+    const lock = `${localJobsPath(dir)}.lock`;
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    for (;;) {
+        try {
+            fs.writeFileSync(lock, String(process.pid), { flag: "wx" });
+            break;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            try {
+                if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) {
+                    fs.rmSync(lock, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new Error(`The bot's job list is busy (${lock}). Try again in a moment.`);
+            sleepSync(25);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        fs.rmSync(lock, { force: true });
+    }
+}
+// ─── Cron ────────────────────────────────────────────────────────────────────
+const FIELD_RANGES = [
+    [0, 59], // minute
+    [0, 23], // hour
+    [1, 31], // day of month
+    [1, 12], // month
+    [0, 7], // day of week (0 and 7 are Sunday)
+];
+function parseField(field, [min, max]) {
+    const out = new Set();
+    for (const part of field.split(",")) {
+        const [rangePart, stepPart] = part.split("/");
+        const step = stepPart === undefined ? 1 : Number(stepPart);
+        if (!Number.isInteger(step) || step < 1)
+            return null;
+        let lo;
+        let hi;
+        if (rangePart === "*") {
+            lo = min;
+            hi = max;
+        }
+        else if (/^\d+-\d+$/.test(rangePart ?? "")) {
+            [lo, hi] = rangePart.split("-").map(Number);
+        }
+        else if (/^\d+$/.test(rangePart ?? "")) {
+            lo = Number(rangePart);
+            hi = stepPart === undefined ? lo : max;
+        }
+        else {
+            return null;
+        }
+        if (lo < min || hi > max || lo > hi)
+            return null;
+        for (let v = lo; v <= hi; v += step)
+            out.add(v);
+    }
+    return out;
+}
+const DAY_NAMES = { SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6 };
+const MONTH_NAMES = {
+    JAN: 1, FEB: 2, MAR: 3, APR: 4, MAY: 5, JUN: 6, JUL: 7, AUG: 8, SEP: 9, OCT: 10, NOV: 11, DEC: 12,
+};
+function replaceNames(field, names) {
+    return field.replace(/[A-Za-z]{3}/g, (name) => {
+        const value = names[name.toUpperCase()];
+        return value === undefined ? name : String(value);
+    });
+}
+/**
+ * The job's schedule as a standard 5-field cron. Jobs are stored in the same
+ * form the cloud uses (`cron(m h dom mon dow year)`, Sunday = 1, `?` for the
+ * unused day field), so the same `hq bot jobs` input works for either home.
+ */
+export function toStandardCron(expr) {
+    const trimmed = expr.trim();
+    const wrapped = /^cron\((.*)\)$/.exec(trimmed);
+    if (!wrapped)
+        return trimmed.split(/\s+/).length === 5 ? trimmed : null;
+    const fields = wrapped[1].trim().split(/\s+/);
+    if (fields.length !== 6)
+        return null;
+    const [minute, hour, dom, month, dow] = fields;
+    const standardDow = dow === "?" || dow === "*"
+        ? "*"
+        : replaceNames(dow, { SUN: 1, MON: 2, TUE: 3, WED: 4, THU: 5, FRI: 6, SAT: 7 }).replace(/\d+/g, (n) => String(Number(n) - 1));
+    return [minute, hour, dom === "?" ? "*" : dom, month, standardDow].join(" ");
+}
+/** Parse a standard 5-field cron, or null when it is not one. */
+export function parseCron(expr) {
+    const standard = toStandardCron(expr);
+    if (!standard)
+        return null;
+    const fields = standard.split(/\s+/).map((field, i) => i === 3 ? replaceNames(field, MONTH_NAMES) : i === 4 ? replaceNames(field, DAY_NAMES) : field);
+    if (fields.length !== 5)
+        return null;
+    const sets = fields.map((field, i) => parseField(field, FIELD_RANGES[i]));
+    if (sets.some((set) => set === null))
+        return null;
+    const [minutes, hours, days, months, weekdays] = sets;
+    if (weekdays.has(7))
+        weekdays.add(0);
+    return {
+        minutes: minutes,
+        hours: hours,
+        days: days,
+        months: months,
+        weekdays: weekdays,
+        dayRestricted: fields[2] !== "*",
+        weekdayRestricted: fields[4] !== "*",
+    };
+}
+const WEEKDAY = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+const formatters = new Map();
+function zonedParts(date, timeZone) {
+    let format = formatters.get(timeZone);
+    if (!format) {
+        format = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            hour12: false,
+            minute: "numeric",
+            hour: "numeric",
+            day: "numeric",
+            month: "numeric",
+            weekday: "short",
+        });
+        formatters.set(timeZone, format);
+    }
+    const parts = format.formatToParts(date);
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? "";
+    return {
+        minute: Number(get("minute")),
+        hour: Number(get("hour")) % 24,
+        day: Number(get("day")),
+        month: Number(get("month")),
+        weekday: WEEKDAY[get("weekday")] ?? -1,
+    };
+}
+export function cronMatches(cron, date, timeZone) {
+    const t = zonedParts(date, timeZone);
+    if (!cron.minutes.has(t.minute) || !cron.hours.has(t.hour) || !cron.months.has(t.month))
+        return false;
+    const dayOk = cron.days.has(t.day);
+    const weekdayOk = cron.weekdays.has(t.weekday);
+    // Standard cron: when both day fields are restricted, either may match.
+    if (cron.dayRestricted && cron.weekdayRestricted)
+        return dayOk || weekdayOk;
+    return dayOk && weekdayOk;
+}
+/**
+ * The newest time this job was due, at or before `now` and after the last one
+ * already fired. Null when nothing new is due.
+ */
+/** `rate(5 minutes)` / `rate(1 hour)` / `rate(2 days)` as milliseconds. */
+export function rateIntervalMs(expr) {
+    const match = /^rate\((\d+)\s+(minute|minutes|hour|hours|day|days)\)$/.exec(expr.trim());
+    if (!match)
+        return null;
+    const n = Number(match[1]);
+    const unit = match[2].startsWith("minute") ? 60_000 : match[2].startsWith("hour") ? 3_600_000 : 86_400_000;
+    return n > 0 ? n * unit : null;
+}
+export function isRunnableSchedule(expr) {
+    return rateIntervalMs(expr) !== null || parseCron(expr) !== null;
+}
+export function latestDueFire(job, now) {
+    const interval = rateIntervalMs(job.cron);
+    if (interval) {
+        const origin = Date.parse(job.createdAt);
+        const steps = Math.floor((now.getTime() - origin) / interval);
+        if (steps < 1)
+            return null;
+        const due = origin + steps * interval;
+        return job.lastFiredAt && Date.parse(job.lastFiredAt) >= due ? null : new Date(due);
+    }
+    const cron = parseCron(job.cron);
+    if (!cron)
+        return null;
+    const start = new Date(now);
+    start.setUTCSeconds(0, 0);
+    const floor = Math.max(job.lastFiredAt ? Date.parse(job.lastFiredAt) : Date.parse(job.createdAt), start.getTime() - LOOKBACK_MINUTES * 60_000);
+    for (let t = start.getTime(); t > floor; t -= 60_000) {
+        const at = new Date(t);
+        if (cronMatches(cron, at, job.timezone))
+            return at;
+    }
+    return null;
+}
+/** The next time this job is due after `now`, within a week; null otherwise. */
+export function nextDueFire(job, now) {
+    const interval = rateIntervalMs(job.cron);
+    if (interval) {
+        const origin = Date.parse(job.createdAt);
+        const steps = Math.max(0, Math.floor((now.getTime() - origin) / interval)) + 1;
+        return new Date(origin + steps * interval);
+    }
+    const cron = parseCron(job.cron);
+    if (!cron)
+        return null;
+    const start = new Date(now);
+    start.setUTCSeconds(0, 0);
+    for (let i = 1; i <= LOOKBACK_MINUTES; i += 1) {
+        const at = new Date(start.getTime() + i * 60_000);
+        if (cronMatches(cron, at, job.timezone))
+            return at;
+    }
+    return null;
+}
+// ─── The job list (what `hq bot jobs` reads and writes) ──────────────────────
+export function toJobRecord(job, now = new Date()) {
+    const next = nextDueFire(job, now);
+    return {
+        jobId: job.jobId,
+        prompt: job.prompt,
+        status: "active",
+        schedule: { kind: "recurring", cron: job.cron, timezone: job.timezone },
+        ...(job.context ? { context: job.context } : {}),
+        createdAt: job.createdAt,
+        ...(next ? { nextRunAt: next.toISOString() } : {}),
+        ...(job.lastRunAt ? { lastRunAt: job.lastRunAt } : {}),
+        ...(job.lastStatus ? { lastStatus: job.lastStatus } : {}),
+        ...(job.runCount ? { runCount: job.runCount } : {}),
+    };
+}
+export function addLocalJob(dir, input, now = new Date()) {
+    if (!isRunnableSchedule(input.cron))
+        throw new Error(`"${input.cron}" is not a schedule this bot can run.`);
+    const job = {
+        jobId: `job_${randomUUID().replace(/-/g, "").slice(0, 20)}`,
+        prompt: input.prompt,
+        cron: input.cron,
+        timezone: input.timezone,
+        ...(input.context ? { context: input.context } : {}),
+        createdAt: now.toISOString(),
+    };
+    withJobsLock(dir, () => writeLocalJobs(dir, [...readLocalJobs(dir), job]));
+    return job;
+}
+/** Remove a job. Returns false when the bot has no job with that id. */
+export function removeLocalJob(dir, jobId) {
+    return withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        const next = jobs.filter((job) => job.jobId !== jobId);
+        if (next.length === jobs.length)
+            return false;
+        writeLocalJobs(dir, next);
+        return true;
+    });
+}
+// ─── Firing ──────────────────────────────────────────────────────────────────
+/**
+ * Hand over every job that is due now. Each fire is recorded (lastFiredAt and
+ * inFlight) before its inbox item is returned.
+ */
+const lastCheckedMinute = new Map();
+/** Forget the once-per-minute check (tests, and a bot restarted in-process). */
+export function resetLocalJobChecks() {
+    lastCheckedMinute.clear();
+}
+export function takeDueLocalJobRuns(dir, now = new Date()) {
+    // Schedules have minute resolution and the inbox is polled every few
+    // seconds: look at the jobs once per minute.
+    const minute = Math.floor(now.getTime() / 60_000);
+    if (lastCheckedMinute.get(dir) === minute)
+        return [];
+    lastCheckedMinute.set(dir, minute);
+    return withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        if (jobs.length === 0)
+            return [];
+        const items = [];
+        let changed = false;
+        const next = jobs.map((job) => {
+            if (job.inFlight && now.getTime() - Date.parse(job.inFlight.since) < IN_FLIGHT_RELEASE_MS)
+                return job;
+            const due = latestDueFire(job, now);
+            if (!due) {
+                if (job.inFlight) {
+                    changed = true;
+                    return { ...job, inFlight: undefined };
+                }
+                return job;
+            }
+            const firedAt = due.toISOString();
+            const messageId = `${LOCAL_JOB_MESSAGE_PREFIX}${job.jobId}-${due.getTime()}`;
+            items.push({
+                messageId,
+                channel: "job",
+                jobId: job.jobId,
+                prompt: job.prompt,
+                ...(job.context ? { context: job.context } : {}),
+                firedAt,
+                staleAfter: new Date(due.getTime() + STALE_AFTER_MS).toISOString(),
+                receivedAt: now.toISOString(),
+            });
+            changed = true;
+            return { ...job, lastFiredAt: firedAt, inFlight: { messageId, since: now.toISOString() } };
+        });
+        if (changed)
+            writeLocalJobs(dir, next);
+        return items;
+    });
+}
+export function isLocalJobMessage(messageId) {
+    return messageId.startsWith(LOCAL_JOB_MESSAGE_PREFIX);
+}
+/** Record how a local run finished and release the job for its next fire. */
+export function finishLocalJobRun(dir, jobId, messageId, completion, now = new Date()) {
+    withJobsLock(dir, () => {
+        const jobs = readLocalJobs(dir);
+        let changed = false;
+        const next = jobs.map((job) => {
+            if (job.jobId !== jobId)
+                return job;
+            changed = true;
+            const releases = !job.inFlight || job.inFlight.messageId === messageId;
+            return {
+                ...job,
+                ...(releases ? { inFlight: undefined } : {}),
+                lastRunAt: now.toISOString(),
+                lastStatus: completion.status,
+                runCount: (job.runCount ?? 0) + (completion.status === "succeeded" || completion.status === "failed" ? 1 : 0),
+            };
+        });
+        if (changed)
+            writeLocalJobs(dir, next);
+    });
+}
+/**
+ * The bot's cloud client, with its scheduled runs answered on this computer:
+ * due local jobs join the inbox, and their ack and completion are recorded
+ * locally instead of being sent to the cloud.
+ */
+export function withLocalJobs(api, dir, clock = () => new Date()) {
+    const local = Object.create(api);
+    local.pullInbox = async (agentUid) => {
+        // Cloud first: if that call fails, nothing local has been taken yet, so
+        // no due run is recorded as fired and then dropped.
+        const cloud = await api.pullInbox(agentUid);
+        return [...cloud, ...takeDueLocalJobRuns(dir, clock())];
+    };
+    local.ackInbox = async (agentUid, messageId) => {
+        if (isLocalJobMessage(messageId))
+            return;
+        await api.ackInbox(agentUid, messageId);
+    };
+    local.completeJobRun = async (agentUid, jobId, messageId, completion) => {
+        if (isLocalJobMessage(messageId)) {
+            finishLocalJobRun(dir, jobId, messageId, completion, clock());
+            return;
+        }
+        await api.completeJobRun(agentUid, jobId, messageId, completion);
+    };
+    return local;
+}
+/** The most jobs one bot may hold (the same cap the cloud uses). */
+export const MAX_LOCAL_JOBS = 25;
+/**
+ * `hq bot jobs` against the bot's own folder: the same three calls the cloud
+ * client offers, answered from `jobs.json`.
+ */
+export function localJobsClient(dir, clock = () => new Date()) {
+    return {
+        async listJobs() {
+            const now = clock();
+            return readLocalJobs(dir).map((job) => toJobRecord(job, now));
+        },
+        async createJob(_agentUid, input) {
+            if (input.schedule.kind !== "recurring") {
+                throw new BotApiError(400, "local jobs", "JOB_VALIDATION", "A local bot runs recurring jobs only.");
+            }
+            if (readLocalJobs(dir).length >= MAX_LOCAL_JOBS) {
+                throw new BotApiError(409, "local jobs", "JOB_QUOTA_EXCEEDED", `at most ${MAX_LOCAL_JOBS} jobs`);
+            }
+            const job = addLocalJob(dir, { prompt: input.prompt, cron: input.schedule.cron, timezone: input.schedule.timezone, ...(input.context ? { context: input.context } : {}) }, clock());
+            return toJobRecord(job, clock());
+        },
+        async cancelJob(_agentUid, jobId) {
+            if (!removeLocalJob(dir, jobId)) {
+                throw new BotApiError(404, "local jobs", "JOB_NOT_FOUND", `Job '${jobId}' not found`);
+            }
+        },
+    };
+}
+//# sourceMappingURL=local-jobs.js.map

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

@@ -0,0 +1,27 @@
+import { type FlagClientOptions, type FlagResolution } from "@indigoai-us/hq-flags-client";
+import type { LaneCompanyRef } from "./types.js";
+export declare const LANES_FLAG_API_DEFAULT_ENDPOINT = "https://hqapi.hq.computer";
+export declare const LANES_FLAG_READ_TIMEOUT_MS = 5000;
+export interface LanesFlagClient {
+    ready(): Promise<void>;
+    explain(flagKey: string, options?: {
+        fallback?: boolean;
+    }): FlagResolution;
+    close(): void;
+}
+export type LanesFlagClientFactory = (options: FlagClientOptions) => LanesFlagClient;
+export interface ReadLanesFlagOptions {
+    company?: LaneCompanyRef | null;
+    env?: NodeJS.ProcessEnv;
+    createClient?: LanesFlagClientFactory;
+    getToken?: () => string | Promise<string>;
+    reportFailure?: (error: unknown) => void;
+}
+/**
+ * Read a lanes flag once for each company identity in this CLI process. The
+ * cache contains only an in-flight or settled boolean promise; it is never
+ * written to disk. A local override is checked on every call and wins first.
+ */
+export declare function readLanesRegistryFlag(flagKey: string, options?: ReadLanesFlagOptions): Promise<boolean>;
+export declare function _resetLanesRegistryFlagCacheForTests(): void;
+//# sourceMappingURL=registry-flag.d.ts.map

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

@@ -0,0 +1,129 @@
+import { createFlagClient, readLocalOverride, } from "@indigoai-us/hq-flags-client";
+import { ensureCognitoIdToken } from "../../utils/cognito-session.js";
+export const LANES_FLAG_API_DEFAULT_ENDPOINT = "https://hqapi.hq.computer";
+export const LANES_FLAG_READ_TIMEOUT_MS = 5_000;
+const registryReads = new Map();
+class MissingFlagTokenError extends Error {
+    constructor() {
+        super("No cached HQ identity token is available");
+        this.name = "MissingFlagTokenError";
+    }
+}
+class MissingFlagRowError extends Error {
+    constructor(flagKey) {
+        super(`The hq-flags registry did not resolve ${flagKey}`);
+        this.name = "MissingFlagRowError";
+    }
+}
+function errorClass(error) {
+    return error instanceof Error ? error.name : "UnknownError";
+}
+function reportReadFailure(flagKey, error) {
+    const suffix = flagKey.replace(/^lanes\./, "").replaceAll(/[^a-zA-Z0-9]+/g, "_");
+    process.stderr.write(`${JSON.stringify({
+        event: `lanes.${suffix}.flag_read_failed`,
+        flag: flagKey,
+        error: errorClass(error),
+        fallback: false,
+    })}\n`);
+}
+function cacheKey(flagKey, company, endpoint) {
+    return JSON.stringify([
+        flagKey,
+        endpoint,
+        company?.uid ?? null,
+        company?.slug ?? null,
+    ]);
+}
+/**
+ * Read a lanes flag once for each company identity in this CLI process. The
+ * cache contains only an in-flight or settled boolean promise; it is never
+ * written to disk. A local override is checked on every call and wins first.
+ */
+export async function readLanesRegistryFlag(flagKey, options = {}) {
+    const env = options.env ?? process.env;
+    const localOverride = readLocalOverride(flagKey, env);
+    if (localOverride !== null)
+        return localOverride;
+    const endpoint = env.HQ_FLAGS_API_URL?.trim() || LANES_FLAG_API_DEFAULT_ENDPOINT;
+    const key = cacheKey(flagKey, options.company, endpoint);
+    const cached = registryReads.get(key);
+    if (cached)
+        return cached;
+    const pending = readRegistryValue(flagKey, endpoint, options);
+    registryReads.set(key, pending);
+    return pending;
+}
+async function readRegistryValue(flagKey, endpoint, options) {
+    const company = options.company;
+    const companyUid = company?.uid?.trim();
+    const companySlug = company?.slug?.trim();
+    let client;
+    let enabled = false;
+    let failed = false;
+    let reported = false;
+    const reportFailure = (error) => {
+        failed = true;
+        if (reported)
+            return;
+        reported = true;
+        (options.reportFailure ?? ((cause) => reportReadFailure(flagKey, cause)))(error);
+    };
+    try {
+        const acquireToken = options.getToken ?? (async () => {
+            try {
+                return await ensureCognitoIdToken({ interactive: false });
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message.startsWith("No valid HQ session")) {
+                    throw new MissingFlagTokenError();
+                }
+                throw error;
+            }
+        });
+        const getToken = async () => {
+            const token = await acquireToken();
+            if (typeof token !== "string" || token.trim().length === 0) {
+                throw new MissingFlagTokenError();
+            }
+            return token;
+        };
+        client = (options.createClient ?? createFlagClient)({
+            endpoint,
+            getToken,
+            env: {},
+            refreshIntervalMs: 0,
+            requestTimeoutMs: LANES_FLAG_READ_TIMEOUT_MS,
+            ...(companyUid ? { companyUid } : {}),
+            ...(companySlug ? { companyIdentifiers: [companySlug] } : {}),
+            onError: reportFailure,
+        });
+        await client.ready();
+        const resolution = client.explain(flagKey, { fallback: false });
+        if (failed)
+            return false;
+        if (resolution.source !== "snapshot" && resolution.source !== "local-override") {
+            reportFailure(new MissingFlagRowError(flagKey));
+        }
+        else {
+            enabled = resolution.value;
+        }
+    }
+    catch (error) {
+        reportFailure(error);
+    }
+    finally {
+        try {
+            client?.close();
+        }
+        catch (error) {
+            reportFailure(error);
+        }
+    }
+    return failed ? false : enabled;
+}
+export function _resetLanesRegistryFlagCacheForTests() {
+    registryReads.clear();
+}
+//# sourceMappingURL=registry-flag.js.map

package/package.json

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