@indigoai-us/hq-cli 5.345.11 → 5.345.12

package/dist/lib/daemon/lanes-reconcile-guard.js

@@ -0,0 +1,115 @@
+/**
+ * Pre-spawn check for the desktop `lanes-reconcile` unit.
+ *
+ * Every reconcile pass is a fresh `hq` node process (~1.8 s CPU, ~200 MB RSS),
+ * so a 15-second poll costs about 12% of a core even when the lane store holds
+ * nothing to do. This check reads the lane store in-process (readdir + small
+ * JSON reads, no child process) and tells the supervisor how urgent the next
+ * pass is:
+ *
+ * - `spawn`: something the 15-second cadence exists for may be due — lane
+ *   admission, a running lane's heartbeat, or a keep-alive resume (#1396).
+ * - `idle`: only work that ran on the pre-#1396 60-second cadence remains
+ *   (terminal lanes, worker-profile resumes, question aging, Codex rollout
+ *   retention, lead-autopilot registry). The supervisor runs it at most once
+ *   per `idleIntervalSec`.
+ * - `skip`: the store holds no lane or question records, no lead registry and
+ *   no lanes config, so a reconcile pass has no input to act on.
+ *
+ * Any error reading the store returns `spawn` (fail open), as does any record
+ * this check does not understand.
+ *
+ * The paths below mirror `LANES_STORE_REL`, `LANE_RECORDS_DIR`,
+ * `QUESTION_RECORDS_DIR` (lanes/store.ts), `LANES_CONFIG_REL` (lanes/config.ts)
+ * and `LEAD_REGISTRY_REL` (lanes/autopilot-registry.ts). They are copied, not
+ * imported, so the daemon does not load the lanes modules; a test pins them to
+ * the originals.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const LANES_STORE_DIR = path.join("workspace", "lanes");
+export const LANE_RECORDS_SUBDIR = "lanes";
+export const QUESTION_RECORDS_SUBDIR = "questions";
+export const LANES_CONFIG_FILE = path.join("personal", "lanes", "config.json");
+export const LEAD_REGISTRY_FILE = path.join("workspace", "lane-briefs", "juniors.json");
+/**
+ * Lane states that reconcile admission, heartbeats and liveness never act on.
+ * `blocked` is listed because reconcile only resumes a blocked lane when it is
+ * keep-alive, which is checked separately.
+ */
+const QUIET_LANE_STATES = new Set(["done", "failed", "interrupted", "cancelled", "killed", "blocked"]);
+const realFs = {
+    readdirSync: (dir) => fs.readdirSync(dir),
+    readFileSync: (file, encoding) => fs.readFileSync(file, encoding),
+    existsSync: (file) => fs.existsSync(file),
+};
+/** Same filter reconcile's `readDirJsonIds` applies. */
+function recordNames(fsDeps, dir) {
+    let names;
+    try {
+        names = fsDeps.readdirSync(dir);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    return names.filter((name) => name.endsWith(".json") && !name.startsWith(".") && !name.includes(".conflict-"));
+}
+function readRecord(fsDeps, file) {
+    const parsed = JSON.parse(fsDeps.readFileSync(file, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`${file} is not a JSON object`);
+    }
+    return parsed;
+}
+/** A lane that may need the 15-second cadence. Unknown shapes count as urgent. */
+function laneIsUrgent(lane) {
+    if (typeof lane.state !== "string" || !QUIET_LANE_STATES.has(lane.state))
+        return true;
+    if (lane.keep_alive === true)
+        return true;
+    if (lane.pending_resume !== undefined)
+        return true;
+    return false;
+}
+export function lanesReconcileVerdict(hqRoot, fsDeps = realFs) {
+    try {
+        if (!hqRoot)
+            return "spawn";
+        const store = path.join(hqRoot, LANES_STORE_DIR);
+        const laneDir = path.join(store, LANE_RECORDS_SUBDIR);
+        const questionDir = path.join(store, QUESTION_RECORDS_SUBDIR);
+        const laneNames = recordNames(fsDeps, laneDir);
+        const questionNames = recordNames(fsDeps, questionDir);
+        for (const name of laneNames) {
+            if (laneIsUrgent(readRecord(fsDeps, path.join(laneDir, name))))
+                return "spawn";
+        }
+        for (const name of questionNames) {
+            const question = readRecord(fsDeps, path.join(questionDir, name));
+            if (typeof question.status !== "string" || question.status === "pending")
+                return "spawn";
+        }
+        if (laneNames.length === 0 &&
+            questionNames.length === 0 &&
+            !fsDeps.existsSync(path.join(hqRoot, LEAD_REGISTRY_FILE)) &&
+            !fsDeps.existsSync(path.join(hqRoot, LANES_CONFIG_FILE))) {
+            return "skip";
+        }
+        return "idle";
+    }
+    catch {
+        return "spawn";
+    }
+}
+/** The supervisor's `runGuard`: dispatches on the unit's declared guard. */
+export function daemonRunGuard(unit) {
+    switch (unit.runGuard?.name) {
+        case "lanes-reconcile":
+            return lanesReconcileVerdict(unit.env.HQ_ROOT);
+        default:
+            return "spawn";
+    }
+}
+//# sourceMappingURL=lanes-reconcile-guard.js.map

package/dist/lib/daemon/run.js

@@ -45,6 +45,7 @@ import { adoptChild, createChildTracker, finishSuccession, handoffEligible, read
 import { listSyncRunnerProcesses, readWatchRunnerOwnerStatus, syncHeartbeatTimeoutMs, syncRunnerNodeOptions, watchRunnerOwnerStatusPath, } from "./sync-runner.js";
 import { STOP_ESCALATION_MS, createSupervisor, } from "./supervisor.js";
 import { userToolDirs } from "./tools.js";
+import { daemonRunGuard } from "./lanes-reconcile-guard.js";
 export const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
 /** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
 export const RESTART_EXIT_CODE = 75;
@@ -788,6 +789,7 @@ export async function runDaemon(opts) {
             return takeControlRequests(paths.requestsDir);
         },
         restartDaemon: () => restartDaemon(),
+        runGuard: daemonRunGuard,
         writeState: (state) => writeJsonAtomic(paths.statePath, state),
         log,
         syncOwnerBlockReason: () => {

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

@@ -111,6 +111,8 @@ export interface SupervisorDeps {
     cliVersion?: string;
     /** Services to take over from the previous daemon instead of starting them. */
     adopt?: readonly AdoptedUnit[];
+    /** Pre-run check for scheduled units that declare `runGuard`; a throw counts as `spawn`. */
+    runGuard?: (unit: UnitPlan) => "spawn" | "idle" | "skip";
 }
 export interface Supervisor {
     start(): void;

package/dist/lib/daemon/supervisor.js

@@ -56,6 +56,9 @@ export function planKey(plan, cliVersion) {
         plan.command,
         plan.env,
     ];
+    // Only units that declare a guard carry it, so existing keys stay unchanged.
+    if (plan.runGuard !== undefined)
+        fields.push({ runGuard: plan.runGuard });
     if (cliVersion !== undefined && plan.command?.type === "hq" && !plan.keepAcrossCliUpdates)
         fields.push(cliVersion);
     return JSON.stringify(fields);
@@ -554,6 +557,27 @@ export function createSupervisor(deps) {
             runScheduled(slot);
         }, delayMs);
     };
+    /** True when the unit's run guard says this timed run has nothing to do. Fails open. */
+    const guardSaysWait = (slot) => {
+        const guard = slot.plan.runGuard;
+        if (!guard || !deps.runGuard)
+            return false;
+        let verdict;
+        try {
+            verdict = deps.runGuard(slot.plan);
+        }
+        catch (err) {
+            deps.log("warn", `${slot.plan.id} run check failed, running anyway: ${errorMessage(err)}`);
+            return false;
+        }
+        if (verdict === "skip")
+            return true;
+        if (verdict === "idle") {
+            const last = slot.state.lastRunAt;
+            return last !== undefined && now() - last < guard.idleIntervalSec * 1000;
+        }
+        return false;
+    };
     const runScheduled = (slot, manual = false) => {
         if (stopped)
             return;
@@ -564,6 +588,10 @@ export function createSupervisor(deps) {
             emit();
             return;
         }
+        if (!manual && guardSaysWait(slot)) {
+            emit();
+            return;
+        }
         slot.busy = true;
         slot.state.lastRunAt = now();
         const command = slot.plan.command;

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

@@ -1,7 +1,5 @@
 import type { LaneCompanyRef, LaneHost } from "./types.js";
-export declare const OUTPOST_LEAD_REGISTRY_SCHEMA = "hq-lanes-outpost-lead-registry.v1";
-export declare const OUTPOST_LEAD_REGISTRY_MAX_AGE_MS: number;
-export declare const OUTPOST_LEAD_REGISTRY_REFRESH_MS: number;
+declare const OUTPOST_LEAD_REGISTRY_SCHEMA = "hq-lanes-outpost-lead-registry.v1";
 export declare const LEAD_REGISTRY_REL: string;
 export declare const OUTPOST_LEAD_REGISTRY_STATE_REL: string;
 export declare const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
@@ -23,8 +21,6 @@ export declare function buildOutpostLeadRegistry(input: {
     outpostId: string;
     generatedAt: string;
 }): OutpostLeadRegistry;
-/** Stage a host-filtered registry on the Outpost using an atomic local rename. */
-export declare function buildOutpostLeadRegistryInstallCommand(registry: OutpostLeadRegistry): string;
 export declare function syncOutpostLeadRegistries(input: {
     hqRoot: string;
     outpostIds: readonly string[];
@@ -59,4 +55,5 @@ export declare function validateOutpostLeadRegistry(input: {
     outpostId: string;
     now: Date;
 }): OutpostLeadRegistry;
+export {};
 //# sourceMappingURL=autopilot-registry.d.ts.map

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

@@ -4,9 +4,9 @@ import * as path from "node:path";
 import { joinCommandParts, withRemoteHqDir } from "@indigoai-us/hq-cloud/outposts";
 import { isControllerAliasOutpostId } from "./admission-host.js";
 import { LanesError } from "./errors.js";
-export const OUTPOST_LEAD_REGISTRY_SCHEMA = "hq-lanes-outpost-lead-registry.v1";
-export const OUTPOST_LEAD_REGISTRY_MAX_AGE_MS = 24 * 60 * 60 * 1000;
-export const OUTPOST_LEAD_REGISTRY_REFRESH_MS = 6 * 60 * 60 * 1000;
+const OUTPOST_LEAD_REGISTRY_SCHEMA = "hq-lanes-outpost-lead-registry.v1";
+const OUTPOST_LEAD_REGISTRY_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const OUTPOST_LEAD_REGISTRY_REFRESH_MS = 6 * 60 * 60 * 1000;
 export const LEAD_REGISTRY_REL = path.join("workspace", "lane-briefs", "juniors.json");
 export const OUTPOST_LEAD_REGISTRY_STATE_REL = path.join("workspace", "lane-briefs", "autopilot-outpost-registry-state.json");
 export const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
@@ -50,7 +50,7 @@ export function buildOutpostLeadRegistry(input) {
     };
 }
 /** Stage a host-filtered registry on the Outpost using an atomic local rename. */
-export function buildOutpostLeadRegistryInstallCommand(registry) {
+function buildOutpostLeadRegistryInstallCommand(registry) {
     const encoded = Buffer.from(`${JSON.stringify(registry)}\n`, "utf8").toString("base64");
     const script = [
         'const fs=require("node:fs"),path=require("node:path");',

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

@@ -19,11 +19,6 @@ export declare const QUESTION_AGE_MS: number;
 export declare const MAX_AGED_ADVANCES: number;
 /** Aligns with watcher silence: a host that has not reported for this long is dead. */
 export declare const DEAD_HOST_MS: number;
-export declare const RECONCILE_LOCK_STALE_MS = 30000;
-export declare const RECONCILE_LOCK_TIMEOUT_MS = 5000;
-/** A pickup probe that has not cleared its marker within this window is abandoned. */
-export declare const PICKUP_VALIDATION_MAX_AGE_MS: number;
-export declare const PICKUP_VALIDATION_TIMEOUT_REASON: "pickup_validation_timeout";
 export declare const CLOSE_INTERRUPTED_DONE_STORY_WORKERS_FLAG = "lanes.close-interrupted-done-story-workers";
 export declare const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";
 export declare const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";

package/dist/lib/lanes/reconcile.js

@@ -45,11 +45,11 @@ export const QUESTION_AGE_MS = 60 * 60 * 1000;
 export const MAX_AGED_ADVANCES = MAX_LANE_DEPTH - 1;
 /** Aligns with watcher silence: a host that has not reported for this long is dead. */
 export const DEAD_HOST_MS = SILENCE_MS;
-export const RECONCILE_LOCK_STALE_MS = 30_000;
-export const RECONCILE_LOCK_TIMEOUT_MS = 5_000;
+const RECONCILE_LOCK_STALE_MS = 30_000;
+const RECONCILE_LOCK_TIMEOUT_MS = 5_000;
 /** A pickup probe that has not cleared its marker within this window is abandoned. */
-export const PICKUP_VALIDATION_MAX_AGE_MS = 15 * 60 * 1000;
-export const PICKUP_VALIDATION_TIMEOUT_REASON = "pickup_validation_timeout";
+const PICKUP_VALIDATION_MAX_AGE_MS = 15 * 60 * 1000;
+const PICKUP_VALIDATION_TIMEOUT_REASON = "pickup_validation_timeout";
 export const CLOSE_INTERRUPTED_DONE_STORY_WORKERS_FLAG = "lanes.close-interrupted-done-story-workers";
 const INTERRUPTED_DONE_STORY_MIN_AGE_MS = 24 * 60 * 60 * 1000;
 export const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";

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

@@ -179,7 +179,7 @@ export declare const LANE_PROVIDERS: readonly ["claude", "codex", "grok"];
 export type LaneProvider = (typeof LANE_PROVIDERS)[number];
 export declare const QUEUED_REASONS: readonly ["cap", "provider_cap", "account_cap", "profile_cap", "queue_position", "throttle", "provider_binary_missing", "account_retry", "lead_reserve", "worker_profile_changed", "low_disk", "admit_failed"];
 export type QueuedReason = (typeof QUEUED_REASONS)[number];
-export type QueuedDetails = {
+type QueuedDetails = {
     reason: "worker_profile_changed";
     expected_hash: string | null;
     actual_hash: string;
@@ -308,7 +308,7 @@ export interface SeniorHistoryEntry {
     by: string;
     reason: string;
 }
-export interface LaneStopHistoryEntry {
+interface LaneStopHistoryEntry {
     at: string;
     reason: string;
 }
@@ -370,7 +370,7 @@ export interface AttributionHistoryEntry {
     at: string;
     story_switch_unacknowledged?: StorySwitchUnacknowledgedNote;
 }
-export interface StorySwitchPending {
+interface StorySwitchPending {
     previous_project_id: string;
     previous_story_id: string;
     project_id: string;
@@ -416,7 +416,7 @@ export interface ManagerStatusGateHistoryEntry {
     resume_queued?: boolean;
     resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
 }
-export interface BlockerFreshnessState {
+interface BlockerFreshnessState {
     /** Stable hashes of the stale blocker labels seen at the last completed turn. */
     stale_keys: string[];
     stale_labels: string[];
@@ -440,7 +440,7 @@ export interface BlockerFreshnessHistoryEntry {
     reason?: string;
     delivery_recovered?: true;
 }
-export interface KrFreshnessState {
+interface KrFreshnessState {
     /** Stable fingerprint of the last stalled KPI set, which is resumed once. */
     stalled_fingerprint?: string;
 }
@@ -1044,4 +1044,5 @@ export interface LanesConfig {
 export declare function isIsoDateTime(value: string): boolean;
 export declare function parseMajorSchema(schemaVersion: string, expectedPrefix: string, expectedMajor: number): void;
 export declare function parseLaneEnvelope(raw: unknown): LaneEnvelope;
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/utils/run-bundled-script.js

@@ -33,7 +33,7 @@ import { spawnSync } from "child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "path";
-import { resolveBundledAsset } from "./hq-roots.js";
+import { resolveBundledAsset } from "./hq-roots-core.js";
 /**
  * Which interpreter runs a bundled asset, chosen by extension.
  *

package/package.json

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