@indigoai-us/hq-cli 5.345.128 → 5.345.130

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;

package/dist/lib/daemon/run.js

@@ -24,7 +24,12 @@ import { CLAUDE_RUNNER_SCRIPT, CODEX_RUNNER_SCRIPT, enabledServices, planUnits }
 import { effectiveSyncOwner, readDaemonConfig } from "./config.js";
 import { assertPersonalServiceSessionCapability, readRemoteControlPoolsConfig, remoteControlPoolSecretsEnv, } from "./remote-control-pools.js";
 import { loadLanesConfig } from "../lanes/config.js";
+import { daemonLanesReconcileHandler } from "../lanes/daemon-reconcile.js";
+import { ensureDaemonLanesReconcileHandler } from "./lanes-reconcile-loader.js";
 import { SUPERVISOR_HANDOFF_FLAG, readDaemonFlag } from "./flag.js";
+import { createBoundedDaemonFlagMonitor } from "./flag-monitor.js";
+import { DAEMON_CHILD_BOOTSTRAP_HANDOFF_WATCH_FLAG, DAEMON_LANES_RECONCILE_FILE_WATCH_FLAG, DAEMON_SEARCH_INDEX_RUNNER_OWNS_INDEX_FLAG, DAEMON_SYNC_PROCESS_SCAN_ON_MISSING_FLAG, } from "./kill-switch-flags.js";
+import { createLanesReconcileWatcher } from "./lanes-reconcile-watcher.js";
 import { findLegacyUnits, legacyMeshUnitsToRetire, legacyOwnerLookup } from "./legacy.js";
 import { readLegacySyncEnv } from "./legacy-sync-env.js";
 import { acquireDaemonLock, isProcessAlive, processCommandLine, releaseDaemonLock } from "./lock.js";
@@ -216,11 +221,14 @@ export function backgroundQosCommand(command, backgroundQos, platform = process.
         return command;
     return [DARWIN_TASKPOLICY, ["-b", command[0], ...command[1]]];
 }
-export function daemonHqChildCommand(nodeBinary, hqBinary, args, bootstrapPath, packagePrefix) {
+export function daemonHqChildCommand(nodeBinary, hqBinary, args, bootstrapPath, packagePrefix, handoffWatchEnabled = true) {
     return bootstrapPath && packagePrefix
-        ? [nodeBinary, [bootstrapPath, packagePrefix, CLI_VERSION, ...args]]
+        ? [nodeBinary, [bootstrapPath, packagePrefix, CLI_VERSION, ...(handoffWatchEnabled ? [] : ["--handoff-watch=off"]), ...args]]
         : [nodeBinary, [hqBinary, ...args]];
 }
+export function daemonSyncUnitIsPresent(units) {
+    return units.some((unit) => unit.id === "sync");
+}
 export function resolveSyncRunnerPath() {
     try {
         const require = createRequire(import.meta.url);
@@ -674,11 +682,104 @@ export async function runDaemon(opts) {
     };
     const daemonSyncRunnerPids = new Set();
     let supervisor = null;
+    const killSwitchMonitor = (flagKey) => createBoundedDaemonFlagMonitor({
+        fallback: true,
+        read: () => readDaemonFlag(flagKey, {
+            env,
+            fallback: true,
+            localOverrideMode: "ignore",
+            throwOnError: true,
+        }),
+        onReadError: (error) => log("warn", `could not read ${flagKey}; keeping its default-on behavior (${error instanceof Error ? error.name : "UnknownError"})`),
+    });
+    const childBootstrapHandoffWatchFlag = killSwitchMonitor(DAEMON_CHILD_BOOTSTRAP_HANDOFF_WATCH_FLAG);
+    const lanesReconcileFileWatchFlag = killSwitchMonitor(DAEMON_LANES_RECONCILE_FILE_WATCH_FLAG);
+    const searchIndexRunnerOwnsIndexFlag = killSwitchMonitor(DAEMON_SEARCH_INDEX_RUNNER_OWNS_INDEX_FLAG);
+    const syncProcessScanOnMissingFlag = killSwitchMonitor(DAEMON_SYNC_PROCESS_SCAN_ON_MISSING_FLAG);
+    let laneReconcileWatcher = null;
+    let laneReconcileWatcherRoot = null;
+    let laneReconcileWatchFailedRoot = null;
+    let laneReconcileHandlerLoadInFlight = false;
+    let laneReconcileHandlerLoadFailed = false;
+    const loadLaneReconcileHandler = (initialRoot) => {
+        if (daemonLanesReconcileHandler() || laneReconcileHandlerLoadInFlight || laneReconcileHandlerLoadFailed)
+            return;
+        laneReconcileHandlerLoadInFlight = true;
+        const resolveRoot = () => {
+            const configured = readDaemonConfig(paths.configPath).hqRoot ?? (env.HQ_ROOT?.trim() || undefined);
+            return configured && fs.existsSync(configured) ? configured : initialRoot;
+        };
+        void ensureDaemonLanesReconcileHandler({ hqRoot: resolveRoot, env }).then(() => {
+            supervisor?.reconcile();
+        }).catch((error) => {
+            laneReconcileHandlerLoadFailed = true;
+            log("error", `could not load the in-process lanes reconciler; retaining the scheduled unit (${error instanceof Error ? error.message : String(error)})`);
+        }).finally(() => {
+            laneReconcileHandlerLoadInFlight = false;
+        });
+    };
+    const closeRuntimeWatchers = () => {
+        laneReconcileWatcher?.close();
+        laneReconcileWatcher = null;
+        laneReconcileWatcherRoot = null;
+        childBootstrapHandoffWatchFlag.close();
+        lanesReconcileFileWatchFlag.close();
+        searchIndexRunnerOwnsIndexFlag.close();
+        syncProcessScanOnMissingFlag.close();
+    };
     const plan = () => {
         const config = readDaemonConfig(paths.configPath);
         const legacy = legacyUnits();
         const configured = config.hqRoot ?? (env.HQ_ROOT?.trim() || undefined);
         const hqRoot = configured && fs.existsSync(configured) ? configured : undefined;
+        if (laneReconcileWatcherRoot && laneReconcileWatcherRoot !== hqRoot) {
+            laneReconcileWatcher?.close();
+            laneReconcileWatcher = null;
+            laneReconcileWatcherRoot = null;
+            laneReconcileWatchFailedRoot = null;
+        }
+        const lanesReconcileEnabled = lanesReconcileFileWatchFlag.status().enabled;
+        if (!lanesReconcileEnabled) {
+            laneReconcileWatcher?.close();
+            laneReconcileWatcher = null;
+            laneReconcileWatcherRoot = null;
+            laneReconcileWatchFailedRoot = null;
+        }
+        else if (hqRoot) {
+            if (!daemonLanesReconcileHandler())
+                loadLaneReconcileHandler(hqRoot);
+            const laneReconcileHandler = daemonLanesReconcileHandler();
+            if (laneReconcileHandler && laneReconcileWatcherRoot !== hqRoot && laneReconcileWatchFailedRoot !== hqRoot) {
+                laneReconcileWatcher?.close();
+                laneReconcileWatcher = null;
+                laneReconcileWatcherRoot = null;
+                const laneStore = path.join(hqRoot, "workspace", "lanes");
+                const laneDirectories = [path.join(laneStore, "lanes"), path.join(laneStore, "questions")];
+                try {
+                    for (const directory of laneDirectories)
+                        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+                    laneReconcileWatcher = createLanesReconcileWatcher({
+                        directories: laneDirectories,
+                        reconcile: laneReconcileHandler,
+                        intervalMs: 15_000,
+                        onError: (error) => log("error", `in-process lanes reconcile failed: ${error instanceof Error ? error.message : String(error)}`),
+                        onWatchError: (error) => {
+                            laneReconcileWatcher = null;
+                            laneReconcileWatcherRoot = null;
+                            laneReconcileWatchFailedRoot = hqRoot;
+                            log("error", `lane-store watch failed; restoring the scheduled reconcile unit (${error instanceof Error ? error.message : String(error)})`);
+                            supervisor?.reconcile();
+                        },
+                    });
+                    laneReconcileWatcherRoot = hqRoot;
+                    laneReconcileWatchFailedRoot = null;
+                }
+                catch (error) {
+                    laneReconcileWatchFailedRoot = hqRoot;
+                    log("error", `could not watch the lane store; retaining the scheduled reconcile unit (${error instanceof Error ? error.message : String(error)})`);
+                }
+            }
+        }
         let remoteControlPools = { version: 1, pools: [] };
         let remoteControlPoolsError;
         try {
@@ -810,21 +911,30 @@ export async function runDaemon(opts) {
             !config.syncPaused &&
             hqRoot &&
             isSignedIn) {
-            const processList = listSyncRunnerProcesses(platform);
-            if (!processList.ok) {
-                syncRunnerProcesses = null;
-                log("warn", `${processList.error}; sync will wait before taking ownership`);
-            }
-            else {
-                syncRunnerProcesses = processList.processes;
-                try {
-                    syncRunnerOwnerPid = readWatchRunnerOwnerStatus(watchRunnerOwnerStatusPath(hqRoot, home, env))?.pid ?? null;
+            const syncUnitPresent = daemonSyncUnitIsPresent(supervisor?.state().units ?? []);
+            if (!syncProcessScanOnMissingFlag.status().enabled || !syncUnitPresent) {
+                const processList = listSyncRunnerProcesses(platform);
+                if (!processList.ok) {
+                    syncRunnerProcesses = null;
+                    log("warn", `${processList.error}; sync will wait before taking ownership`);
                 }
-                catch (error) {
-                    log("warn", `could not verify the sync watch-owner status: ${error instanceof Error ? error.message : String(error)}`);
+                else {
+                    syncRunnerProcesses = processList.processes;
+                    try {
+                        syncRunnerOwnerPid = readWatchRunnerOwnerStatus(watchRunnerOwnerStatusPath(hqRoot, home, env))?.pid ?? null;
+                    }
+                    catch (error) {
+                        log("warn", `could not verify the sync watch-owner status: ${error instanceof Error ? error.message : String(error)}`);
+                    }
                 }
             }
         }
+        const appManagesSync = desktopAppManagesSync({
+            machineType,
+            host: opts.host,
+            legacy,
+            appRunning: () => desktopAppRunning(platform),
+        });
         const plans = planUnits(services, {
             machineType,
             platform,
@@ -840,15 +950,15 @@ export async function runDaemon(opts) {
             kitConfigured: fs.existsSync(agentKitPaths(home, env).kitConfigPath),
             syncPaused: config.syncPaused === true,
             syncOwner,
-            desktopAppManagesSync: desktopAppManagesSync({
-                machineType,
-                host: opts.host,
-                legacy,
-                appRunning: () => desktopAppRunning(platform),
-            }),
+            desktopAppManagesSync: appManagesSync,
             syncRunnerProcesses,
             syncRunnerOwnerPid,
             daemonSyncRunnerPids,
+            lanesReconcileInProcess: Boolean(laneReconcileWatcher && laneReconcileWatcherRoot === hqRoot),
+            searchIndexOwnedBySyncRunner: searchIndexRunnerOwnsIndexFlag.status().enabled &&
+                hqCloud !== null && !hqCloudVersionOlder(hqCloud.version, "6.18.75") &&
+                syncOwner === "daemon" && services.includes("sync") && !config.syncPaused &&
+                !appManagesSync && Boolean(hqRoot && isSignedIn && runners.syncRunner),
             syncHeartbeatTimeoutMs: syncHeartbeatTimeoutMs(env),
             bots: listLocalBots(),
             legacyOwner: legacyOwnerLookup(legacy),
@@ -884,7 +994,7 @@ export async function runDaemon(opts) {
         if (!command || command.type === "internal")
             throw new Error(`${unit.id} has no process to start`);
         let [file, args] = command.type === "hq"
-            ? daemonHqChildCommand(opts.nodeBinary, opts.hqBinary, command.args, stagedHqChildBootstrap?.bootstrapPath ?? null, cliPackagePrefix)
+            ? daemonHqChildCommand(opts.nodeBinary, opts.hqBinary, command.args, stagedHqChildBootstrap?.bootstrapPath ?? null, cliPackagePrefix, childBootstrapHandoffWatchFlag.status().enabled)
             : command.type === "node"
                 ? [opts.nodeBinary, [command.script, ...command.args]]
                 : [command.file, command.args];
@@ -1112,6 +1222,7 @@ export async function runDaemon(opts) {
             stopping = true;
             log("info", `${why}; stopping services`);
             closeHqd();
+            closeRuntimeWatchers();
             // Keep shutdown bounded, but let a stopping sync runner reach its persist deadline.
             const cap = createShutdownCap();
             extendSyncShutdownCap = cap.extendForSyncRunnerPersist;
@@ -1139,6 +1250,7 @@ export async function runDaemon(opts) {
                 return;
             stopping = true;
             closeHqd();
+            closeRuntimeWatchers();
             const released = supervisor.release();
             // What these readers have not read stays in the FIFO for the next daemon.
             for (const tail of protocolTails)
@@ -1207,6 +1319,7 @@ export async function runDaemon(opts) {
         catch (err) {
             log("error", `supervisor failed to start: ${err.message}`);
             closeHqd();
+            closeRuntimeWatchers();
             releaseDaemonLock(paths.lockPath);
             resolve(1);
         }

package/dist/lib/doctor/json-output.d.ts

@@ -106,9 +106,10 @@ export interface BuildDoctorJsonInput {
     clientHealthCheckStatusEnabledCheckIds?: ReadonlySet<string>;
     /**
      * JSON consumed by the SessionStart health hook (`--client-health-report`).
-     * Ordinary hq-core upgrade WARNs and leftover `sync.journal.personal` WARNs
-     * are omitted from every JSON document (`--json` and `--client-health-report`),
-     * including `summary` tallies: `--fix` cannot apply a release, and the leftover
+     * Ordinary hq-core upgrade WARNs, leftover `sync.journal.personal` WARNs, and
+     * leftover `sync.manifest.personal` WARNs are omitted from every JSON document
+     * (`--json` and `--client-health-report`), including `summary` tallies: `--fix`
+     * cannot apply a release or upload personal manifests, and the leftover
      * personal shard is not a live sync target. Company journals this `--fix`
      * pass did not try to refresh are omitted the same way: the repair cap leaves
      * them for a later session, and older hooks that only call `hq doctor --json`
@@ -141,6 +142,17 @@ export declare function isLeftoverPersonalJournalWarn(result: {
     checkId: string;
     status: DoctorStatus;
 }): boolean;
+/**
+ * True when doctor still WARNs on a stale personal sync manifest.
+ * `--fix` does not upload manifests (network, auth, vault write), so the row
+ * stays WARN after a repair pass. JSON omits the WARN so `--json` health hooks
+ * do not file it as a failed repair. FAIL stays visible, and human
+ * `hq doctor` still prints the WARN.
+ */
+export declare function isLeftoverPersonalManifestWarn(result: {
+    checkId: string;
+    status: DoctorStatus;
+}): boolean;
 /** Assemble the machine-readable document from a completed run. */
 export declare function buildDoctorJson(input: BuildDoctorJsonInput): DoctorJsonDocument;
 /** Serialise the document as pretty-printed JSON with a trailing newline. */

package/dist/lib/doctor/json-output.js

@@ -50,8 +50,20 @@ export function isOrdinaryCoreUpdateWarn(result) {
 export function isLeftoverPersonalJournalWarn(result) {
     return result.checkId === "sync.journal.personal" && result.status === "WARN";
 }
+/**
+ * True when doctor still WARNs on a stale personal sync manifest.
+ * `--fix` does not upload manifests (network, auth, vault write), so the row
+ * stays WARN after a repair pass. JSON omits the WARN so `--json` health hooks
+ * do not file it as a failed repair. FAIL stays visible, and human
+ * `hq doctor` still prints the WARN.
+ */
+export function isLeftoverPersonalManifestWarn(result) {
+    return result.checkId === "sync.manifest.personal" && result.status === "WARN";
+}
 function omitFromDoctorJson(result) {
-    return isOrdinaryCoreUpdateWarn(result) || isLeftoverPersonalJournalWarn(result);
+    return (isOrdinaryCoreUpdateWarn(result) ||
+        isLeftoverPersonalJournalWarn(result) ||
+        isLeftoverPersonalManifestWarn(result));
 }
 /** Tally the results that actually ship in the JSON document. */
 function summarizeJsonResults(results) {

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

@@ -9,10 +9,14 @@
 import * as fs from "node:fs";
 import { type AccountConfig, type LaneProvider, type LanesConfig, type RunawaySearchGuardConfig, type LivenessWindows, type ProviderConfig } from "./types.js";
 export declare const LANES_CONFIG_REL: string;
-export declare const DEFAULT_MAX_QUEUED = 3;
-export declare const DEFAULT_CPU_BUSY_PAUSE = 0.85;
-export declare const DEFAULT_CPU_BUSY_RESUME = 0.7;
-export declare const DEFAULT_MIN_AVAILABLE_MEM_MB = 1024;
+/**
+ * Owner directive 2026-10-14: no default lane caps or CPU/memory admission
+ * gates. A provider has no running or queued limit unless the operator sets
+ * `max_running` / `max_queued` explicitly; this value stands for "no limit"
+ * and stays a finite integer so it survives JSON output.
+ */
+export declare const UNLIMITED_LANES: number;
+export declare const DEFAULT_MAX_QUEUED: number;
 /**
  * Owner directive 2026-09-22: "if it's been an hour since last msg, always
  * run compact". Override per provider with `compact_after_ms`.