@indigoai-us/hq-cli 5.345.128 → 5.345.129

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/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

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

@@ -0,0 +1,80 @@
+import * as fs from "node:fs";
+/** Reconcile at startup, on lane-store changes, and on a bounded in-process timer. */
+export function createLanesReconcileWatcher(options) {
+    const debounceMs = options.debounceMs ?? 250;
+    const intervalMs = options.intervalMs ?? 60_000;
+    const watch = options.watch ?? ((directory, listener) => fs.watch(directory, listener));
+    const watchers = [];
+    let timer;
+    let running = false;
+    let rerun = false;
+    let closed = false;
+    const run = async () => {
+        if (closed)
+            return;
+        if (running) {
+            rerun = true;
+            return;
+        }
+        running = true;
+        try {
+            await options.reconcile();
+        }
+        catch (error) {
+            options.onError?.(error);
+        }
+        finally {
+            running = false;
+            if (rerun && !closed) {
+                rerun = false;
+                schedule();
+            }
+            else {
+                schedule(intervalMs);
+            }
+        }
+    };
+    const schedule = (delayMs = debounceMs) => {
+        if (closed)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            void run();
+        }, delayMs);
+    };
+    const watchFailure = (error) => {
+        options.onWatchError?.(error);
+        close();
+    };
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+        for (const watcher of watchers.splice(0))
+            watcher.close();
+    };
+    try {
+        for (const directory of options.directories) {
+            const watcher = watch(directory, (_event, filename) => {
+                if (filename !== null && !filename.toString().endsWith(".json"))
+                    return;
+                schedule();
+            });
+            const eventSource = watcher;
+            eventSource.on?.("error", watchFailure);
+            watchers.push(watcher);
+        }
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+    schedule(0);
+    return { close };
+}
+//# sourceMappingURL=lanes-reconcile-watcher.js.map

package/dist/lib/daemon/remote-control.d.ts

@@ -11,11 +11,12 @@
  *   backoff (replacing the runner's `while true` loop and its watchdogs);
  * - the daemon stops the host -> the host kills the session and exits 0;
  * - a new version of the tool is installed (the updater, or the tool's own
- *   auto-updater) -> once the session has been quiet for 10 minutes, or after
- *   2 hours at the latest, the host kills the session and exits 0, and the
- *   daemon starts it again on the new version. Reinstalling the same version
- *   (a long-running Claude session's auto-updater does that every few
- *   minutes) and hq-cli releases leave the session alone.
+ *   auto-updater) -> standalone hosts restart after 10 quiet minutes or 2
+ *   hours at the latest. Shared Remote Control pools never restart solely for
+ *   an update, because their terminal activity cannot establish that all
+ *   connected client sessions are idle. A failed pool host is still restarted
+ *   by the daemon. Reinstalling the same version and hq-cli releases leave
+ *   running sessions alone.
  *
  * The tmux server is a private socket (`-L hq-daemon`), so it never touches a
  * user's own tmux sessions.
@@ -67,6 +68,8 @@ export interface RemoteControlHostDeps {
     label: string;
     /** Identity of the tool's binary on disk; a change means it was updated. Null when it cannot be read. */
     binaryFingerprint: () => string | null;
+    /** Shared pools must keep their clients connected across tool updates. */
+    restartOnToolUpdate?: boolean;
     now: () => number;
     run: RunCommand;
     sleep: (ms: number) => Promise<void>;

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

@@ -11,11 +11,12 @@
  *   backoff (replacing the runner's `while true` loop and its watchdogs);
  * - the daemon stops the host -> the host kills the session and exits 0;
  * - a new version of the tool is installed (the updater, or the tool's own
- *   auto-updater) -> once the session has been quiet for 10 minutes, or after
- *   2 hours at the latest, the host kills the session and exits 0, and the
- *   daemon starts it again on the new version. Reinstalling the same version
- *   (a long-running Claude session's auto-updater does that every few
- *   minutes) and hq-cli releases leave the session alone.
+ *   auto-updater) -> standalone hosts restart after 10 quiet minutes or 2
+ *   hours at the latest. Shared Remote Control pools never restart solely for
+ *   an update, because their terminal activity cannot establish that all
+ *   connected client sessions are idle. A failed pool host is still restarted
+ *   by the daemon. Reinstalling the same version and hq-cli releases leave
+ *   running sessions alone.
  *
  * The tmux server is a private socket (`-L hq-daemon`), so it never touches a
  * user's own tmux sessions.
@@ -317,7 +318,7 @@ export async function runRemoteControlHost(deps) {
         return 1;
     }
     deps.log(`${deps.label} started in ${JSON.stringify(deps.cwd)} (creator pid ${invokerPid})`);
-    const startedWith = deps.binaryFingerprint();
+    const startedWith = deps.restartOnToolUpdate === false ? null : deps.binaryFingerprint();
     let updatedAt = null;
     for (;;) {
         if (deps.signal.aborted) {
@@ -338,7 +339,7 @@ export async function runRemoteControlHost(deps) {
             return 1;
         }
         const now = deps.now();
-        if (updatedAt === null) {
+        if (deps.restartOnToolUpdate !== false && updatedAt === null) {
             const current = deps.binaryFingerprint();
             if (startedWith !== null && current !== null && current !== startedWith) {
                 updatedAt = now;

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

@@ -86,7 +86,10 @@ export declare function daemonPlanCanReleasePackageUseLease(plans: readonly Unit
  * PRIO_DARWIN_BG is inherited by everything the unit spawns (qmd included).
  */
 export declare function backgroundQosCommand(command: [string, string[]], backgroundQos: boolean, platform?: NodeJS.Platform | string, exists?: (file: string) => boolean): [string, string[]];
-export declare function daemonHqChildCommand(nodeBinary: string, hqBinary: string, args: readonly string[], bootstrapPath: string | null, packagePrefix: string | null): [string, string[]];
+export declare function daemonHqChildCommand(nodeBinary: string, hqBinary: string, args: readonly string[], bootstrapPath: string | null, packagePrefix: string | null, handoffWatchEnabled?: boolean): [string, string[]];
+export declare function daemonSyncUnitIsPresent(units: readonly {
+    id: string;
+}[]): boolean;
 export declare function resolveSyncRunnerPath(): string | null;
 /** The hosted desktop app uses this env value when planning daemon services. */
 export declare function daemonInstantSyncEnabled(env: NodeJS.ProcessEnv, configured?: boolean): boolean;