@indigoai-us/hq-cli 5.345.128 → 5.345.129

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/daemon-reconcile.d.ts

@@ -0,0 +1,3 @@
+export declare function registerDaemonLanesReconcileHandler(handler: () => Promise<void>): void;
+export declare function daemonLanesReconcileHandler(): (() => Promise<void>) | null;
+//# sourceMappingURL=daemon-reconcile.d.ts.map

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

@@ -0,0 +1,8 @@
+let daemonReconcileHandler = null;
+export function registerDaemonLanesReconcileHandler(handler) {
+    daemonReconcileHandler = handler;
+}
+export function daemonLanesReconcileHandler() {
+    return daemonReconcileHandler;
+}
+//# sourceMappingURL=daemon-reconcile.js.map

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

@@ -0,0 +1,10 @@
+export interface ReconcilePassResult {
+    ok: boolean;
+    errors?: readonly {
+        code?: string;
+        message: string;
+    }[];
+}
+/** Preserve CLI exit semantics while letting the daemon report failures to its watcher. */
+export declare function finishReconcilePass(summary: ReconcilePassResult, mode: "cli" | "daemon", exit?: (code: number) => void): void;
+//# sourceMappingURL=reconcile-result.d.ts.map

package/dist/lib/lanes/reconcile-result.js

@@ -0,0 +1,11 @@
+/** Preserve CLI exit semantics while letting the daemon report failures to its watcher. */
+export function finishReconcilePass(summary, mode, exit = (code) => process.exit(code)) {
+    if (summary.ok)
+        return;
+    if (mode === "daemon") {
+        const detail = summary.errors?.map((error) => `${error.code ?? "unknown"}: ${error.message}`).join("; ") ?? "unknown reconcile error";
+        throw new Error(`In-process lanes reconcile failed: ${detail}`);
+    }
+    exit(1);
+}
+//# sourceMappingURL=reconcile-result.js.map

package/dist/lib/mesh/live/daemon/work-subscribe.d.ts

@@ -14,7 +14,7 @@ export interface WorkCacheMqtt extends MeshMqttEventClient {
 export interface WorkCacheSubscriber {
     stop: () => Promise<void>;
 }
-export declare const AGENT_INBOX_PUSH_STATE_BASENAME = "agent-inbox-push.json";
+export { AGENT_INBOX_PUSH_STATE_BASENAME } from "../paths.js";
 export declare function startWorkCacheSubscriber(opts: {
     meshRoot: string;
     fetchCredentials?: PersonalCredentialsFetcher;

package/dist/lib/mesh/live/daemon/work-subscribe.js

@@ -8,7 +8,8 @@ import { createPersonalRealtimeFetcher, } from "./credentials.js";
 import { presignIotWssUrl } from "./presign.js";
 import { applyProjectViewPush, parseProjectViewPush } from "./live-cache.js";
 import { backoffDelayMs, RECONNECT_MIN_DELAY_MS } from "./presence.js";
-export const AGENT_INBOX_PUSH_STATE_BASENAME = "agent-inbox-push.json";
+import { AGENT_INBOX_PUSH_STATE_BASENAME } from "../paths.js";
+export { AGENT_INBOX_PUSH_STATE_BASENAME } from "../paths.js";
 const INBOX_PUSH_HEARTBEAT_MS = 5_000;
 function readInboxWakeSequence(meshRoot, onInfo) {
     const target = path.join(meshRoot, AGENT_INBOX_PUSH_STATE_BASENAME);
@@ -78,6 +79,7 @@ export async function startWorkCacheSubscriber(opts) {
     let heartbeatTimer = null;
     let generation = 0;
     let inboxSubscribed = false;
+    let inboxAgentUid;
     // Carry the sequence forward from the last state marker so a daemon restart
     // cannot reuse a value the watcher has already consumed.
     let wakeSequence = readInboxWakeSequence(opts.meshRoot, opts.onInfo);
@@ -92,6 +94,7 @@ export async function startWorkCacheSubscriber(opts) {
                 connected,
                 heartbeatAtMs: now().getTime(),
                 wakeSequence,
+                ...(connected && inboxAgentUid ? { agentUid: inboxAgentUid } : {}),
             });
         }
         catch (error) {
@@ -115,6 +118,7 @@ export async function startWorkCacheSubscriber(opts) {
         if (stopped)
             return;
         inboxSubscribed = false;
+        inboxAgentUid = undefined;
         clearInboxHeartbeat();
         persistInboxState(false);
         const gen = ++generation;
@@ -133,6 +137,7 @@ export async function startWorkCacheSubscriber(opts) {
             bundle.topics.inbox === `hq/${bundle.actorUid}/inbox`
             ? bundle.topics.inbox
             : undefined;
+        inboxAgentUid = inboxTopic ? bundle.actorUid : undefined;
         if (!topic && !inboxTopic) {
             opts.onInfo?.("work cache subscribe skipped: credentials have no supported topic");
             return;
@@ -175,6 +180,7 @@ export async function startWorkCacheSubscriber(opts) {
                         return;
                     if (err) {
                         inboxSubscribed = false;
+                        inboxAgentUid = undefined;
                         clearInboxHeartbeat();
                         persistInboxState(false);
                         opts.onInfo?.("agent inbox push subscribe failed");
@@ -212,6 +218,7 @@ export async function startWorkCacheSubscriber(opts) {
             if (stopped || gen !== generation)
                 return;
             inboxSubscribed = false;
+            inboxAgentUid = undefined;
             clearInboxHeartbeat();
             persistInboxState(false);
             schedule();

package/dist/lib/mesh/live/paths.d.ts

@@ -2,6 +2,8 @@
  * Local Work Mesh Live paths under ~/.hq/work-mesh/.
  * Injectable root for tests (never touch the real HOME in unit tests).
  */
+/** Content-free sequence file written by the mesh MQTT inbox subscriber. */
+export declare const AGENT_INBOX_PUSH_STATE_BASENAME = "agent-inbox-push.json";
 export declare function workMeshRoot(home?: string, env?: NodeJS.ProcessEnv): string;
 export declare function workMeshSpoolPath(root?: string): string;
 export declare function workMeshHeldPath(root?: string): string;

package/dist/lib/mesh/live/paths.js

@@ -5,6 +5,8 @@
 import * as os from "node:os";
 import * as path from "node:path";
 const WORK_MESH_DIRNAME = "work-mesh";
+/** Content-free sequence file written by the mesh MQTT inbox subscriber. */
+export const AGENT_INBOX_PUSH_STATE_BASENAME = "agent-inbox-push.json";
 export function workMeshRoot(home = os.homedir(), env = process.env) {
     const override = env.HQ_WORK_MESH_ROOT?.trim();
     if (override)

package/dist/lib/mesh/story-status.d.ts

@@ -5,8 +5,8 @@ export type BoardStoryStatus = (typeof BOARD_STORY_STATUSES)[number];
  * need attention, while `dropped` is terminal; the Board has only one terminal
  * column (`done`).
  */
-export declare const LEDGER_STATES: readonly ["todo", "in_progress", "review", "waiting", "blocked", "done", "dropped"];
-export declare const ACCEPTED_LEDGER_STATES: readonly ["todo", "in_progress", "review", "waiting", "blocked", "done", "dropped", "in_review", "verification"];
+export declare const LEDGER_STATES: readonly ["todo", "queued", "in_progress", "review", "waiting", "blocked", "done", "dropped"];
+export declare const ACCEPTED_LEDGER_STATES: readonly ["todo", "queued", "in_progress", "review", "waiting", "blocked", "done", "dropped", "in_review", "verification"];
 export declare class UnknownProjectStoryStateError extends Error {
     readonly source: string;
     readonly storyId: string;

package/dist/lib/mesh/story-status.js

@@ -6,10 +6,11 @@ const boardStoryStatusSet = new Set(BOARD_STORY_STATUSES);
  * column (`done`).
  */
 export const LEDGER_STATES = [
-    "todo", "in_progress", "review", "waiting", "blocked", "done", "dropped",
+    "todo", "queued", "in_progress", "review", "waiting", "blocked", "done", "dropped",
 ];
 const LEDGER_STATE_TO_BOARD_STATUS = {
     todo: "queued",
+    queued: "queued",
     in_progress: "in_progress",
     review: "review",
     // The four-column Board cannot represent waiting separately. Preserve the

package/dist/utils/resident-package-preload.js

@@ -53,12 +53,15 @@ export const RESIDENT_PACKAGE_MODULES = {
         "../lib/plan-limit-nag.js",
         "../utils/plan-gate-error.js",
         "../lib/daemon/mcp-oauth.js",
+        "../commands/lanes.js",
+        "commander",
         "@modelcontextprotocol/sdk/client/index.js",
         "@modelcontextprotocol/sdk/client/streamableHttp.js",
         "../utils/staged-npm-install.js",
         "open",
         "../lib/first-sync-next-step.js",
         "@indigoai-us/hq-cloud",
+        "../lib/lanes/reconcile.js",
     ],
     "daemon-logs-follow": [],
     "mesh-daemon": ["../sentry.js", "../lib/doctor/client-health-reason-codes-flag.js", "@indigoai-us/hq-flags-client", "../lib/plan-limit-nag.js", "../utils/plan-gate-error.js", "open", "../utils/cognito-session.js", "../lib/first-sync-next-step.js", "@indigoai-us/hq-cloud"],
@@ -220,12 +223,15 @@ const LOADERS = {
         () => import("../lib/plan-limit-nag.js"),
         () => import("../utils/plan-gate-error.js"),
         () => import("../lib/daemon/mcp-oauth.js"),
+        () => import("../commands/lanes.js"),
+        () => import("commander"),
         () => import("@modelcontextprotocol/sdk/client/index.js"),
         () => import("@modelcontextprotocol/sdk/client/streamableHttp.js"),
         () => import("../utils/staged-npm-install.js"),
         () => import("open"),
         () => import("../lib/first-sync-next-step.js"),
         () => import("@indigoai-us/hq-cloud"),
+        () => import("../lib/lanes/reconcile.js"),
     ],
     "daemon-logs-follow": [],
     "mesh-daemon": [

package/package.json

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