@indigoai-us/hq-cli 5.282.0 → 5.284.0

package/dist/fast-lanes-list-route.d.ts

@@ -0,0 +1,8 @@
+export interface FastLanesListRouteDeps {
+    flagEnabled: (flagKey: string, env: NodeJS.ProcessEnv) => Promise<boolean>;
+    runFastList: () => Promise<void>;
+    runPlacementList: () => Promise<void>;
+}
+/** Returns false unless this exact list form is safely enabled in the local flag snapshot. */
+export declare function runFastLanesListRequest(argv: readonly string[], env?: NodeJS.ProcessEnv, deps?: FastLanesListRouteDeps): Promise<boolean>;
+//# sourceMappingURL=fast-lanes-list-route.d.ts.map

package/dist/fast-lanes-list-route.js

@@ -0,0 +1,30 @@
+import { isFastCachedLanesListRequest } from "./fast-scaffold.js";
+import { fastFlagEnabled } from "./native-fast-route.js";
+import { LANE_OUTPOST_SNAPSHOT_CACHE_FLAG } from "./lib/lanes/outpost-hire-cache.js";
+import { LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lib/lanes/flag-keys.js";
+/** Returns false unless this exact list form is safely enabled in the local flag snapshot. */
+export async function runFastLanesListRequest(argv, env = process.env, deps = {
+    flagEnabled: fastFlagEnabled,
+    runFastList: async () => {
+        const { runFastCachedLanesList } = await import("./fast-lanes-list.js");
+        await runFastCachedLanesList();
+    },
+    runPlacementList: async () => {
+        const { runFastCachedLanesListFromEntrypoint } = await import("./commands/lanes.js");
+        await runFastCachedLanesListFromEntrypoint();
+    },
+}) {
+    if (!isFastCachedLanesListRequest(argv))
+        return false;
+    if (env.HQ_INTERNAL_LANES_REFRESH_REMOTE_SNAPSHOT === "1")
+        return false;
+    if (!await deps.flagEnabled(LANE_OUTPOST_SNAPSHOT_CACHE_FLAG, env))
+        return false;
+    const lanePlacementEnabled = await deps.flagEnabled(LANE_OUTPOST_LOAD_BALANCING_FLAG, env);
+    if (lanePlacementEnabled)
+        await deps.runPlacementList();
+    else
+        await deps.runFastList();
+    return true;
+}
+//# sourceMappingURL=fast-lanes-list-route.js.map

package/dist/fast-lanes-list.d.ts

@@ -0,0 +1,3 @@
+/** Lightweight implementation for the exact cache-first `lanes list --json` entrypoint. */
+export declare function runFastCachedLanesList(): Promise<void>;
+//# sourceMappingURL=fast-lanes-list.d.ts.map

package/dist/fast-lanes-list.js

@@ -0,0 +1,252 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { compareLaneQueueOrder, laneRunsOnHost } from "./lib/lanes/admission.js";
+import { readOutpostIdentity, resolveAdmissionHost } from "./lib/lanes/admission-host.js";
+import { LaneSchemaError, isLanesError } from "./lib/lanes/errors.js";
+import { OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS, outpostHireSummaryCacheKey, readOutpostHireSummaryCacheIncludingStale, } from "./lib/lanes/outpost-hire-cache.js";
+import { resolveLanesHqRoot } from "./lib/lanes/hq-root.js";
+import { laneStories } from "./lib/lanes/stories.js";
+import { readAllLanes } from "./lib/lanes/store.js";
+import { isTerminalLaneState } from "./lib/lanes/types.js";
+const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
+function withoutProviderHome(value) {
+    if (Array.isArray(value))
+        return value.map(withoutProviderHome);
+    if (value === null || typeof value !== "object")
+        return value;
+    const safe = {};
+    for (const [key, nested] of Object.entries(value)) {
+        if (key === "provider_home_at_spawn")
+            continue;
+        safe[key] = withoutProviderHome(nested);
+    }
+    return safe;
+}
+function printJson(value) {
+    console.log(JSON.stringify(withoutProviderHome(value), null, 2));
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function failJson(err) {
+    if (isLanesError(err)) {
+        if (err.error === "hire_grant_exhausted") {
+            process.stderr.write(`hq lanes: ${err.message}\n`);
+        }
+        printJson({ ...err.toJSON(), message: err.message });
+    }
+    else {
+        const message = errorMessage(err);
+        process.stderr.write(`hq lanes: ${message}${err instanceof Error && err.stack ? `\n${err.stack}` : ""}\n`);
+        printJson({ error: "internal", message });
+    }
+    process.exitCode = 1;
+}
+function laneHireFields(lane, aliveChildrenByParent) {
+    const aliveChildCount = aliveChildrenByParent.get(lane.lane_id) ?? 0;
+    const hireGrant = lane.hire_grant ?? 0;
+    return {
+        hire_grant: hireGrant,
+        hire_alive_children: aliveChildCount,
+        hire: `${aliveChildCount}/${hireGrant}`,
+        hire_summary: `hire ${aliveChildCount}/${hireGrant}`,
+    };
+}
+function isOverdue(hqRoot, laneId, now) {
+    const filePath = path.join(hqRoot, LANES_RUNS_REL, laneId, "timeout.json");
+    let text;
+    try {
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return false;
+        throw err;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (err) {
+        throw new LaneSchemaError(`Invalid JSON in ${filePath}: ${errorMessage(err)}`, { path: filePath });
+    }
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return false;
+    const deadline = raw.deadline_at;
+    if (typeof deadline !== "string")
+        return false;
+    const at = Date.parse(deadline);
+    if (!Number.isFinite(at))
+        return false;
+    return now.getTime() > at;
+}
+function startOutpostLaneSnapshotRefresh(root, env) {
+    let entry;
+    try {
+        const currentEntry = process.argv[1];
+        if (!currentEntry)
+            throw new Error("process.argv[1] is empty");
+        entry = fs.realpathSync(currentEntry);
+    }
+    catch (err) {
+        process.stderr.write(`lanes snapshot refresh could not resolve the running CLI entry: ${errorMessage(err)}\n`);
+        return;
+    }
+    try {
+        const child = spawn(process.execPath, [...process.execArgv, entry, "lanes", "list"], {
+            cwd: root,
+            detached: true,
+            stdio: ["ignore", "ignore", "inherit"],
+            env: { ...env, HQ_ROOT: root, HQ_NO_UPDATE_CHECK: "1", HQ_INTERNAL_LANES_REFRESH_REMOTE_SNAPSHOT: "1" },
+        });
+        child.once("error", (err) => {
+            process.stderr.write(`lanes snapshot refresh could not start: ${errorMessage(err)}\n`);
+        });
+        child.unref();
+    }
+    catch (err) {
+        process.stderr.write(`lanes snapshot refresh could not start: ${errorMessage(err)}\n`);
+    }
+}
+function isOwnerLane(lane, host) {
+    return lane.host.kind === "outpost" &&
+        !isTerminalLaneState(lane.state) &&
+        !laneRunsOnHost(lane, host);
+}
+async function buildLaneList(hqRoot, sourceLanes, host, now, env) {
+    const selectedLanes = sourceLanes.sort(compareLaneQueueOrder);
+    const aliveChildrenByParent = new Map();
+    for (const child of selectedLanes) {
+        if (child.senior.kind !== "lane" || !child.senior.id || isTerminalLaneState(child.state))
+            continue;
+        aliveChildrenByParent.set(child.senior.id, (aliveChildrenByParent.get(child.senior.id) ?? 0) + 1);
+    }
+    const ownerLanes = selectedLanes.filter((lane) => isOwnerLane(lane, host));
+    const hireByLane = new Map();
+    const remoteSnapshotMetadata = new Map();
+    let remoteLanesLoading = false;
+    for (const lane of selectedLanes) {
+        if (!isOwnerLane(lane, host)) {
+            hireByLane.set(lane.lane_id, {
+                ...laneHireFields(lane, aliveChildrenByParent),
+                hire_source: "local",
+            });
+        }
+    }
+    if (ownerLanes.length > 0) {
+        const nowMs = now.getTime();
+        const cached = readOutpostHireSummaryCacheIncludingStale(hqRoot, nowMs);
+        let refreshNeeded = false;
+        for (const lane of ownerLanes) {
+            if (lane.host.kind !== "outpost")
+                continue;
+            const summary = cached.get(outpostHireSummaryCacheKey(lane.host.id, lane.lane_id));
+            if (!summary) {
+                hireByLane.set(lane.lane_id, {
+                    ...laneHireFields(lane, aliveChildrenByParent),
+                    hire_source: "local",
+                });
+                remoteSnapshotMetadata.set(lane.lane_id, { ageSeconds: null, stale: true, loading: true });
+                refreshNeeded = true;
+                remoteLanesLoading = true;
+                continue;
+            }
+            const ageMs = Math.max(0, nowMs - Date.parse(summary.cached_at));
+            const stale = ageMs >= OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS;
+            hireByLane.set(lane.lane_id, {
+                hire_grant: summary.hire_grant,
+                hire_alive_children: summary.hire_alive_children,
+                hire: summary.hire,
+                hire_summary: summary.hire_summary,
+                hire_source: "owner",
+            });
+            remoteSnapshotMetadata.set(lane.lane_id, {
+                ageSeconds: Math.floor(ageMs / 1_000),
+                stale,
+                loading: stale,
+            });
+            if (stale) {
+                refreshNeeded = true;
+                remoteLanesLoading = true;
+            }
+        }
+        if (refreshNeeded)
+            startOutpostLaneSnapshotRefresh(hqRoot, env);
+    }
+    const sessions = selectedLanes.filter((lane) => lane.state === "running" && lane.senior.kind === "session" && Boolean(lane.senior.id));
+    let sessionLiveness;
+    let livenessDeps;
+    if (sessions.length > 0) {
+        const liveness = await import("./lib/lanes/liveness.js");
+        sessionLiveness = liveness.sessionLiveness;
+        const base = liveness.defaultLivenessDeps();
+        livenessDeps = {
+            ...base,
+            now: () => now.getTime(),
+            homedir: () => os.homedir(),
+            env,
+            existsSync: (file) => fs.existsSync(file),
+            readFileSync: (file, encoding) => fs.readFileSync(file, encoding),
+            hostname: () => os.hostname(),
+        };
+    }
+    const livenessBySession = new Map();
+    const lanes = selectedLanes.map((lane) => {
+        const stories = laneStories(lane);
+        const remoteQueued = lane.state === "queued" && lane.host.kind === "outpost" && !laneRunsOnHost(lane, host);
+        let seniorLost = false;
+        if (lane.state === "running" && lane.senior.kind === "session" && lane.senior.id && sessionLiveness && livenessDeps) {
+            const sessionId = lane.senior.id;
+            const cached = livenessBySession.get(sessionId);
+            if (cached !== undefined)
+                seniorLost = cached;
+            else {
+                const state = sessionLiveness(hqRoot, sessionId, {
+                    nowMs: now.getTime(),
+                    deps: livenessDeps,
+                });
+                seniorLost = state === null || state === "ended" || state === "lost";
+                livenessBySession.set(sessionId, seniorLost);
+            }
+        }
+        return {
+            ...lane,
+            ...hireByLane.get(lane.lane_id),
+            stories,
+            story_ids: stories.map((story) => story.story_id),
+            no_story_reason: lane.no_story_reason ?? null,
+            ...(remoteQueued ? { state: "remote", remote_state: lane.state, queued_reason: undefined } : {}),
+            ...(remoteSnapshotMetadata.has(lane.lane_id)
+                ? {
+                    remote_snapshot_age_s: remoteSnapshotMetadata.get(lane.lane_id).ageSeconds,
+                    remote_snapshot_stale: remoteSnapshotMetadata.get(lane.lane_id).stale,
+                    ...(remoteSnapshotMetadata.get(lane.lane_id).loading ? { remote_snapshot_loading: true } : {}),
+                }
+                : {}),
+            overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now),
+            stalled: Boolean(lane.stalled),
+            senior_lost: seniorLost,
+        };
+    });
+    return { lanes, ...(remoteLanesLoading ? { remote_lanes_loading: true } : {}) };
+}
+/** Lightweight implementation for the exact cache-first `lanes list --json` entrypoint. */
+export async function runFastCachedLanesList() {
+    try {
+        const env = process.env;
+        const hqRoot = resolveLanesHqRoot({ env, cwd: process.cwd() });
+        const now = new Date();
+        const host = resolveAdmissionHost({
+            hostname: () => os.hostname(),
+            readOutpostIdentity: () => readOutpostIdentity(),
+        });
+        const lanes = await buildLaneList(hqRoot, readAllLanes(hqRoot), host, now, env);
+        printJson({ ok: true, action: "list", ...lanes });
+    }
+    catch (err) {
+        failJson(err);
+    }
+}
+//# sourceMappingURL=fast-lanes-list.js.map

package/dist/fast-scaffold.d.ts

@@ -53,6 +53,11 @@ export type ParsedSecretsEnvFastRequest = {
  * the full CLI, which remains the source of truth for help and errors.
  */
 export declare function parseSecretsEnvFastRequest(argv: readonly string[]): ParsedSecretsEnvFastRequest | null;
+/**
+ * The cache-first list path only handles the bare JSON request. `--fresh`,
+ * filters, help, and unknown options stay with Commander and the full CLI.
+ */
+export declare function isFastCachedLanesListRequest(argv: readonly string[]): boolean;
 /**
  * Parse `hq core [--hq-root <path>] <name> [args...]` when `<name>` is a
  * fast-path script. Returns null for anything else so the caller defers to the

package/dist/fast-scaffold.js

@@ -112,6 +112,16 @@ export function parseSecretsEnvFastRequest(argv) {
     }
     return hasOnly ? { options, scope } : null;
 }
+/**
+ * The cache-first list path only handles the bare JSON request. `--fresh`,
+ * filters, help, and unknown options stay with Commander and the full CLI.
+ */
+export function isFastCachedLanesListRequest(argv) {
+    return argv.length === 5 &&
+        argv[2] === "lanes" &&
+        argv[3] === "list" &&
+        argv[4] === "--json";
+}
 /**
  * Parse `hq core [--hq-root <path>] <name> [args...]` when `<name>` is a
  * fast-path script. Returns null for anything else so the caller defers to the

package/dist/index.js

@@ -6,7 +6,7 @@ import "./node-network-compat.js";
 import { isVersionRequest, wantsLabelledVersionReport } from "./version-request.js";
 // Dependency-light: a pure parser + table, no command graph. Safe to load on
 // every path (including --version) without reintroducing the heavy startup.
-import { isFastCoreRequest, parseFastCore, parseSecretsEnvFastRequest, } from "./fast-scaffold.js";
+import { isFastCachedLanesListRequest, isFastCoreRequest, parseFastCore, parseSecretsEnvFastRequest, } from "./fast-scaffold.js";
 // Also dependency-light: registers a process-level rejection boundary; its only
 // heavy import (main.js) is lazy and reached only when a rejection fires.
 import { installProcessRejectionBoundary } from "./unhandled-rejection-boundary.js";
@@ -61,6 +61,15 @@ else if (parseSecretsEnvFastRequest(process.argv)) {
         });
     });
 }
+else if (isFastCachedLanesListRequest(process.argv)) {
+    void import("./fast-lanes-list-route.js").then(async ({ runFastLanesListRequest }) => {
+        const handled = await runFastLanesListRequest(process.argv);
+        if (!handled) {
+            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

package/dist/lib/checkpoint-ontology/merge-copies.d.ts

@@ -27,11 +27,23 @@
  *
  * A signal whose `entity_refs` names a copy holds that copy: signals are
  * server-owned, so the ref cannot be re-pointed from here.
+ *
+ * With `pairKind: "variants"` (flag `checkpoint.ontology.merge-variants`) the
+ * pairs are two-file duplicate groups whose canonical names differ only in
+ * case, spacing or punctuation; the survivor is the spaced name, then the
+ * higher `signal_count`, then path order. The copy's canonical name becomes
+ * an alias of the survivor. Merge and delete work as for numbered copies.
  */
 import { type OntologyCompany } from "./company.js";
 import { type EntityIndex } from "./tree.js";
 export declare const MERGE_COPIES_FLAG = "checkpoint.ontology.merge-copies";
-export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group";
+/**
+ * `merge-copies --variants`: merge two-file duplicate groups whose canonical
+ * names differ only in spacing, case or punctuation (CO-65).
+ */
+export declare const MERGE_VARIANTS_FLAG = "checkpoint.ontology.merge-variants";
+export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group" | "group_size" | "type_differs" | "names_differ" | "numbered_copy";
+export type PairKind = "numbered" | "variants";
 export interface CopySkip {
     copy: string;
     reason: CopySkipReason;
@@ -66,6 +78,7 @@ export interface CopyPlan extends CopyPair {
 export interface MergeCopiesReport {
     company: string;
     mode: "dry_run" | "merge" | "delete";
+    pair_kind: PairKind;
     duplicate_groups_before: number;
     duplicate_groups_after: number;
     copies_found: number;
@@ -97,6 +110,8 @@ export interface MergeCopiesOptions {
     hqRoot: string;
     company: OntologyCompany;
     mode: "dry_run" | "merge" | "delete";
+    /** Which pairs to merge; default numbered copies. */
+    pairKind?: PairKind;
     /** Handle at most this many copies (sorted by path). */
     limit?: number;
     now: Date;
@@ -107,6 +122,14 @@ export declare function findCopyPairs(index: EntityIndex): {
     pairs: CopyPair[];
     skipped: CopySkip[];
 };
+/**
+ * Two-file duplicate groups whose canonical names differ only in case, spacing
+ * or punctuation. Numbered copies are left to `findCopyPairs`. Read-only.
+ */
+export declare function findVariantPairs(index: EntityIndex): {
+    pairs: CopyPair[];
+    skipped: CopySkip[];
+};
 /**
  * Plan, merge or delete numbered copies for one company. The dry run writes
  * nothing; merge writes entity files only; delete removes vault keys and

package/dist/lib/checkpoint-ontology/merge-copies.js

@@ -27,6 +27,12 @@
  *
  * A signal whose `entity_refs` names a copy holds that copy: signals are
  * server-owned, so the ref cannot be re-pointed from here.
+ *
+ * With `pairKind: "variants"` (flag `checkpoint.ontology.merge-variants`) the
+ * pairs are two-file duplicate groups whose canonical names differ only in
+ * case, spacing or punctuation; the survivor is the spaced name, then the
+ * higher `signal_count`, then path order. The copy's canonical name becomes
+ * an alias of the survivor. Merge and delete work as for numbered copies.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -38,6 +44,11 @@ import { isWritableEntityType, normalizeEntityName } from "./identity.js";
 import { findDuplicateGroups, readBackRefs, recordOutbox } from "./multi-writer.js";
 import { buildEntityIndex, listSignalFiles, readSignal } from "./tree.js";
 export const MERGE_COPIES_FLAG = "checkpoint.ontology.merge-copies";
+/**
+ * `merge-copies --variants`: merge two-file duplicate groups whose canonical
+ * names differ only in spacing, case or punctuation (CO-65).
+ */
+export const MERGE_VARIANTS_FLAG = "checkpoint.ontology.merge-variants";
 /** `<slug> <n>.md`, the name a file manager gives a second copy. */
 const COPY_NAME = /^(.+) (\d+)\.md$/;
 /** A relationship list item with a link, as the gardener and checkpoint write them. */
@@ -133,6 +144,62 @@ export function findCopyPairs(index) {
     }
     return { pairs, skipped };
 }
+/** The canonical name with case, spacing and punctuation removed. */
+function compactName(name, type) {
+    return normalizeEntityName(name, type).replace(/[^\p{L}\p{N}]/gu, "");
+}
+/**
+ * Two-file duplicate groups whose canonical names differ only in case, spacing
+ * or punctuation. Numbered copies are left to `findCopyPairs`. Read-only.
+ */
+export function findVariantPairs(index) {
+    const pairs = [];
+    const skipped = [];
+    for (const group of findDuplicateGroups(index)) {
+        const paths = [...group.paths].sort((a, b) => a.localeCompare(b));
+        const numbered = paths.filter((rel) => COPY_NAME.test(path.posix.basename(rel)));
+        if (numbered.length > 0) {
+            for (const rel of numbered)
+                skipped.push({ copy: rel, reason: "numbered_copy" });
+            continue;
+        }
+        if (paths.length !== 2) {
+            skipped.push({ copy: paths[0], reason: "group_size" });
+            continue;
+        }
+        const left = index.byRel.get(paths[0]);
+        const right = index.byRel.get(paths[1]);
+        if (!left || !right) {
+            skipped.push({ copy: paths[0], reason: "no_original" });
+            continue;
+        }
+        if (left.type !== right.type) {
+            skipped.push({ copy: paths[0], reason: "type_differs" });
+            continue;
+        }
+        const leftName = compactName(left.canonical_name, left.type);
+        const rightName = compactName(right.canonical_name, right.type);
+        if (leftName === "" || rightName === "" || leftName !== rightName) {
+            skipped.push({ copy: paths[0], reason: "names_differ" });
+            continue;
+        }
+        const leftSpaced = left.canonical_name.includes(" ");
+        const rightSpaced = right.canonical_name.includes(" ");
+        let originalRel = paths[0];
+        let copyRel = paths[1];
+        if (leftSpaced !== rightSpaced) {
+            originalRel = leftSpaced ? paths[0] : paths[1];
+            copyRel = leftSpaced ? paths[1] : paths[0];
+        }
+        else if (left.signal_count !== right.signal_count) {
+            originalRel = left.signal_count > right.signal_count ? paths[0] : paths[1];
+            copyRel = originalRel === paths[0] ? paths[1] : paths[0];
+        }
+        pairs.push({ type: left.type, copy: copyRel, original: originalRel });
+    }
+    pairs.sort((a, b) => a.copy.localeCompare(b.copy));
+    return { pairs, skipped };
+}
 /** Resolve a relative link in `fromRel` to a company-relative path, or null. */
 function resolveLink(fromRel, href) {
     if (/^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("#") || href.startsWith("/"))
@@ -431,13 +498,15 @@ function writeEntity(hqRoot, company, rel, content, now) {
 export async function mergeCopies(options) {
     const { hqRoot, company, mode, now } = options;
     const index = buildEntityIndex(company.dir);
-    const found = findCopyPairs(index);
+    const pairKind = options.pairKind ?? "numbered";
+    const found = pairKind === "variants" ? findVariantPairs(index) : findCopyPairs(index);
     const pairs = options.limit !== undefined ? found.pairs.slice(0, Math.max(0, options.limit)) : found.pairs;
     const before = scanLinks(company).broken;
     const { plans, merges, finals, notReady } = plan(company, index, pairs, found.pairs, now);
     const report = {
         company: company.slug,
         mode,
+        pair_kind: pairKind,
         duplicate_groups_before: findDuplicateGroups(index).length,
         duplicate_groups_after: 0,
         copies_found: found.pairs.length,

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

@@ -0,0 +1,3 @@
+/** hq-flags keys used by lane list and placement behavior. */
+export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+//# sourceMappingURL=flag-keys.d.ts.map

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

@@ -0,0 +1,3 @@
+/** hq-flags keys used by lane list and placement behavior. */
+export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+//# sourceMappingURL=flag-keys.js.map

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

@@ -20,7 +20,7 @@ export { LANE_STORY_LEDGER_FLAG, buildLaneStatusSnapshot, formatLaneStatusHuman,
 export type { LaneStatusSnapshot, ProjectStoryLedger, StoryLedgerWriteDeps } from "./story-ledger.js";
 export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
 export type { OutpostDispatchResult, OutpostPickupPayload, } from "./outpost-dispatch.js";
-export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, syncLaneRecordFromOwner, updateLane, updateQuestion, withLaneHireLocks, } from "./store.js";
+export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readAllLanes, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, syncLaneRecordFromOwner, updateLane, updateQuestion, withLaneHireLocks, } from "./store.js";
 export type { StoreDeps } from "./store.js";
 export { DEFAULT_LANE_WATCH_INTERVAL_MS, MAX_LANE_WATCH_INTERVAL_MS, MAX_WATCHED_LANES, MAX_WATCH_OUTPUT_LINES, runLaneWatch, } from "./watch.js";
 export type { LaneWatchDeps, LaneWatchResult } from "./watch.js";

package/dist/lib/lanes/index.js

@@ -12,7 +12,7 @@ export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFT
 export { resolveLanesHqRoot } from "./hq-root.js";
 export { LANE_STORY_LEDGER_FLAG, buildLaneStatusSnapshot, formatLaneStatusHuman, laneStoryLedgerEnabled, resolveProjectStoryLedger, syncLaneToProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
 export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
-export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, syncLaneRecordFromOwner, updateLane, updateQuestion, withLaneHireLocks, } from "./store.js";
+export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readAllLanes, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, syncLaneRecordFromOwner, updateLane, updateQuestion, withLaneHireLocks, } from "./store.js";
 export { DEFAULT_LANE_WATCH_INTERVAL_MS, MAX_LANE_WATCH_INTERVAL_MS, MAX_WATCHED_LANES, MAX_WATCH_OUTPUT_LINES, runLaneWatch, } from "./watch.js";
 export { MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_TASK_OUTPUT_MAX_BYTES, MONITOR_TRANSCRIPT_MAX_BYTES, MONITOR_UNCOVERED_EXIT_CODE, coveredLaneIds, isMonitorTaskLive, monitorReminderText, parseCanonicalWatchCommand, parseMonitorTranscript, readLiveMonitorEvidence, } from "./monitor.js";
 export { IMDS_HOST, IMDS_INSTANCE_ID_URL, IMDS_TIMEOUT_MS, IMDS_TOKEN_URL, defaultReadImdsInstanceId, resolveMachineIdentity, } from "./machine-identity.js";

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -81,12 +81,20 @@ export declare function parseOutpostPickupPayload(raw: unknown): OutpostPickupPa
 export declare function buildOutpostPickupCommand(payloadUrl: string): string;
 /** Bounded, read-only capacity query executed by the target Outpost CLI. */
 export declare function buildOutpostCapacityCommand(): string;
+/**
+ * Marks a lane list that runs on an Outpost for another host. Such a list
+ * answers from the box's own records and never dispatches to other Outposts:
+ * two boxes that each hold a lane placed on the other would otherwise run
+ * lists on each other without end. `env` keeps older CLIs working, since they
+ * ignore the variable instead of rejecting an unknown flag.
+ */
+export declare const REMOTE_LANE_READ_ENV = "HQ_LANES_REMOTE_READ";
 /** Read lane records owned by an Outpost, using its configured HQ binary when set. */
 export declare function buildOutpostLaneListCommand(input?: {
     hqBinary?: string;
     laneIds?: readonly string[];
     active?: boolean;
-    hierarchy?: string;
+    hierarchy?: string | readonly string[];
     snapshot?: boolean;
 }): string;
 /** Read questions on one Outpost, scoped to a company when supplied. */

package/dist/lib/lanes/outpost-dispatch.js

@@ -65,9 +65,19 @@ export function buildOutpostPickupCommand(payloadUrl) {
 export function buildOutpostCapacityCommand() {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "capacity", "--json"]));
 }
+/**
+ * Marks a lane list that runs on an Outpost for another host. Such a list
+ * answers from the box's own records and never dispatches to other Outposts:
+ * two boxes that each hold a lane placed on the other would otherwise run
+ * lists on each other without end. `env` keeps older CLIs working, since they
+ * ignore the variable instead of rejecting an unknown flag.
+ */
+export const REMOTE_LANE_READ_ENV = "HQ_LANES_REMOTE_READ";
 /** Read lane records owned by an Outpost, using its configured HQ binary when set. */
 export function buildOutpostLaneListCommand(input = {}) {
     const args = [
+        "env",
+        `${REMOTE_LANE_READ_ENV}=1`,
         input.hqBinary?.trim() || "hq",
         "lanes",
         "list",
@@ -77,8 +87,10 @@ export function buildOutpostLaneListCommand(input = {}) {
         args.push("--lane", laneId);
     if (input.active)
         args.push("--active");
-    if (input.hierarchy !== undefined)
-        args.push("--hierarchy", input.hierarchy);
+    for (const laneId of typeof input.hierarchy === "string"
+        ? [input.hierarchy]
+        : input.hierarchy ?? [])
+        args.push("--hierarchy", laneId);
     if (input.snapshot)
         args.push("--snapshot");
     return withRemoteHqDir(joinCommandParts(args));

package/dist/lib/lanes/outpost-hire-cache.d.ts

@@ -1,4 +1,5 @@
 export declare const OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS = 60000;
+export declare const LANE_OUTPOST_SNAPSHOT_CACHE_FLAG = "lanes.outpost-snapshot-cache";
 export interface OutpostHireSummary {
     hire_grant: number;
     hire_alive_children: number;
@@ -13,6 +14,8 @@ export interface OutpostHireSummaryCacheEntry extends OutpostHireSummary {
 export declare function outpostHireSummaryCachePath(hqRoot: string): string;
 export declare function outpostHireSummaryCacheKey(outpostId: string, laneId: string): string;
 export declare function readOutpostHireSummaryCache(hqRoot: string, nowMs: number): Map<string, OutpostHireSummaryCacheEntry>;
+/** Reads the last validated summaries even after their freshness window expires. */
+export declare function readOutpostHireSummaryCacheIncludingStale(hqRoot: string, nowMs: number): Map<string, OutpostHireSummaryCacheEntry>;
 export declare function writeOutpostHireSummaryCache(hqRoot: string, updates: readonly (OutpostHireSummary & {
     outpost_id: string;
     lane_id: string;