@indigoai-us/hq-cli 5.345.127 → 5.345.129

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/accounts.js

@@ -280,7 +280,7 @@ function throwIfQuotaBlocked(block, provider, accountId, identity) {
     const label = accountLabel(accountId, identity);
     const identityFields = identity ? { identity } : {};
     if (block.reason === "account_model_unavailable") {
-        throw new AccountResolutionError("account_model_unavailable", `${label} cannot run model ${model}: ${block.marker ?? "needs credits"}`, {
+        throw new AccountResolutionError("account_model_unavailable", `${label} cannot run model ${model}: ${block.marker ?? "needs credits"}. The account's model needs credits; once they are added, clear the marker with: ${clearQuotaCommand(provider, accountId)}`, {
             provider,
             account: accountId,
             model: block.model ?? null,
@@ -289,7 +289,7 @@ function throwIfQuotaBlocked(block, provider, accountId, identity) {
         });
     }
     const clear = clearQuotaCommand(provider, accountId);
-    throw new AccountResolutionError("account_quota_exhausted", `${label} is out of quota${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""} for model ${model}. Clear the hold with: ${clear}`, {
+    throw new AccountResolutionError("account_quota_exhausted", `${label} is marked unavailable for model ${model} (the account's model needs credits). Clear the marker with: ${clear}`, {
         provider,
         account: accountId,
         model: block.model ?? null,

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/host-capacity.d.ts

@@ -12,6 +12,10 @@ export interface HostCapacityAccount {
     /** Account-wide quota status when this snapshot is produced on its host. */
     quota_held?: boolean;
     quota_reset_at?: string;
+    /** Last recorded provider usage limit on this account. Informational only. */
+    last_quota_hit_at?: string;
+    /** The provider's reset time from that limit, when it named one. Informational only. */
+    provider_reset_at?: string;
     /** Exact lane states used for Claude account balancing; absent on older Outposts. */
     lane_counts?: {
         running: number;

package/dist/lib/lanes/host-capacity.js

@@ -2,7 +2,7 @@ import { accountStatus } from "./accounts.js";
 import { accountMaxRunning } from "./config.js";
 import { laneOccupiesRunningSlot, laneRunsOnHost, } from "./admission.js";
 import { LanesError } from "./errors.js";
-import { quotaBlockFor } from "./quota.js";
+import { quotaBlockFor, quotaHitInfo } from "./quota.js";
 function admissionHost(host) {
     return host.kind === "outpost"
         ? { hostname: "", outpostId: host.id }
@@ -38,6 +38,7 @@ export function buildHostCapacitySnapshot(input) {
                 ? quotaBlockFor(input.quotaState, provider, id, undefined, input.now)
                 : undefined;
             const quotaResetAt = input.quotaState?.providers[provider]?.[id]?.all_models_quota_reset_at;
+            const hit = input.quotaState ? quotaHitInfo(input.quotaState, provider, id, input.now) : undefined;
             accounts[id] = {
                 enabled: account.enabled,
                 logged_in: status.logged_in,
@@ -51,6 +52,8 @@ export function buildHostCapacitySnapshot(input) {
                         ...(quotaResetAt ? { quota_reset_at: quotaResetAt } : {}),
                     }
                     : {}),
+                ...(hit?.last_quota_hit_at ? { last_quota_hit_at: hit.last_quota_hit_at } : {}),
+                ...(hit?.provider_reset_at ? { provider_reset_at: hit.provider_reset_at } : {}),
                 lane_counts: {
                     running: liveLanes.filter((lane) => lane.state === "running").length,
                     queued: liveLanes.filter((lane) => lane.state === "queued").length,
@@ -142,6 +145,12 @@ export function parseHostCapacitySnapshot(raw) {
                 ...(account.quota_reset_at !== undefined
                     ? { quota_reset_at: account.quota_reset_at }
                     : {}),
+                ...(typeof account.last_quota_hit_at === "string" && Number.isFinite(Date.parse(account.last_quota_hit_at))
+                    ? { last_quota_hit_at: account.last_quota_hit_at }
+                    : {}),
+                ...(typeof account.provider_reset_at === "string" && Number.isFinite(Date.parse(account.provider_reset_at))
+                    ? { provider_reset_at: account.provider_reset_at }
+                    : {}),
                 ...(account.lane_counts !== undefined
                     ? { lane_counts: parseLaneCounts(account.lane_counts, `${provider}.${id}.lane_counts`) }
                     : {}),

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

@@ -44,8 +44,8 @@ export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PRO
 export type { AccountResolveContext, AccountStatus, AuthState, ClaudeIdentity, ResolvedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
 export type { LivenessDeps, LivenessEventKind, LivenessIndex, SessionIndexEntry, } from "./liveness.js";
-export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
-export type { AnsweredLaneWakeResult, ReconcileChange, ReconcileDeps, ReconcileHost, ReconcileSkip, ReconcileSummary, } from "./reconcile.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, admitQueuedNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export type { AnsweredLaneWakeResult, AdmitQueuedNowResult, ReconcileChange, ReconcileDeps, ReconcileHost, ReconcileSkip, ReconcileSummary, } from "./reconcile.js";
 export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
 export type { ProviderPathEnv, ReconcileInstallOpts, ReconcileInstallResult, RunCommand, RunCommandResult, } from "./reconcile-install.js";
 export { unitPathEnv } from "./reconcile-install.js";

package/dist/lib/lanes/index.js

@@ -24,7 +24,7 @@ export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO,
 export { effectiveAccountHome, } from "./account-home.js";
 export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, claudeIdentityDiffers, claudeIdentityFromProbe, clearQuotaCommand, credentialPaths, describeClaudeIdentity, hasCredentialFile, isCredentialProven, isDefaultProviderHome, isLoggedOut, probeInteractiveClaudeIdentity, withProviderHomeEnv, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
-export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, admitQueuedNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
 export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
 export { unitPathEnv } from "./reconcile-install.js";
 export { PROVIDER_REJECTED_REASON, PROVIDER_REJECTION_MESSAGE_CAP, parseClaudeResultRejection, parseCodexTurnFailed, parseGrokErrorOutput, parseProviderRejection, readProviderRejection, retryableFromStatus, } from "./provider-rejection.js";

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

@@ -178,6 +178,14 @@ export declare function applyLoopStallAnswer(input: {
     action: "requeued" | "parked" | "already_applied";
 } | undefined;
 export declare function loopStatus(runDir: string, laneId: string): LoopStatus;
+/**
+ * Commit a stop envelope that is the only thing left in an idle loop lane's
+ * queue: no phase is active and the stop is the FIFO head. The loop
+ * controller would do exactly this on its next claim; doing it in-process
+ * lets a queued loop lane end without waiting for admission. Returns false
+ * and changes nothing when the queue holds anything ahead of the stop.
+ */
+export declare function commitIdleLoopStop(runDir: string, laneId: string, now?: () => Date): boolean;
 export declare function setLoopControllerPid(runDir: string, laneId: string, pid: number | undefined): void;
 export declare function clearLoopControllerPid(runDir: string, laneId: string, pid: number): void;
 export declare function loopControllerIsAlive(runDir: string): boolean;

package/dist/lib/lanes/loop.js

@@ -596,6 +596,41 @@ export function loopStatus(runDir, laneId) {
         updated_at: typeof loop.updated_at === "string" ? loop.updated_at : new Date(0).toISOString(),
     };
 }
+/**
+ * Commit a stop envelope that is the only thing left in an idle loop lane's
+ * queue: no phase is active and the stop is the FIFO head. The loop
+ * controller would do exactly this on its next claim; doing it in-process
+ * lets a queued loop lane end without waiting for admission. Returns false
+ * and changes nothing when the queue holds anything ahead of the stop.
+ */
+export function commitIdleLoopStop(runDir, laneId, now = () => new Date()) {
+    if (envelopeFiles(activeDir(runDir)).length > 0)
+        return false;
+    const head = envelopeFiles(pendingDir(runDir))[0];
+    if (!head)
+        return false;
+    let headRecord;
+    try {
+        headRecord = fileEnvelope(head);
+    }
+    catch {
+        return false;
+    }
+    if (headRecord.envelope.kind !== "stop")
+        return false;
+    const claimed = claimNextLoopEnvelope(runDir);
+    if (!claimed)
+        return false;
+    if (claimed.record.envelope.kind !== "stop") {
+        // Another claimer moved the queue between the check and the claim; put it back.
+        fs.renameSync(claimed.file, path.join(pendingDir(runDir), path.basename(claimed.file)));
+        return false;
+    }
+    const stopped = { schema_version: LOOP_SCHEMA, envelope_id: claimed.record.envelope_id, status: "stopped", started_at: claimed.record.queued_at, finished_at: now().toISOString() };
+    writeResultAt(runDir, claimed.file, claimed.record, stopped);
+    persistStatus(runDir, laneId, { state: "stopped", queue_depth: listLoopQueue(runDir).length, active_envelope_id: null, active_phase: null });
+    return true;
+}
 export function setLoopControllerPid(runDir, laneId, pid) {
     persistStatus(runDir, laneId, { pid });
 }