@indigoai-us/hq-cli 5.319.0 → 5.321.0

package/dist/commands/lanes.js

@@ -35,7 +35,7 @@ import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
-import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG } from "../lib/lanes/flag-keys.js";
+import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, } from "../lib/lanes/flag-keys.js";
 import { CODEX_ROLLOUT_RETENTION_FLAG, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
@@ -1337,6 +1337,7 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, opt
         updated: new Map(),
         unverifiedRemote: new Map(),
         missingOnOwner: new Map(),
+        skippedRemoteRefresh: new Set(),
     };
     const now = ctx.now();
     const nowMs = now.getTime();
@@ -1378,6 +1379,7 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, opt
     if (candidates.length === 0)
         return result;
     const enabledByCompany = new Map();
+    const skipRefreshByCompany = new Map();
     const enabledCandidates = [];
     for (const lane of candidates) {
         const company = resolveLaneCompany(hqRoot, lane).company;
@@ -1392,8 +1394,20 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, opt
             });
             enabledByCompany.set(companyKey, enabled);
         }
-        if (enabled)
-            enabledCandidates.push(lane);
+        if (!enabled)
+            continue;
+        if (options.skipRemoteRefreshForCompany) {
+            let skipRefresh = skipRefreshByCompany.get(companyKey);
+            if (skipRefresh === undefined) {
+                skipRefresh = await options.skipRemoteRefreshForCompany(company);
+                skipRefreshByCompany.set(companyKey, skipRefresh);
+            }
+            if (skipRefresh) {
+                result.skippedRemoteRefresh.add(lane.lane_id);
+                continue;
+            }
+        }
+        enabledCandidates.push(lane);
     }
     if (enabledCandidates.length === 0)
         return result;
@@ -4950,7 +4964,12 @@ async function runList(ctx, opts) {
     }
     const remoteRead = ctx.env[REMOTE_LANE_READ_ENV] === "1";
     const remoteRefresh = remoteRead
-        ? { updated: new Map(), unverifiedRemote: new Map(), missingOnOwner: new Map() }
+        ? {
+            updated: new Map(),
+            unverifiedRemote: new Map(),
+            missingOnOwner: new Map(),
+            skippedRemoteRefresh: new Set(),
+        }
         : await refreshRemoteLaneMirrors(ctx, hqRoot, laneSource, new Set(laneSource
             .filter((lane) => matchesLaneFilters(lane, false))
             .map((lane) => lane.lane_id)), {
@@ -4958,6 +4977,7 @@ async function runList(ctx, opts) {
             laneIds: new Set(laneSource
                 .filter((lane) => matchesLaneFilters(lane, false))
                 .map((lane) => lane.lane_id)),
+            skipRemoteRefreshForCompany: (company) => readLanesRegistryFlagFailOff(LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, { company, env: ctx.env }),
         });
     for (const [laneId, updated] of remoteRefresh.updated) {
         const index = laneSource.findIndex((lane) => lane.lane_id === laneId);
@@ -4995,6 +5015,7 @@ async function runList(ctx, opts) {
     const ownerEligibleLaneIds = new Set();
     for (const lane of selectedLanes) {
         if (remoteRead ||
+            remoteRefresh.skippedRemoteRefresh.has(lane.lane_id) ||
             lane.host.kind !== "outpost" ||
             isTerminalLaneState(lane.state) ||
             laneRunsHere(lane, host)) {
@@ -5034,6 +5055,7 @@ async function runList(ctx, opts) {
     const livenessBySession = new Map();
     let livenessDeps;
     const lanes = selectedLanes.map((lane) => {
+        const overdue = Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now);
         const remoteQueued = lane.state === "queued" &&
             lane.host.kind === "outpost" &&
             !laneRunsHere(lane, host);
@@ -5052,7 +5074,7 @@ async function runList(ctx, opts) {
                     queued_details: lane.queued_reason === "low_disk" ? lane.queued_details : undefined,
                 }
                 : {}),
-            overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now),
+            overdue,
             stalled: Boolean(lane.stalled),
             // Listing is observational. Reconcile owns durable liveness transitions.
             senior_lost: lane.state === "running" && lane.senior.kind === "session" && lane.senior.id
@@ -7873,6 +7895,7 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
             updated: new Map(),
             unverifiedRemote: new Map(),
             missingOnOwner: new Map(),
+            skippedRemoteRefresh: new Set(),
         }
         : await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot));
     const remoteLost = [];

package/dist/fast-core.js

@@ -35,6 +35,11 @@ export async function runFastCore(argv) {
         const envOverride = localBooleanFlagOverride(entry.familyFlagKey, process.env);
         familyEnabled = envOverride ?? await (await import("./native-fast-route.js")).fastFlagEnabled(entry.familyFlagKey, process.env, { numericEnvironmentOverride: false });
     }
+    if (entry.kind === "native" && entry.fallbackToCommandGraph && !familyEnabled) {
+        const { runCli } = await import("./main.js");
+        await runCli();
+        return;
+    }
     const useShell = entry.kind === "native" && Boolean(entry.familyFlagKey) && !familyEnabled;
     const worktreeScopeFixEnabled = entry.name === "repo-run-registry"
         ? await (await import("./native-fast-route.js")).fastFlagEnabled(CORE_RRR_WORKTREE_SCOPE_FIX_FLAG, process.env, { numericEnvironmentOverride: false })
@@ -74,6 +79,14 @@ export async function runFastCore(argv) {
         const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
         const stdin = readsStdin ? await readStdinIfPiped(process.stdin) : "";
         const code = await handler(parsed.args, stdin, process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg, worktreeScopeFixEnabled);
+        if (code === undefined) {
+            if (!entry.fallbackToCommandGraph) {
+                throw new Error(`Native fast handler ${entry.exportName} requested an unavailable command-graph fallback`);
+            }
+            const { runCli } = await import("./main.js");
+            await runCli();
+            return;
+        }
         // Let Node drain handler output before terminating. The timeout guard's
         // stderr message must survive the native route's process boundary.
         process.exitCode = code;

package/dist/fast-scaffold.d.ts

@@ -32,6 +32,8 @@ export type FastScaffoldScript = {
     familyFlagKey?: string;
     /** Shell rollback companion used while the family gate is off. */
     asset?: string;
+    /** Return to the Commander graph when this new route has no shell companion. */
+    fallbackToCommandGraph?: boolean;
     /** Root context used by the native handler. */
     root?: "live" | "cwd" | "passthrough";
     /** Cwd used for a shell rollback companion. Defaults to the caller cwd. */

package/dist/fast-scaffold.js

@@ -217,6 +217,16 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellHqRoot: "live",
         ...(name === "session-project" ? { readsStdin: true, readsStdinFor: (args) => args[0] === "ingest-plan" } : {}),
     })),
+    {
+        name: "hook-batch journal-due",
+        kind: "native",
+        modulePath: "./commands/core-hook-batch-native.js",
+        exportName: "runCoreHookBatchFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-hook-batch",
+        root: "live",
+        fallbackToCommandGraph: true,
+    },
     ...[
         { name: "eval-trigger", modulePath: "./commands/core-eval-trigger-native.js", exportName: "runEvalTriggerFast", asset: "core/scripts/eval-trigger.sh", root: "cwd", shellCwd: "caller", shellHqRoot: "none", readsStdinFor: (args) => args[0] === "--check" },
         { name: "migrate-policy-triggers", modulePath: "./commands/core-migrate-policy-triggers-native.js", exportName: "runMigratePolicyTriggersFast", asset: "core/scripts/migrate-policy-triggers.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },

package/dist/index.d.ts

@@ -3,8 +3,17 @@ import "./node-preflight.js";
 import "./node-network-compat-fast.js";
 import { isVersionRequest } from "./version-request.js";
 import { isFastCoreRequest } from "./fast-scaffold.js";
+type PackageUseLeaseLoader = () => Promise<void>;
+declare function isNpmPackageEntry(entryUrl: string): boolean;
+declare function dispatchWithPackageUseLease(entryUrl: string, dispatch: () => void, loadLease?: PackageUseLeaseLoader): void | Promise<void>;
+declare function runCliEntry(entryUrl: string, dispatch: () => void, loadLease?: PackageUseLeaseLoader): void | Promise<void>;
 export declare const __test__: {
     isVersionRequest: typeof isVersionRequest;
     isFastCoreRequest: typeof isFastCoreRequest;
+    dispatchWithPackageUseLease: typeof dispatchWithPackageUseLease;
+    runCliEntry: typeof runCliEntry;
+    isNpmPackageEntry: typeof isNpmPackageEntry;
+    acquirePackageUseLease: (prefix: string, version: string, stateDirectory?: string) => Promise<import("./utils/package-use-lease.js").PackageUseLease>;
 };
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -17,77 +17,149 @@ import { installProcessRejectionBoundary } from "./unhandled-rejection-boundary.
 // command never run (HQ-CLI-W). Sets process.exitCode only, never process.exit,
 // so runCli's finally still finalizes release health and flushes Sentry.
 installProcessRejectionBoundary();
-if (isVersionRequest(process.argv)) {
-    // Bare `--version` is the CLI semver only (the contract field updaters
-    // compare). `hq version` and `--json` print the labelled HQ/CLI report.
-    // Lazy so this path still skips the command graph.
-    if (wantsLabelledVersionReport(process.argv)) {
-        void import("./lib/flag-registry.js").then(({ kickFlagRegistryReadiness }) => {
-            kickFlagRegistryReadiness();
-            return import("./utils/version-report.js").then(({ runVersionCommand }) => runVersionCommand(process.argv));
+function dispatchCliEntry() {
+    if (isVersionRequest(process.argv)) {
+        // Bare `--version` is the CLI semver only (the contract field updaters
+        // compare). `hq version` and `--json` print the labelled HQ/CLI report.
+        // Lazy so this path still skips the command graph.
+        if (wantsLabelledVersionReport(process.argv)) {
+            void import("./lib/flag-registry.js").then(({ kickFlagRegistryReadiness }) => {
+                kickFlagRegistryReadiness();
+                return import("./utils/version-report.js").then(({ runVersionCommand }) => runVersionCommand(process.argv));
+            });
+        }
+        else {
+            // Keep the benchmarked updater fast route limited to the installed semver.
+            // Registry checks and flag resolution belong to the regular command path.
+            void import("./cli-version.js").then(({ CLI_VERSION }) => {
+                process.stdout.write(`${CLI_VERSION}\n`);
+            });
+        }
+    }
+    else if (parseFastCore(process.argv)?.entry.kind === "native" &&
+        (process.env.HQ_FLAG_HQ_CORE_NATIVE_FAST_ROUTE === "true" ||
+            process.env.HQ_FLAG_HQ_CORE_NATIVE_FAST_ROUTE === "1")) {
+        // An explicit enabled override has already decided the global gate. Skip the
+        // snapshot reader import on hot native plumbing paths; runFastCore still
+        // checks the command-family flag before choosing native or shell rollback.
+        void import("./fast-core.js").then(({ runFastCore }) => runFastCore(process.argv));
+    }
+    else if (parseFastCore(process.argv)?.entry.kind === "native") {
+        // Native routes are default-off. Resolve the company-scoped persisted flag
+        // without loading the command graph; a miss or stale snapshot takes the
+        // existing full-graph route.
+        void import("./native-fast-route.js").then(async ({ nativeFastRouteEnabled }) => {
+            if (await nativeFastRouteEnabled(process.argv)) {
+                const { runFastCore } = await import("./fast-core.js");
+                await runFastCore(process.argv);
+            }
+            else {
+                const { runCli } = await import("./main.js");
+                await runCli();
+            }
         });
     }
-    else {
-        // Keep the benchmarked updater fast route limited to the installed semver.
-        // Registry checks and flag resolution belong to the regular command path.
-        void import("./cli-version.js").then(({ CLI_VERSION }) => {
-            process.stdout.write(`${CLI_VERSION}\n`);
+    else if (parseSecretsEnvFastRequest(process.argv)) {
+        const request = parseSecretsEnvFastRequest(process.argv);
+        void import("./secrets-env-fast-route.js").then(async (route) => {
+            await route.dispatchSecretsEnvFastRequest(request, {
+                isEnabled: () => route.secretsEnvFastRouteEnabled(request),
+                runFast: async () => {
+                    const { runSecretsEnvFastPath } = await import("./secrets-env-fast-path.js");
+                    return runSecretsEnvFastPath(request);
+                },
+                runCurrent: async () => {
+                    const { runCli } = await import("./main.js");
+                    await runCli();
+                },
+            });
         });
     }
+    else if (isFastCoreRequest(process.argv)) {
+        // Hot relocated plumbing (`hq core hq-session`, `hq core checkpoint-stop-gate`)
+        // dispatches straight to the bundled-script runner, so it never pays for the
+        // ~60-module command graph main.ts imports. See src/fast-scaffold.ts.
+        void import("./fast-core.js").then(({ runFastCore }) => runFastCore(process.argv));
+    }
+    else {
+        // Keep the command lifecycle detached from module evaluation, as it was
+        // before the fast --version split. Some best-effort teardown work uses
+        // unref'd handles; top-level-awaiting runCli() makes Node turn an otherwise
+        // successful command into exit 13 when that teardown promise remains pending.
+        // A floated rejection here no longer exits 0 silently: the boundary installed
+        // above turns it into a non-zero exit (HQ-CLI-W).
+        void import("./main.js").then(({ runCli }) => runCli());
+    }
 }
-else if (parseFastCore(process.argv)?.entry.kind === "native" &&
-    (process.env.HQ_FLAG_HQ_CORE_NATIVE_FAST_ROUTE === "true" ||
-        process.env.HQ_FLAG_HQ_CORE_NATIVE_FAST_ROUTE === "1")) {
-    // An explicit enabled override has already decided the global gate. Skip the
-    // snapshot reader import on hot native plumbing paths; runFastCore still
-    // checks the command-family flag before choosing native or shell rollback.
-    void import("./fast-core.js").then(({ runFastCore }) => runFastCore(process.argv));
+function isNpmPackageEntry(entryUrl) {
+    return /\/node_modules\/@indigoai-us\/hq-cli\/dist\/index\.js$/i.test(entryUrl);
 }
-else if (parseFastCore(process.argv)?.entry.kind === "native") {
-    // Native routes are default-off. Resolve the company-scoped persisted flag
-    // without loading the command graph; a miss or stale snapshot takes the
-    // existing full-graph route.
-    void import("./native-fast-route.js").then(async ({ nativeFastRouteEnabled }) => {
-        if (await nativeFastRouteEnabled(process.argv)) {
-            const { runFastCore } = await import("./fast-core.js");
-            await runFastCore(process.argv);
-        }
-        else {
-            const { runCli } = await import("./main.js");
-            await runCli();
-        }
-    });
+function isPackageUseUpdatePendingError(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        error.name === "PackageUseUpdatePendingError");
 }
-else if (parseSecretsEnvFastRequest(process.argv)) {
-    const request = parseSecretsEnvFastRequest(process.argv);
-    void import("./secrets-env-fast-route.js").then(async (route) => {
-        await route.dispatchSecretsEnvFastRequest(request, {
-            isEnabled: () => route.secretsEnvFastRouteEnabled(request),
-            runFast: async () => {
-                const { runSecretsEnvFastPath } = await import("./secrets-env-fast-path.js");
-                return runSecretsEnvFastPath(request);
-            },
-            runCurrent: async () => {
-                const { runCli } = await import("./main.js");
-                await runCli();
-            },
-        });
-    });
+function packageUseErrorClass(error) {
+    if (!error || typeof error !== "object")
+        return "unknown";
+    const value = error;
+    if (typeof value.code === "string")
+        return value.code;
+    if (value.cause && typeof value.cause === "object") {
+        const cause = value.cause;
+        if (typeof cause.code === "string")
+            return cause.code;
+        if (typeof cause.name === "string")
+            return cause.name;
+    }
+    return typeof value.name === "string" ? value.name : "unknown";
 }
-else if (isFastCoreRequest(process.argv)) {
-    // Hot relocated plumbing (`hq core hq-session`, `hq core checkpoint-stop-gate`)
-    // dispatches straight to the bundled-script runner, so it never pays for the
-    // ~60-module command graph main.ts imports. See src/fast-scaffold.ts.
-    void import("./fast-core.js").then(({ runFastCore }) => runFastCore(process.argv));
+function dispatchWithPackageUseLease(entryUrl, dispatch, loadLease = async () => {
+    const { acquireCurrentPackageUseLease } = await import("./utils/package-use-lease.js");
+    acquireCurrentPackageUseLease();
+}) {
+    if (!isNpmPackageEntry(entryUrl)) {
+        dispatch();
+        return;
+    }
+    return loadLease().then(dispatch, (error) => {
+        if (isPackageUseUpdatePendingError(error))
+            throw error;
+        process.stderr.write(`hq-cli package-use lease unavailable (${packageUseErrorClass(error)}); continuing without lease\n`);
+        dispatch();
+    });
 }
-else {
-    // Keep the command lifecycle detached from module evaluation, as it was
-    // before the fast --version split. Some best-effort teardown work uses
-    // unref'd handles; top-level-awaiting runCli() makes Node turn an otherwise
-    // successful command into exit 13 when that teardown promise remains pending.
-    // A floated rejection here no longer exits 0 silently: the boundary installed
-    // above turns it into a non-zero exit (HQ-CLI-W).
-    void import("./main.js").then(({ runCli }) => runCli());
+function runCliEntry(entryUrl, dispatch, loadLease) {
+    const handlePendingUpdate = (error) => {
+        if (!isPackageUseUpdatePendingError(error))
+            throw error;
+        const message = error instanceof Error
+            ? error.message
+            : "The HQ CLI package is being updated";
+        process.stderr.write(`hq-cli: ${message}\n`);
+        process.exitCode = 1;
+    };
+    try {
+        const result = dispatchWithPackageUseLease(entryUrl, dispatch, loadLease);
+        return result?.catch(handlePendingUpdate);
+    }
+    catch (error) {
+        handlePendingUpdate(error);
+    }
 }
-export const __test__ = { isVersionRequest, isFastCoreRequest };
+// Local builds and benchmark fixtures are not installed in an npm prefix.
+// Keep their fast route free of package-use filesystem work; npm installs still
+// publish a lease before dispatch.
+void runCliEntry(import.meta.url, dispatchCliEntry);
+export const __test__ = {
+    isVersionRequest,
+    isFastCoreRequest,
+    dispatchWithPackageUseLease,
+    runCliEntry,
+    isNpmPackageEntry,
+    acquirePackageUseLease: async (prefix, version, stateDirectory) => {
+        const lease = await import("./utils/package-use-lease.js");
+        return lease.acquirePackageUseLease(prefix, version, stateDirectory);
+    },
+};
 //# sourceMappingURL=index.js.map

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

@@ -12,6 +12,8 @@ import { type HostApp } from "./supervisor.js";
 export declare const LOG_ROTATE_BYTES: number;
 /** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
 export declare const RESTART_EXIT_CODE = 75;
+/** Route an updater request through the daemon's existing graceful handoff. */
+export declare function handoffForPackageUpdateRequest(requested: boolean, restartDaemon: () => void): void;
 export interface RunDaemonOptions {
     foreground?: boolean;
     /** Started by the OS unit, which relaunches the daemon whenever it exits. */

package/dist/lib/daemon/run.js

@@ -12,6 +12,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { CLI_VERSION } from "../../cli-version.js";
+import { currentPackageUseUpdateRequested } from "../../utils/package-use-lease.js";
 import { isLocalDependencyInstall, resolveRunningInstall } from "../../utils/version-gate.js";
 import { agentKitPaths } from "../agent-kit/paths.js";
 import { readBotConfig } from "../bot/config.js";
@@ -39,6 +40,11 @@ import { userToolDirs } from "./tools.js";
 export const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
 /** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
 export const RESTART_EXIT_CODE = 75;
+/** Route an updater request through the daemon's existing graceful handoff. */
+export function handoffForPackageUpdateRequest(requested, restartDaemon) {
+    if (requested)
+        restartDaemon();
+}
 const LEGACY_PROBE_TTL_MS = 60_000;
 /** A flag read that has not answered by then counts as off. */
 const HANDOFF_FLAG_TIMEOUT_MS = 10_000;
@@ -603,7 +609,10 @@ export async function runDaemon(opts) {
                 log("info", `rotated ${n} log file(s)`);
             return true;
         },
-        takeRequests: () => takeControlRequests(paths.requestsDir),
+        takeRequests: () => {
+            handoffForPackageUpdateRequest(currentPackageUseUpdateRequested(), restartDaemon);
+            return takeControlRequests(paths.requestsDir);
+        },
         restartDaemon: () => restartDaemon(),
         writeState: (state) => writeJsonAtomic(paths.statePath, state),
         log,

package/dist/lib/lanes/flag-keys.d.ts

@@ -4,6 +4,9 @@ export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-bala
 export declare const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
 /** Count only children with live work against their senior's hire grant. */
 export declare const LANE_HIRE_GRANT_FINISHED_LANES_FLAG = "lanes.hire-grant-count-live-only";
+/** Skips owner refreshes during ordinary lane list polling when explicitly enabled. */
+export declare const LANE_LIST_SKIP_REMOTE_REFRESH_FLAG = "lanes.list-skip-remote-refresh";
+export declare const LANE_LIST_SKIP_REMOTE_REFRESH_DEFAULT_ENABLED = false;
 /** Enables missed-deadline lead nudges and second-miss operator escalation. */
 export declare const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
 export declare const LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG = "lanes.autopilot-nudge-dedupe";

package/dist/lib/lanes/flag-keys.js

@@ -4,6 +4,9 @@ export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 export const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
 /** Count only children with live work against their senior's hire grant. */
 export const LANE_HIRE_GRANT_FINISHED_LANES_FLAG = "lanes.hire-grant-count-live-only";
+/** Skips owner refreshes during ordinary lane list polling when explicitly enabled. */
+export const LANE_LIST_SKIP_REMOTE_REFRESH_FLAG = "lanes.list-skip-remote-refresh";
+export const LANE_LIST_SKIP_REMOTE_REFRESH_DEFAULT_ENABLED = false;
 /** Enables missed-deadline lead nudges and second-miss operator escalation. */
 export const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
 export const LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG = "lanes.autopilot-nudge-dedupe";

package/dist/lib/work-context/bind-best.d.ts

@@ -41,7 +41,7 @@ export declare function discoverProjects(input: {
     env?: NodeJS.ProcessEnv;
     home?: string;
 }): CatalogProject[];
-/** discoverProjects memoized by directory mtime. A cache hit does not rescan. */
+/** discoverProjects memoized by source directory and mtime. A hit does not rescan. */
 export declare function discoverProjectsCached(input: Parameters<typeof discoverProjects>[0], nowMs?: number): CatalogProject[];
 export declare function refineProjectBinding(input: {
     hint?: string;

package/dist/lib/work-context/bind-best.js

@@ -215,14 +215,14 @@ function catalogStamp(input) {
         if (!dir)
             return "0";
         try {
-            return String(fs.statSync(dir).mtimeMs);
+            return `${dir}:${fs.statSync(dir).mtimeMs}`;
         }
         catch {
-            return "0";
+            return `${dir}:0`;
         }
     }).join("|");
 }
-/** discoverProjects memoized by directory mtime. A cache hit does not rescan. */
+/** discoverProjects memoized by source directory and mtime. A hit does not rescan. */
 export function discoverProjectsCached(input, nowMs = Date.now()) {
     const key = `${input.hqRoot ?? ""}|${input.companySlug ?? ""}|${input.companyUid ?? ""}|${input.home ?? ""}|${catalogStamp(input)}`;
     if (catalogCache && catalogCache.key === key && nowMs - catalogCache.at < CATALOG_CACHE_TTL_MS) {

package/dist/utils/package-use-lease.d.ts

@@ -0,0 +1,25 @@
+export declare class PackageUseUpdatePendingError extends Error {
+    constructor(message: string);
+}
+export interface PackageUseLease {
+    readonly leasePath: string;
+    release(): void;
+}
+export interface PackageUseLeaseRecord {
+    pid: number;
+    start_time_ms: number;
+    hq_version: string;
+}
+export declare function npmPrefix(root: string, platform?: NodeJS.Platform): string | null;
+export declare function packageUseLeaseDirectory(prefix: string, stateDirectory?: string): string;
+export declare function packageUseUpdateRequestPath(prefix: string, stateDirectory?: string): string;
+declare function waitForUpdateRequest(requestPath: string, timeoutMs: number): void;
+export declare function acquirePackageUseLease(prefix: string, hqVersion: string, stateDirectory?: string): PackageUseLease;
+export declare function acquireCurrentPackageUseLease(): PackageUseLease | null;
+/** True while the desktop updater owns the per-prefix update request. */
+export declare function currentPackageUseUpdateRequested(): boolean;
+export declare const __test__: {
+    waitForUpdateRequest: typeof waitForUpdateRequest;
+};
+export {};
+//# sourceMappingURL=package-use-lease.d.ts.map