@indigoai-us/hq-cli 5.199.0 → 5.200.1

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [5.200.1] — 2026-09-25
+
+### Fixed
+
+- `hq lanes questions show` and `answer` preserve `question_not_found` when
+  Outpost question visibility is disabled, even if an owned Outpost lane has
+  no company. `questions list --all-hosts` also omits the company-unavailable
+  error while the gate is off.
+
+## [5.200.0] — 2026-09-25
+
+### Fixed
+
+- `hq lanes list` now fetches Outpost hire summaries once per host and reuses
+  them for 60 seconds. Missing or invalid owner rows keep the local summary and
+  include a warning.
+
 ## [5.199.0] — 2026-09-25
 
 ### Added
@@ -15,8 +32,6 @@
   company-scoped `lanes.outpost-question-visibility` hq-flags gate. Use
   `--company` to limit a list or answer to one company.
 
-## [5.198.1] — 2026-09-25
-
 ### Fixed
 
 - Registry-backed hq-flags readers now use the central registry endpoint when
@@ -24,6 +39,18 @@
   keep precedence, and process-wide gates retain their legacy fallback until a
   registry snapshot is ready.
 
+## [5.198.1] — 2026-09-25
+
+### Fixed
+
+- Session questions stay with live or unknown sessions until their configured
+  unanswered timeout; only a positive `session_end` advances immediately. When
+  there is no Work Mesh entry, hq-cli checks Claude transcript metadata in
+  configured account homes without opening transcript contents, using the
+  newest matching mtime. Metadata errors remain visible and do not block the
+  independent timeout. The timeout defaults to 600 seconds. A running-lane
+  answer reports `awaiting_next_tool_call` after its durable dropbox append.
+
 ## [5.198.0] — 2026-09-25
 
 ### Added
@@ -47,13 +74,6 @@
   `result` / `error.message` / `subtype` — instead of the last characters of
   the JSON tail (`"costUsdTicks" | } | "numTurns" | }`). Log only; never
   posted to a person.
-- Session questions stay with live or unknown sessions until their configured
-  unanswered timeout; only a positive `session_end` advances immediately. When
-  there is no Work Mesh entry, hq-cli checks Claude transcript metadata in
-  configured account homes without opening transcript contents, using the
-  newest matching mtime. Metadata errors remain visible and do not block the
-  independent timeout. The timeout defaults to 600 seconds. A running-lane
-  answer reports `awaiting_next_tool_call` after its durable dropbox append.
 
 ## [5.197.0] — 2026-09-25
 

package/dist/commands/lanes.js

@@ -23,6 +23,7 @@ import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
 export { LANE_HIRE_GRANTS_FLAG };
 import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostQuestionAnswerCommand, buildOutpostQuestionListCommand, buildOutpostQuestionShowCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { outpostHireSummaryCacheKey, readOutpostHireSummaryCache, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { BALANCE_MOVABLE_STATES, CLAUDE_ACCOUNT_BALANCE_FLAG, accountLoadsForReport, assertBalanceApplyEnabled, planClaudeBalanceMoves, selectClaudeAccount, } from "../lib/lanes/claude-account-balance.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
@@ -578,6 +579,32 @@ function normalizeLaneRecordView(raw) {
     return normalized;
 }
 async function ownerLaneHireFields(ctx, lane) {
+    if (lane.host.kind !== "outpost") {
+        throw new LanesError("outpost_lane_hire_summary_invalid", "Owner summary requires an Outpost-hosted lane", {
+            lane_id: lane.lane_id,
+        });
+    }
+    const nowMs = ctx.now().getTime();
+    const cachedEntries = readOutpostHireSummaryCache(ctx.hqRoot(), nowMs);
+    const cached = cachedEntries.get(outpostHireSummaryCacheKey(lane.host.id, lane.lane_id));
+    if (cached) {
+        return {
+            hire_grant: cached.hire_grant,
+            hire_alive_children: cached.hire_alive_children,
+            hire: cached.hire,
+            hire_summary: cached.hire_summary,
+        };
+    }
+    const fields = await fetchOwnerLaneHireFields(ctx, lane);
+    const cachedAtMs = ctx.now().getTime();
+    writeOutpostHireSummaryCache(ctx.hqRoot(), [{
+            outpost_id: lane.host.id,
+            lane_id: lane.lane_id,
+            ...fields,
+        }], cachedAtMs, cachedEntries);
+    return fields;
+}
+async function fetchOwnerLaneHireFields(ctx, lane) {
     if (lane.host.kind !== "outpost") {
         throw new LanesError("outpost_lane_hire_summary_invalid", "Owner summary requires an Outpost-hosted lane", {
             lane_id: lane.lane_id,
@@ -608,25 +635,42 @@ async function ownerLaneHireFields(ctx, lane) {
     if (!remote || remote.ok !== true || remote.action !== "show") {
         throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid hire summary for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, command_id: dispatched.commandId });
     }
+    return validateOwnerLaneHireSummary({
+        outpostId,
+        laneId: lane.lane_id,
+        rawLane: remote.lane,
+        hireGrant: remote.hire_grant,
+        hireAliveChildren: remote.hire_alive_children,
+        hire: remote.hire,
+        hireSummary: remote.hire_summary,
+        commandId: dispatched.commandId,
+    });
+}
+function validateOwnerLaneHireSummary(input) {
     let ownerLane;
     try {
-        ownerLane = parseLaneRecord(normalizeLaneRecordView(remote.lane));
+        ownerLane = parseLaneRecord(normalizeLaneRecordView(input.rawLane));
     }
     catch (err) {
-        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid lane snapshot for ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, cause: dispatchErrorMessage(err) });
+        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${input.outpostId} returned an invalid lane snapshot for ${input.laneId}`, {
+            lane_id: input.laneId,
+            outpost_id: input.outpostId,
+            command_id: input.commandId,
+            cause: dispatchErrorMessage(err),
+        });
     }
-    const grant = remote.hire_grant;
-    const alive = remote.hire_alive_children;
-    if (ownerLane.lane_id !== lane.lane_id ||
+    const grant = input.hireGrant;
+    const alive = input.hireAliveChildren;
+    if (ownerLane.lane_id !== input.laneId ||
         ownerLane.host.kind !== "outpost" ||
-        ownerLane.host.id !== outpostId ||
+        ownerLane.host.id !== input.outpostId ||
         !Number.isSafeInteger(grant) ||
         grant < 0 ||
         !Number.isSafeInteger(alive) ||
         alive < 0 ||
-        remote.hire !== `${String(alive)}/${String(grant)}` ||
-        remote.hire_summary !== `hire ${String(alive)}/${String(grant)}`) {
-        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an inconsistent hire summary for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, command_id: dispatched.commandId });
+        input.hire !== `${String(alive)}/${String(grant)}` ||
+        input.hireSummary !== `hire ${String(alive)}/${String(grant)}`) {
+        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${input.outpostId} returned an inconsistent hire summary for lane ${input.laneId}`, { lane_id: input.laneId, outpost_id: input.outpostId, command_id: input.commandId });
     }
     return {
         hire_grant: grant,
@@ -635,6 +679,116 @@ async function ownerLaneHireFields(ctx, lane) {
         hire_summary: `hire ${alive}/${grant}`,
     };
 }
+async function fetchOutpostListHireSummaries(ctx, outpostId, lanes) {
+    const fallback = (error) => new Map(lanes.map((lane) => [lane.lane_id, {
+            error: new LanesError(error.error, error.message, {
+                ...error.details,
+                outpost_id: outpostId,
+                lane_id: lane.lane_id,
+            }),
+        }]));
+    let hqBinary;
+    try {
+        hqBinary = outpostCliOverride(ctx, outpostId);
+    }
+    catch (err) {
+        if (isLanesError(err))
+            return fallback(err);
+        return fallback(new LanesError("outpost_lane_hire_summary_unavailable", `Could not read hire summaries from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId }));
+    }
+    let dispatched;
+    try {
+        // No filters: the owner list must return every lane requested by this host group.
+        dispatched = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostLaneListCommand({ hqBinary }),
+            timeoutSeconds: OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS,
+            waitMs: OUTPOST_HIRE_SUMMARY_WAIT_MS,
+        });
+    }
+    catch (err) {
+        return fallback(new LanesError("outpost_lane_hire_summary_unavailable", `Could not read hire summaries from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId }));
+    }
+    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+        return fallback(new LanesError("outpost_lane_hire_summary_unavailable", `Outpost ${outpostId} did not confirm its lane list for hire summaries`, { outpost_id: outpostId, command_id: dispatched.commandId }));
+    }
+    const remote = parseRemoteJson(dispatched.stdout, "Outpost lane hire summary list");
+    if (!remote || remote.ok !== true || remote.action !== "list" || !Array.isArray(remote.lanes)) {
+        return fallback(new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid lane list for hire summaries`, { outpost_id: outpostId, command_id: dispatched.commandId }));
+    }
+    const outcomes = new Map();
+    for (const lane of lanes) {
+        const matchingRows = remote.lanes.filter((row) => row !== null && typeof row === "object" && !Array.isArray(row) &&
+            row.lane_id === lane.lane_id);
+        if (matchingRows.length === 0) {
+            outcomes.set(lane.lane_id, { error: new LanesError("outpost_lane_hire_summary_missing", `Outpost ${outpostId} did not return lane ${lane.lane_id} in its lane list`, { outpost_id: outpostId, lane_id: lane.lane_id, command_id: dispatched.commandId }) });
+            continue;
+        }
+        if (matchingRows.length !== 1) {
+            outcomes.set(lane.lane_id, { error: new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned duplicate lane rows for ${lane.lane_id}`, { outpost_id: outpostId, lane_id: lane.lane_id, command_id: dispatched.commandId }) });
+            continue;
+        }
+        const row = matchingRows[0];
+        try {
+            outcomes.set(lane.lane_id, { fields: validateOwnerLaneHireSummary({
+                    outpostId,
+                    laneId: lane.lane_id,
+                    rawLane: row,
+                    hireGrant: row.hire_grant,
+                    hireAliveChildren: row.hire_alive_children,
+                    hire: row.hire,
+                    hireSummary: row.hire_summary,
+                    commandId: dispatched.commandId,
+                }) });
+        }
+        catch (err) {
+            outcomes.set(lane.lane_id, { error: isLanesError(err)
+                    ? err
+                    : new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid hire summary for lane ${lane.lane_id}`, { outpost_id: outpostId, lane_id: lane.lane_id, command_id: dispatched.commandId }) });
+        }
+    }
+    return outcomes;
+}
+async function batchOwnerLaneHireFields(ctx, lanes) {
+    const outcomes = new Map();
+    const groups = new Map();
+    const nowMs = ctx.now().getTime();
+    const cached = readOutpostHireSummaryCache(ctx.hqRoot(), nowMs);
+    for (const lane of lanes) {
+        if (lane.host.kind !== "outpost")
+            continue;
+        const cachedSummary = cached.get(outpostHireSummaryCacheKey(lane.host.id, lane.lane_id));
+        if (cachedSummary) {
+            outcomes.set(lane.lane_id, {
+                fields: {
+                    hire_grant: cachedSummary.hire_grant,
+                    hire_alive_children: cachedSummary.hire_alive_children,
+                    hire: cachedSummary.hire,
+                    hire_summary: cachedSummary.hire_summary,
+                },
+            });
+            continue;
+        }
+        const group = groups.get(lane.host.id) ?? [];
+        group.push(lane);
+        groups.set(lane.host.id, group);
+    }
+    const fetchedGroups = await mapWithConcurrency([...groups.entries()], OUTPOST_HIRE_SUMMARY_CONCURRENCY, ([outpostId, group]) => fetchOutpostListHireSummaries(ctx, outpostId, group));
+    const cacheUpdates = [];
+    for (const groupOutcomes of fetchedGroups) {
+        for (const [laneId, outcome] of groupOutcomes) {
+            outcomes.set(laneId, outcome);
+            if ("fields" in outcome) {
+                const lane = lanes.find((candidate) => candidate.lane_id === laneId);
+                if (lane?.host.kind === "outpost") {
+                    cacheUpdates.push({ outpost_id: lane.host.id, lane_id: laneId, ...outcome.fields });
+                }
+            }
+        }
+    }
+    writeOutpostHireSummaryCache(ctx.hqRoot(), cacheUpdates, ctx.now().getTime(), cached);
+    return outcomes;
+}
 const OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS = 20;
 const OUTPOST_HIRE_SUMMARY_WAIT_MS = 15_000;
 const OUTPOST_HIRE_SUMMARY_CONCURRENCY = 4;
@@ -3681,6 +3835,7 @@ async function runList(ctx, opts) {
         return true;
     })
         .sort(compareLaneQueueOrder);
+    const ownerEligibleLaneIds = new Set();
     const companyContexts = new Map();
     for (const lane of selectedLanes) {
         if (lane.host.kind !== "outpost" ||
@@ -3688,14 +3843,58 @@ async function runList(ctx, opts) {
             laneRunsHere(lane, host)) {
             continue;
         }
-        const company = lane.company;
-        companyContexts.set(JSON.stringify([company?.uid ?? null, company?.slug ?? null]), company);
+        const companyKey = JSON.stringify([
+            lane.company?.uid ?? null,
+            lane.company?.slug ?? null,
+        ]);
+        ownerEligibleLaneIds.add(lane.lane_id);
+        companyContexts.set(companyKey, lane.company);
+    }
+    const enabledByCompany = new Map(await Promise.all([...companyContexts.entries()].map(async ([companyKey, company]) => [
+        companyKey,
+        await ctx.laneHireGrantsEnabled(company),
+    ])));
+    const ownerLanes = [];
+    const hireByLane = new Map();
+    for (const lane of selectedLanes) {
+        if (!ownerEligibleLaneIds.has(lane.lane_id)) {
+            hireByLane.set(lane.lane_id, {
+                ...laneHireFields(lane, allLanes),
+                hire_source: "local",
+            });
+            continue;
+        }
+        const companyKey = JSON.stringify([
+            lane.company?.uid ?? null,
+            lane.company?.slug ?? null,
+        ]);
+        if (enabledByCompany.get(companyKey))
+            ownerLanes.push(lane);
+        else {
+            hireByLane.set(lane.lane_id, {
+                ...laneHireFields(lane, allLanes),
+                hire_source: "local",
+            });
+        }
+    }
+    if (ownerLanes.length > 0) {
+        const ownerSummaries = await batchOwnerLaneHireFields(ctx, ownerLanes);
+        for (const lane of ownerLanes) {
+            const outcome = ownerSummaries.get(lane.lane_id);
+            if (outcome && "fields" in outcome) {
+                hireByLane.set(lane.lane_id, { ...outcome.fields, hire_source: "owner" });
+                continue;
+            }
+            const error = outcome && "error" in outcome
+                ? outcome.error
+                : new LanesError("outpost_lane_hire_summary_missing", `No owner hire summary was returned for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: lane.host.id });
+            hireByLane.set(lane.lane_id, {
+                ...laneHireFields(lane, allLanes),
+                hire_source: "local",
+                hire_warning: `${error.error}: ${error.message}`,
+            });
+        }
     }
-    await Promise.all([...companyContexts.values()].map((company) => ctx.laneHireGrantsEnabled(company)));
-    const hireByLane = new Map(await mapWithConcurrency(selectedLanes, OUTPOST_HIRE_SUMMARY_CONCURRENCY, async (lane) => [
-        lane.lane_id,
-        await laneHirePresentation(ctx, lane, allLanes),
-    ]));
     const lanes = selectedLanes.map((lane) => {
         const remoteQueued = lane.state === "queued" &&
             lane.host.kind === "outpost" &&
@@ -6809,15 +7008,17 @@ async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
     const eligibleGroups = [];
     for (const [outpostId, lanes] of [...lanesByOutpost.entries()].sort(([a], [b]) => a.localeCompare(b))) {
         for (const group of groupQuestionLanesByCompany(lanes)) {
-            if (companyFilter && !questionCompanyRefMatches(group.company, companyFilter))
-                continue;
             if (group.company === null) {
-                errors.push({
-                    host: `outpost:${outpostId}`,
-                    error: "outpost_question_company_unavailable",
-                });
+                if (await ctx.laneOutpostQuestionVisibilityEnabled(null)) {
+                    errors.push({
+                        host: `outpost:${outpostId}`,
+                        error: "outpost_question_company_unavailable",
+                    });
+                }
                 continue;
             }
+            if (companyFilter && !questionCompanyRefMatches(group.company, companyFilter))
+                continue;
             if (await ctx.laneOutpostQuestionVisibilityEnabled(group.company)) {
                 eligibleGroups.push({ outpostId, group });
             }

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

@@ -72,8 +72,10 @@ 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;
-/** Read the lane records owned by an Outpost for exact per-account state counts. */
-export declare function buildOutpostLaneListCommand(): string;
+/** Read every lane on an Outpost, optionally using its configured HQ binary. */
+export declare function buildOutpostLaneListCommand(input?: {
+    hqBinary?: string;
+}): string;
 /** Read questions on one Outpost, scoped to a company when supplied. */
 export declare function buildOutpostQuestionListCommand(input?: {
     company?: string;

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

@@ -65,9 +65,14 @@ export function buildOutpostPickupCommand(payloadUrl) {
 export function buildOutpostCapacityCommand() {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "capacity", "--json"]));
 }
-/** Read the lane records owned by an Outpost for exact per-account state counts. */
-export function buildOutpostLaneListCommand() {
-    return withRemoteHqDir(joinCommandParts(["hq", "lanes", "list", "--json"]));
+/** Read every lane on an Outpost, optionally using its configured HQ binary. */
+export function buildOutpostLaneListCommand(input = {}) {
+    return withRemoteHqDir(joinCommandParts([
+        input.hqBinary?.trim() || "hq",
+        "lanes",
+        "list",
+        "--json",
+    ]));
 }
 /** Read questions on one Outpost, scoped to a company when supplied. */
 export function buildOutpostQuestionListCommand(input = {}) {

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

@@ -0,0 +1,20 @@
+export declare const OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS = 60000;
+export interface OutpostHireSummary {
+    hire_grant: number;
+    hire_alive_children: number;
+    hire: string;
+    hire_summary: string;
+}
+export interface OutpostHireSummaryCacheEntry extends OutpostHireSummary {
+    outpost_id: string;
+    lane_id: string;
+    cached_at: string;
+}
+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>;
+export declare function writeOutpostHireSummaryCache(hqRoot: string, updates: readonly (OutpostHireSummary & {
+    outpost_id: string;
+    lane_id: string;
+})[], nowMs: number, existingEntries?: ReadonlyMap<string, OutpostHireSummaryCacheEntry>): void;
+//# sourceMappingURL=outpost-hire-cache.d.ts.map

package/dist/lib/lanes/outpost-hire-cache.js

@@ -0,0 +1,146 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS = 60_000;
+const CACHE_RELATIVE_PATH = path.join("workspace", "lanes-runs", ".cache", "outpost-hire-summaries.json");
+export function outpostHireSummaryCachePath(hqRoot) {
+    return path.join(hqRoot, CACHE_RELATIVE_PATH);
+}
+export function outpostHireSummaryCacheKey(outpostId, laneId) {
+    return JSON.stringify([outpostId, laneId]);
+}
+export function readOutpostHireSummaryCache(hqRoot, nowMs) {
+    const filePath = outpostHireSummaryCachePath(hqRoot);
+    let contents;
+    try {
+        contents = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        if (isMissingFile(err))
+            return new Map();
+        console.warn(`Ignoring unreadable Outpost hire summary cache at ${filePath}: ${errorText(err)}`);
+        return new Map();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (err) {
+        console.warn(`Ignoring malformed Outpost hire summary cache at ${filePath}: ${errorText(err)}`);
+        return new Map();
+    }
+    if (!Array.isArray(parsed)) {
+        console.warn(`Ignoring malformed Outpost hire summary cache at ${filePath}: expected an array`);
+        return new Map();
+    }
+    const entries = new Map();
+    const duplicates = new Set();
+    for (const value of parsed) {
+        const entry = parseCacheEntry(value, nowMs);
+        if (!entry)
+            continue;
+        const key = outpostHireSummaryCacheKey(entry.outpost_id, entry.lane_id);
+        if (entries.has(key)) {
+            entries.delete(key);
+            duplicates.add(key);
+            continue;
+        }
+        if (!duplicates.has(key))
+            entries.set(key, entry);
+    }
+    return entries;
+}
+export function writeOutpostHireSummaryCache(hqRoot, updates, nowMs, existingEntries) {
+    if (updates.length === 0)
+        return;
+    const filePath = outpostHireSummaryCachePath(hqRoot);
+    const cached = new Map(existingEntries ?? readOutpostHireSummaryCache(hqRoot, nowMs));
+    for (const update of updates) {
+        const entry = {
+            outpost_id: update.outpost_id,
+            lane_id: update.lane_id,
+            hire_grant: update.hire_grant,
+            hire_alive_children: update.hire_alive_children,
+            hire: update.hire,
+            hire_summary: update.hire_summary,
+            cached_at: new Date(nowMs).toISOString(),
+        };
+        if (!parseCacheEntry(entry, nowMs))
+            continue;
+        cached.set(outpostHireSummaryCacheKey(entry.outpost_id, entry.lane_id), entry);
+    }
+    const directory = path.dirname(filePath);
+    let temporaryPath;
+    try {
+        fs.mkdirSync(directory, { recursive: true });
+        temporaryPath = path.join(directory, `.outpost-hire-summaries.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+        fs.writeFileSync(temporaryPath, `${JSON.stringify([...cached.values()])}\n`, {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        fs.renameSync(temporaryPath, filePath);
+    }
+    catch (err) {
+        if (temporaryPath) {
+            try {
+                fs.unlinkSync(temporaryPath);
+            }
+            catch (cleanupErr) {
+                if (!isMissingFile(cleanupErr)) {
+                    console.warn(`Could not remove temporary Outpost hire summary cache ${temporaryPath}: ${errorText(cleanupErr)}`);
+                }
+            }
+        }
+        console.warn(`Could not write Outpost hire summary cache at ${filePath}: ${errorText(err)}`);
+    }
+}
+function parseCacheEntry(value, nowMs) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const entry = value;
+    const allowedKeys = new Set([
+        "outpost_id",
+        "lane_id",
+        "hire_grant",
+        "hire_alive_children",
+        "hire",
+        "hire_summary",
+        "cached_at",
+    ]);
+    if (Object.keys(entry).length !== allowedKeys.size || Object.keys(entry).some((key) => !allowedKeys.has(key))) {
+        return undefined;
+    }
+    if (typeof entry.outpost_id !== "string" || !entry.outpost_id.trim() ||
+        typeof entry.lane_id !== "string" || !entry.lane_id.trim() ||
+        !Number.isSafeInteger(entry.hire_grant) || entry.hire_grant < 0 ||
+        !Number.isSafeInteger(entry.hire_alive_children) || entry.hire_alive_children < 0 ||
+        typeof entry.cached_at !== "string") {
+        return undefined;
+    }
+    const cachedAt = Date.parse(entry.cached_at);
+    if (!Number.isFinite(cachedAt) ||
+        cachedAt > nowMs ||
+        nowMs - cachedAt > OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS) {
+        return undefined;
+    }
+    const hire = `${entry.hire_alive_children}/${entry.hire_grant}`;
+    const hireSummary = `hire ${hire}`;
+    if (entry.hire !== hire || entry.hire_summary !== hireSummary)
+        return undefined;
+    return {
+        outpost_id: entry.outpost_id,
+        lane_id: entry.lane_id,
+        hire_grant: entry.hire_grant,
+        hire_alive_children: entry.hire_alive_children,
+        hire,
+        hire_summary: hireSummary,
+        cached_at: entry.cached_at,
+    };
+}
+function isMissingFile(err) {
+    return err !== null && typeof err === "object" && "code" in err && err.code === "ENOENT";
+}
+function errorText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=outpost-hire-cache.js.map

package/package.json

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