@indigoai-us/hq-cli 5.345.127 → 5.345.129

package/dist/lib/bot/inbox-wake.js

@@ -0,0 +1,125 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { AGENT_INBOX_PUSH_STATE_BASENAME } from "../mesh/live/paths.js";
+export { AGENT_INBOX_PUSH_STATE_BASENAME } from "../mesh/live/paths.js";
+const INBOX_PUSH_SUBSCRIPTION_STALE_MS = 15_000;
+function readWakeState(root, onError) {
+    const target = path.join(root, AGENT_INBOX_PUSH_STATE_BASENAME);
+    try {
+        const info = fs.lstatSync(target);
+        if (!info.isFile() || info.isSymbolicLink())
+            return { wakeSequence: 0, connected: false, heartbeatAtMs: 0 };
+        const parsed = JSON.parse(fs.readFileSync(target, "utf8"));
+        return {
+            wakeSequence: Number.isSafeInteger(parsed.wakeSequence) && Number(parsed.wakeSequence) >= 0
+                ? Number(parsed.wakeSequence)
+                : 0,
+            connected: parsed.connected === true,
+            heartbeatAtMs: typeof parsed.heartbeatAtMs === "number" && Number.isFinite(parsed.heartbeatAtMs)
+                ? parsed.heartbeatAtMs
+                : 0,
+            ...(typeof parsed.agentUid === "string" ? { agentUid: parsed.agentUid } : {}),
+        };
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            onError?.(error);
+        return { wakeSequence: 0, connected: false, heartbeatAtMs: 0 };
+    }
+}
+/** Watches the content-free Work Mesh inbox sequence, with a bounded poll fallback. */
+export function createInboxWakeWatcher(root, options = {}) {
+    const now = options.now ?? Date.now;
+    let lastState = readWakeState(root, options.onError);
+    let lastSequence = lastState.wakeSequence;
+    let closed = false;
+    let pendingWake = false;
+    const waiters = new Set();
+    let watcher;
+    const signalWake = () => {
+        pendingWake = waiters.size === 0;
+        for (const resolve of waiters)
+            resolve("wake");
+        waiters.clear();
+    };
+    try {
+        watcher = (options.watch ?? ((directory, listener) => fs.watch(directory, listener)))(root, (_event, filename) => {
+            if (filename !== null && filename.toString() !== AGENT_INBOX_PUSH_STATE_BASENAME)
+                return;
+            const nextState = readWakeState(root, options.onError);
+            const sequenceAdvanced = nextState.wakeSequence > lastSequence;
+            const subscriptionChanged = nextState.connected !== lastState.connected || nextState.agentUid !== lastState.agentUid;
+            lastState = nextState;
+            if (sequenceAdvanced) {
+                lastSequence = nextState.wakeSequence;
+                signalWake();
+            }
+            else if (subscriptionChanged) {
+                signalWake();
+            }
+        });
+        watcher.on?.("error", (error) => {
+            options.onError?.(error);
+            const failedWatcher = watcher;
+            watcher = undefined;
+            try {
+                failedWatcher?.close();
+            }
+            catch (closeError) {
+                options.onError?.(closeError);
+            }
+        });
+        // Close the read/register race: a writer can advance the sequence after
+        // the baseline read but before fs.watch is attached.
+        const currentState = readWakeState(root, options.onError);
+        if (currentState.wakeSequence > lastSequence) {
+            lastSequence = currentState.wakeSequence;
+            signalWake();
+        }
+    }
+    catch (error) {
+        options.onError?.(error);
+    }
+    return {
+        wait(delayMs, signal) {
+            if (closed || signal?.aborted)
+                return Promise.resolve("aborted");
+            if (pendingWake) {
+                pendingWake = false;
+                return Promise.resolve("wake");
+            }
+            return new Promise((resolve) => {
+                let settled = false;
+                const finish = (event) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    waiters.delete(finish);
+                    signal?.removeEventListener("abort", abort);
+                    resolve(event);
+                };
+                const abort = () => finish("aborted");
+                const timer = setTimeout(() => finish("timeout"), Math.max(0, delayMs));
+                waiters.add(finish);
+                signal?.addEventListener("abort", abort, { once: true });
+            });
+        },
+        isLiveFor(agentUid) {
+            const state = readWakeState(root, options.onError);
+            const ageMs = now() - state.heartbeatAtMs;
+            return state.connected && state.agentUid === agentUid &&
+                ageMs >= 0 && ageMs <= INBOX_PUSH_SUBSCRIPTION_STALE_MS;
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            watcher?.close();
+            for (const resolve of waiters)
+                resolve("aborted");
+            waiters.clear();
+        },
+    };
+}
+//# sourceMappingURL=inbox-wake.js.map

package/dist/lib/bot/run.d.ts

@@ -58,7 +58,9 @@ import type { VaultObjectDownloader } from "../agent-kit/attachment-download.js"
 import { type HeartbeatAgentUidSource, type HeartbeatCredsSource, type HeartbeatIdentityMismatchReporter } from "../heartbeat-identity.js";
 import { type BotState, type BotStatusFile } from "./status.js";
 import { type CliUpdate, type CliUpdateWatch } from "./cli-update.js";
+import { createInboxWakeWatcher } from "./inbox-wake.js";
 export declare const INBOX_POLL_INTERVAL_MS = 2000;
+export declare const INBOX_MQTT_WAKE_FALLBACK_MS = 60000;
 export declare const HEARTBEAT_INTERVAL_MS = 30000;
 /** First 429/5xx wait when Retry-After is absent (inbox polls at 2s). */
 export declare const API_BACKOFF_BASE_MS = 4000;
@@ -154,6 +156,12 @@ export interface BotRunDeps {
     signInRetryMs?: number;
     /** How long model turns are held after FAILURE_LIMIT failures in a window (default FAILURE_WINDOW_MS). */
     modelHoldMs?: number;
+    /** Kill-switch reader for the Work Mesh MQTT inbox wake path. */
+    inboxMqttWakeEnabled?: () => Promise<boolean>;
+    /** Work Mesh state directory; tests use a scratch directory. */
+    inboxWakeRoot?: string;
+    /** Test seam for the inbox wake source. */
+    createInboxWakeWatcher?: typeof createInboxWakeWatcher;
     /**
      * Downloads a chat attachment's bytes with the bot's own machine identity
      * (vault presign). Unset = attachments are listed with a "cannot download"

package/dist/lib/bot/run.js

@@ -89,8 +89,11 @@ import { clearBotSession, readBotSession, writeBotSession } from "./session.js";
 import { defaultBotStatus, patchBotStatus, readBotStatus } from "./status.js";
 import { CLI_VERSION } from "../../cli-version.js";
 import { CLI_UPDATE_RESTART_EXIT_CODE } from "./cli-update.js";
-import { createInboxPollBackoffFlagReader, safeErrorClass } from "./inbox-poll-backoff-flag.js";
+import { createInboxMqttWakeFlagReader, createInboxPollBackoffFlagReader, safeErrorClass } from "./inbox-poll-backoff-flag.js";
+import { createInboxWakeWatcher } from "./inbox-wake.js";
+import { workMeshRoot } from "../mesh/live/paths.js";
 export const INBOX_POLL_INTERVAL_MS = 2_000;
+export const INBOX_MQTT_WAKE_FALLBACK_MS = 60_000;
 export const HEARTBEAT_INTERVAL_MS = 30_000;
 /** First 429/5xx wait when Retry-After is absent (inbox polls at 2s). */
 export const API_BACKOFF_BASE_MS = 4_000;
@@ -337,6 +340,21 @@ export async function runBot(deps) {
     const runTurn = deps.runTurn ?? ((rt, input) => runRuntimeTurn(rt, input));
     const inboxIntervalMs = deps.inboxIntervalMs ?? INBOX_POLL_INTERVAL_MS;
     const inboxPollBackoffEnabled = deps.inboxPollBackoffEnabled ?? createInboxPollBackoffFlagReader(config);
+    const inboxMqttWakeEnabled = deps.inboxMqttWakeEnabled ?? createInboxMqttWakeFlagReader(config);
+    const makeInboxWakeWatcher = deps.createInboxWakeWatcher ?? createInboxWakeWatcher;
+    const inboxWakeWatcherRef = { current: null };
+    const getInboxWakeWatcher = () => {
+        const watcher = inboxWakeWatcherRef.current ?? makeInboxWakeWatcher(deps.inboxWakeRoot ?? workMeshRoot(), {
+            onError: (error) => log("warn", `Work Mesh inbox wake unavailable (${safeErrorClass(error)}); retaining the fallback inbox poll`),
+        });
+        inboxWakeWatcherRef.current = watcher;
+        return watcher;
+    };
+    const closeInboxWakeWatcher = () => {
+        const watcher = inboxWakeWatcherRef.current;
+        watcher?.close();
+        inboxWakeWatcherRef.current = null;
+    };
     const jobQuietOptionEnabled = deps.jobQuietOptionEnabled ?? botJobQuietOptionEnabled;
     const heartbeatIntervalMs = deps.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;
     const exit = deps.exit ?? ((code) => process.exit(code));
@@ -443,6 +461,7 @@ export async function runBot(deps) {
         if (state === "stopped" || state === "failed")
             return;
         state = final;
+        closeInboxWakeWatcher();
         setStatus({ state: final, ...(final === "failed" ? { lastError: reason.slice(0, 400) } : {}) });
         log(final === "failed" ? "error" : "info", `bot ${final}: ${reason}`);
         if (!deps.skipPidLock)
@@ -771,7 +790,7 @@ export async function runBot(deps) {
         inboxWaitGeneration += 1;
         activeInboxWait?.abort();
     };
-    const waitForInbox = async (delayMs, adaptive) => {
+    const waitForInbox = async (delayMs, adaptive, useMqttWake = false) => {
         if (!adaptive) {
             await sleep(delayMs);
             return;
@@ -781,8 +800,13 @@ export async function runBot(deps) {
         while (remainingMs > 0 && !stopping && state === "running") {
             const controller = new AbortController();
             activeInboxWait = controller;
-            const chunkMs = Math.min(inboxIntervalMs, remainingMs);
-            await sleep(chunkMs, controller.signal);
+            const chunkMs = useMqttWake ? remainingMs : Math.min(inboxIntervalMs, remainingMs);
+            if (useMqttWake) {
+                await getInboxWakeWatcher().wait(chunkMs, controller.signal);
+            }
+            else {
+                await sleep(chunkMs, controller.signal);
+            }
             if (activeInboxWait === controller)
                 activeInboxWait = null;
             if (stopping || state !== "running")
@@ -795,9 +819,8 @@ export async function runBot(deps) {
                 continue;
             }
             remainingMs -= chunkMs;
-            // Keep the install watcher at its original two-second cadence even when
-            // the inbox itself is waiting longer between empty polls.
-            if (remainingMs > 0 && pollForCliUpdate())
+            // The MQTT wake or bounded fallback also checks for CLI updates.
+            if (remainingMs > 0 && !useMqttWake && pollForCliUpdate())
                 break;
         }
     };
@@ -2332,6 +2355,18 @@ export async function runBot(deps) {
                 log("warn", `inbox poll backoff flag lookup failed (${safeErrorClass(error)}); using default-off`);
                 return false;
             });
+            const useMqttWake = await inboxMqttWakeEnabled().catch((error) => {
+                log("warn", `inbox MQTT wake flag lookup failed (${safeErrorClass(error)}); using default-on`);
+                return true;
+            });
+            // Arm before pulling so a wake arriving between the pull and wait is not
+            // lost. The watcher also checks the sequence again after registration.
+            if (useMqttWake) {
+                getInboxWakeWatcher();
+            }
+            else {
+                closeInboxWakeWatcher();
+            }
             let items;
             try {
                 items = await api.pullInbox(config.agentUid);
@@ -2361,6 +2396,15 @@ export async function runBot(deps) {
             }
             if (stopping || state !== "running")
                 break;
+            if (useMqttWake) {
+                const hasLiveInboxSubscription = items.length === 0 &&
+                    getInboxWakeWatcher().isLiveFor?.(config.agentUid) === true;
+                const delayMs = items.length > 0 || !hasLiveInboxSubscription
+                    ? inboxIntervalMs
+                    : INBOX_MQTT_WAKE_FALLBACK_MS;
+                await waitForInbox(delayMs, true, true);
+                continue;
+            }
             if (!useInboxBackoff) {
                 inboxBackoffIndex = 0;
                 await waitForInbox(inboxIntervalMs, false);

package/dist/lib/bot/runtime/messages-stream.js

@@ -87,7 +87,7 @@ export function messagesStreamResult(stdout, runtimeName) {
     if (!sawJson)
         throw new RuntimeError(`${runtimeName} returned non-JSON output`, stdout.trim().slice(-400), null, { excerptIsOutputTail: true });
     if (result?.is_error === true) {
-        const detail = typeof result.result === "string" && result.result ? result.result : String(result.subtype ?? "error");
+        const detail = typeof result.result === "string" && result.result ? result.result : (resultErrors(result) ?? String(result.subtype ?? "error"));
         throw new RuntimeError(`${runtimeName} reported an error: ${detail.slice(0, 200)}`, detail.slice(0, 400), null);
     }
     const text = (typeof result?.result === "string" && result.result.trim() ? result.result : lastText) ?? "";
@@ -143,8 +143,12 @@ export function messagesStreamFailure(stdout) {
     let reason;
     for (const line of stdout.split("\n")) {
         const ev = parseJsonLine(line);
-        if (ev?.type === "result" && ev.is_error === true && typeof ev.result === "string" && ev.result.trim())
-            reason = ev.result.trim();
+        if (ev?.type === "result" && ev.is_error === true) {
+            if (typeof ev.result === "string" && ev.result.trim())
+                reason = ev.result.trim();
+            else
+                reason = resultErrors(ev) ?? reason;
+        }
         if (ev?.type === "error" && typeof ev.message === "string" && ev.message.trim())
             reason = ev.message.trim();
     }
@@ -187,8 +191,32 @@ export function prettyJsonFailure(stdout) {
         return ev.result.trim();
     if (typeof ev.message === "string" && ev.message.trim())
         return ev.message.trim();
+    const errors = resultErrors(ev);
+    if (errors)
+        return errors;
     if (typeof ev.subtype === "string" && ev.subtype.trim() && ev.subtype !== "success")
         return ev.subtype.trim();
     return undefined;
 }
+/**
+ * The `errors` array on a Claude result envelope. A failed `--resume` ends
+ * with `{"subtype":"error_during_execution","is_error":true,"errors":["No
+ * conversation found with session ID: …"]}` and no `result` text; without
+ * this the failure reads as the bare subtype, the stale-session check never
+ * matches, and every turn on that scope fails the same way.
+ */
+function resultErrors(ev) {
+    if (!Array.isArray(ev.errors))
+        return undefined;
+    const parts = ev.errors.flatMap((e) => {
+        if (typeof e === "string")
+            return e.trim() ? [e.trim()] : [];
+        if (e && typeof e === "object" && typeof e.message === "string") {
+            const m = e.message.trim();
+            return m ? [m] : [];
+        }
+        return [];
+    });
+    return parts.length > 0 ? parts.join("; ") : undefined;
+}
 //# sourceMappingURL=messages-stream.js.map

package/dist/lib/capacity/lane-login.js

@@ -82,6 +82,7 @@ function canonicalHome(home, homedir) {
 }
 function handlerDeps(printJson) {
     return {
+        admitQueuedFromCtx: async () => [],
         automaticBalanceMoveHistoryReason: () => unused("automaticBalanceMoveHistoryReason"),
         ensureDir: (dir) => {
             fs.mkdirSync(dir, { recursive: true });

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

@@ -109,6 +109,10 @@ export interface PlanContext {
     syncRunnerProcesses: readonly SyncRunnerProcess[] | null;
     /** PID recorded in the watch-owner status, when it is readable. */
     syncRunnerOwnerPid: number | null;
+    /** The daemon's in-process lane watcher owns reconcile while its kill switch is on. */
+    lanesReconcileInProcess?: boolean;
+    /** The active hq-cloud sync runner owns post-sync QMD indexing. */
+    searchIndexOwnedBySyncRunner?: boolean;
     /** Sync runner children already started by this daemon before their lease is written. */
     daemonSyncRunnerPids?: ReadonlySet<number>;
     /** The protocol-event heartbeat watchdog timeout for the sync runner. */

package/dist/lib/daemon/catalog.js

@@ -227,14 +227,15 @@ function planService(service, ctx) {
                 }),
             ];
         case "lanes-reconcile":
+            if (ctx.lanesReconcileInProcess)
+                return [];
             return [
                 base(service, {
                     kind: "scheduled",
                     // Polls every 15 s so local keep-alive resumes are admitted on time (#1396).
                     // Each pass is a fresh `hq` node process (~1.8 s CPU, ~200 MB RSS), so
-                    // desktops first check the lane store in-process
-                    // (lanes-reconcile-guard.ts) and fall back to the pre-#1396 60 s
-                    // cadence, or no run, when no lane can need the 15 s poll.
+                    // desktops reconcile in-process on lane-store changes with a bounded
+                    // timer for due keep-alive work, avoiding a fresh CLI process per poll.
                     intervalSec: 15,
                     initialDelaySec: 30,
                     command: { type: "hq", args: ["lanes", "reconcile"] },
@@ -246,6 +247,8 @@ function planService(service, ctx) {
                 }),
             ];
         case "search-index":
+            if (ctx.searchIndexOwnedBySyncRunner)
+                return [];
             return [
                 base(service, {
                     kind: "scheduled",

package/dist/lib/daemon/flag-monitor.d.ts

@@ -1,5 +1,7 @@
 export interface BoundedDaemonFlagMonitorOptions {
     read: () => Promise<boolean>;
+    /** Registry default, also used for absent rows and stale reads. */
+    fallback?: boolean;
     now?: () => number;
     onChange?: (enabled: boolean) => void;
     onReadError?: (error: unknown) => void;
@@ -15,7 +17,8 @@ export interface BoundedDaemonFlagMonitor {
 }
 /**
  * Refreshes a long-running daemon's flag independently of incoming requests.
- * A failed read keeps the last successful decision only until its 60s age limit.
+ * A failed read keeps a default-off setting only until its 60s age limit; a
+ * default-on kill switch immediately returns to its registered safe default.
  */
 export declare function createBoundedDaemonFlagMonitor(options: BoundedDaemonFlagMonitorOptions): BoundedDaemonFlagMonitor;
 //# sourceMappingURL=flag-monitor.d.ts.map

package/dist/lib/daemon/flag-monitor.js

@@ -3,11 +3,13 @@ const HQ_ANYWHERE_FLAG_REFRESH_INTERVAL_MS = 30_000;
 const HQ_ANYWHERE_FLAG_MAX_STALENESS_MS = 60_000;
 /**
  * Refreshes a long-running daemon's flag independently of incoming requests.
- * A failed read keeps the last successful decision only until its 60s age limit.
+ * A failed read keeps a default-off setting only until its 60s age limit; a
+ * default-on kill switch immediately returns to its registered safe default.
  */
 export function createBoundedDaemonFlagMonitor(options) {
     const now = options.now ?? (() => performance.now());
-    let value;
+    const fallback = options.fallback ?? false;
+    let value = fallback ? true : undefined;
     let lastSuccessAt;
     let lastAttemptAt;
     let lastReadFailed = false;
@@ -23,7 +25,7 @@ export function createBoundedDaemonFlagMonitor(options) {
     };
     const expireIfStale = () => {
         if (!closed && lastSuccessAt !== undefined && now() - lastSuccessAt >= HQ_ANYWHERE_FLAG_MAX_STALENESS_MS) {
-            publish(false);
+            publish(fallback);
         }
     };
     const refresh = () => {
@@ -44,13 +46,17 @@ export function createBoundedDaemonFlagMonitor(options) {
             // Expire from the elapsed timer itself, not a wall-clock comparison.
             expiryTimer = setTimeout(() => {
                 if (!closed && successVersion === thisSuccessVersion)
-                    publish(false);
+                    publish(fallback);
             }, HQ_ANYWHERE_FLAG_MAX_STALENESS_MS);
             expiryTimer.unref?.();
             return next;
         }).catch((error) => {
             lastReadFailed = true;
             options.onReadError?.(error);
+            if (fallback) {
+                publish(true);
+                return true;
+            }
             expireIfStale();
             return value ?? false;
         }).finally(() => {
@@ -69,7 +75,7 @@ export function createBoundedDaemonFlagMonitor(options) {
             expireIfStale();
             if (lastSuccessAt !== undefined && now() - lastSuccessAt >= HQ_ANYWHERE_FLAG_MAX_STALENESS_MS) {
                 void refresh();
-                return false;
+                return fallback;
             }
             if (value === undefined)
                 return refresh();
@@ -82,7 +88,7 @@ export function createBoundedDaemonFlagMonitor(options) {
             const age = lastSuccessAt === undefined ? null : Math.max(0, now() - lastSuccessAt);
             const fresh = age !== null && age < HQ_ANYWHERE_FLAG_MAX_STALENESS_MS;
             return {
-                enabled: value === true && fresh,
+                enabled: value === true && (fresh || fallback),
                 lastSuccessfulReadAgeMs: age,
                 heldThroughReadError: lastReadFailed && fresh,
             };

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

@@ -17,6 +17,8 @@ export interface DaemonFlagClient {
 }
 export interface ReadDaemonFlagOptions {
     env?: NodeJS.ProcessEnv;
+    /** Registry default for this key; new kill switches use true. */
+    fallback?: boolean;
     /** Controls how this read combines a local person setting with the registry value. */
     localOverrideMode?: "respect" | "off-only" | "ignore";
     createClient?: (options: FlagClientOptions) => DaemonFlagClient;

package/dist/lib/daemon/flag.js

@@ -17,7 +17,7 @@ export async function readDaemonFlag(flagKey, options = {}) {
     const env = options.env ?? process.env;
     if (flagKey === HQ_ANYWHERE_RUNTIME_FLAG && hqAnywhereRuntimeLocallyDisabled(env))
         return false;
-    const fallback = flagKey === HQ_ANYWHERE_RUNTIME_FLAG;
+    const fallback = options.fallback ?? flagKey === HQ_ANYWHERE_RUNTIME_FLAG;
     const override = readLocalOverride(flagKey, env);
     const localOverrideMode = options.localOverrideMode ?? "respect";
     if (override !== null && (localOverrideMode === "respect" || (localOverrideMode === "off-only" && !override)))
@@ -53,8 +53,11 @@ export async function readDaemonFlag(flagKey, options = {}) {
             onError(error);
         }
         const resolution = client.explain(flagKey, { fallback });
-        if (failed && options.throwOnError && !fallback) {
-            throw new Error("hq-flags registry read failed", { cause: reportedError });
+        if (failed) {
+            if (options.throwOnError && !fallback) {
+                throw new Error("hq-flags registry read failed", { cause: reportedError });
+            }
+            return fallback;
         }
         if (resolution.source === "snapshot")
             return resolution.value === true;
@@ -63,8 +66,11 @@ export async function readDaemonFlag(flagKey, options = {}) {
     catch (error) {
         if (!failed)
             onError(error);
-        if (options.throwOnError && failed && !fallback) {
-            throw new Error("hq-flags registry read failed", { cause: reportedError ?? error });
+        if (failed) {
+            if (options.throwOnError && !fallback) {
+                throw new Error("hq-flags registry read failed", { cause: reportedError ?? error });
+            }
+            return fallback;
         }
         return fallback;
     }

package/dist/lib/daemon/hq-child-bootstrap.mjs

@@ -137,9 +137,11 @@ function relaySignal(signal) {
     throw new Error(`Unable to relay ${signal}`);
 }
 async function run() {
-    const [prefix, version, ...args] = process.argv.slice(2);
+    const [prefix, version, ...rawArgs] = process.argv.slice(2);
     if (!prefix || !version)
         throw new Error("The daemon hq bootstrap arguments are invalid");
+    const watchHandoff = rawArgs[0] !== "--handoff-watch=off";
+    const args = watchHandoff ? rawArgs : rawArgs.slice(1);
     const lease = await acquireBootstrapLease(prefix, version);
     const token = randomBytes(16).toString("hex");
     const markerPathFor = (pid) => path.join(lease.directory, `handoff-${pid}-${token}.handoff`);
@@ -170,16 +172,54 @@ async function run() {
         const exit = await new Promise((resolve, reject) => {
             if (!child)
                 return reject(new Error("The HQ CLI child did not start"));
-            child.once("error", reject);
-            child.once("exit", (code, signal) => resolve({ code, signal }));
-            const poll = setInterval(() => {
+            let poll;
+            let watcher;
+            const closeHandoffWatch = () => {
+                if (poll)
+                    clearInterval(poll);
+                poll = undefined;
+                watcher?.close();
+                watcher = undefined;
+            };
+            const releaseOnHandoff = () => {
                 if (!handoffMarker || leaseReleased || !fs.existsSync(handoffMarker))
                     return;
                 fs.rmSync(handoffMarker, { force: true });
                 releaseLease();
-            }, 20);
-            child.once("exit", () => clearInterval(poll));
-            child.once("error", () => clearInterval(poll));
+                closeHandoffWatch();
+            };
+            const startHandoffPolling = () => {
+                if (!poll && !leaseReleased)
+                    poll = setInterval(releaseOnHandoff, 20);
+            };
+            child.once("error", reject);
+            child.once("exit", (code, signal) => resolve({ code, signal }));
+            child.once("exit", closeHandoffWatch);
+            child.once("error", closeHandoffWatch);
+            if (watchHandoff && handoffMarker) {
+                try {
+                    watcher = fs.watch(lease.directory, (_event, filename) => {
+                        if (filename === null || filename.toString() === path.basename(handoffMarker))
+                            releaseOnHandoff();
+                    });
+                    watcher.on("error", (error) => {
+                        process.stderr.write(`hq daemon child bootstrap handoff watch failed (${error.code ?? error.name}); using the recovery poll\n`);
+                        watcher?.close();
+                        watcher = undefined;
+                        startHandoffPolling();
+                    });
+                    // Close the create-before-watch race after the watcher is attached.
+                    releaseOnHandoff();
+                }
+                catch (error) {
+                    process.stderr.write(`hq daemon child bootstrap handoff watch unavailable (${error.code ?? "UnknownError"}); using the recovery poll\n`);
+                    startHandoffPolling();
+                    releaseOnHandoff();
+                }
+            }
+            else {
+                startHandoffPolling();
+            }
         });
         if (!leaseReleased)
             releaseLease();

package/dist/lib/daemon/kill-switch-flags.d.ts

@@ -0,0 +1,5 @@
+export declare const DAEMON_CHILD_BOOTSTRAP_HANDOFF_WATCH_FLAG = "daemon.child-bootstrap-handoff-watch";
+export declare const DAEMON_LANES_RECONCILE_FILE_WATCH_FLAG = "daemon.lanes-reconcile-file-watch";
+export declare const DAEMON_SYNC_PROCESS_SCAN_ON_MISSING_FLAG = "daemon.sync-process-scan-on-missing";
+export declare const DAEMON_SEARCH_INDEX_RUNNER_OWNS_INDEX_FLAG = "daemon.search-index-runner-owns-index";
+//# sourceMappingURL=kill-switch-flags.d.ts.map

package/dist/lib/daemon/kill-switch-flags.js

@@ -0,0 +1,5 @@
+export const DAEMON_CHILD_BOOTSTRAP_HANDOFF_WATCH_FLAG = "daemon.child-bootstrap-handoff-watch";
+export const DAEMON_LANES_RECONCILE_FILE_WATCH_FLAG = "daemon.lanes-reconcile-file-watch";
+export const DAEMON_SYNC_PROCESS_SCAN_ON_MISSING_FLAG = "daemon.sync-process-scan-on-missing";
+export const DAEMON_SEARCH_INDEX_RUNNER_OWNS_INDEX_FLAG = "daemon.search-index-runner-owns-index";
+//# sourceMappingURL=kill-switch-flags.js.map

package/dist/lib/daemon/lanes-reconcile-loader.d.ts

@@ -0,0 +1,7 @@
+export interface DaemonLanesReconcileRegistrationOptions {
+    hqRoot: () => string;
+    env: NodeJS.ProcessEnv;
+}
+/** Load the lazy lanes command root only when the daemon needs its reconciler. */
+export declare function ensureDaemonLanesReconcileHandler(options: DaemonLanesReconcileRegistrationOptions): Promise<void>;
+//# sourceMappingURL=lanes-reconcile-loader.d.ts.map

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

@@ -0,0 +1,24 @@
+import { daemonLanesReconcileHandler } from "../lanes/daemon-reconcile.js";
+async function registerFromLanesCommand(options) {
+    const [{ Command }, { registerLanesCommand }] = await Promise.all([
+        import("commander"),
+        import("../../commands/lanes.js"),
+    ]);
+    const env = { ...options.env };
+    delete env.HQ_ROOT;
+    registerLanesCommand(new Command(), {
+        hqRoot: options.hqRoot,
+        cwd: options.hqRoot,
+        env,
+    });
+}
+/** Load the lazy lanes command root only when the daemon needs its reconciler. */
+export async function ensureDaemonLanesReconcileHandler(options) {
+    if (daemonLanesReconcileHandler())
+        return;
+    await registerFromLanesCommand(options);
+    if (!daemonLanesReconcileHandler()) {
+        throw new Error("lanes command did not register its daemon reconcile handler");
+    }
+}
+//# sourceMappingURL=lanes-reconcile-loader.js.map

package/dist/lib/daemon/lanes-reconcile-watcher.d.ts

@@ -0,0 +1,17 @@
+import * as fs from "node:fs";
+type Watcher = Pick<fs.FSWatcher, "close">;
+export interface LanesReconcileWatcher {
+    close(): void;
+}
+/** Reconcile at startup, on lane-store changes, and on a bounded in-process timer. */
+export declare function createLanesReconcileWatcher(options: {
+    directories: readonly string[];
+    reconcile: () => Promise<void>;
+    debounceMs?: number;
+    intervalMs?: number;
+    watch?: (directory: string, listener: (event: string, filename: string | Buffer | null) => void) => Watcher;
+    onError?: (error: unknown) => void;
+    onWatchError?: (error: unknown) => void;
+}): LanesReconcileWatcher;
+export {};
+//# sourceMappingURL=lanes-reconcile-watcher.d.ts.map