@indigoai-us/hq-cli 5.314.0 → 5.316.0

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

@@ -0,0 +1,25 @@
+import { type LaneRecord, type SeniorRef } from "./types.js";
+export declare const DEFAULT_ORPHAN_MIN_AGE_MINUTES = 30;
+export declare const DEFAULT_ORPHAN_USER_IDLE_HOURS = 72;
+export interface OrphanLaneFinding {
+    lane_id: string;
+    senior: SeniorRef;
+    senior_state: string;
+    age_minutes: number;
+    account: string | null;
+    host: LaneRecord["host"];
+    reason: "senior_ended" | "senior_missing" | "user_idle";
+}
+export declare function parseOrphanMinAge(value: string | undefined): number;
+export declare function parseOrphanUserIdleHours(value: string | undefined): number;
+export declare function findOrphanLanes(input: {
+    lanes: readonly LaneRecord[];
+    candidateLaneIds: ReadonlySet<string>;
+    now: Date;
+    minAgeMinutes: number;
+    userIdleHours: number;
+    sessionState: (sessionId: string, now: Date) => string | null;
+    lastActivityAt: (lane: LaneRecord) => number;
+    hasOpenStory: (lane: LaneRecord) => boolean;
+}): OrphanLaneFinding[];
+//# sourceMappingURL=orphans.d.ts.map

package/dist/lib/lanes/orphans.js

@@ -0,0 +1,102 @@
+import { LanesError } from "./errors.js";
+import { isTerminalLaneState } from "./types.js";
+export const DEFAULT_ORPHAN_MIN_AGE_MINUTES = 30;
+export const DEFAULT_ORPHAN_USER_IDLE_HOURS = 72;
+const LIVE_LANE_STATES = new Set(["running", "queued", "blocked", "awaiting_input"]);
+export function parseOrphanMinAge(value) {
+    if (value === undefined)
+        return DEFAULT_ORPHAN_MIN_AGE_MINUTES;
+    if (!/^(0|[1-9]\d*)$/.test(value)) {
+        throw new LanesError("orphan_min_age_invalid", "Minimum orphan age must be a non-negative whole number of minutes", { value });
+    }
+    const minutes = Number(value);
+    if (!Number.isSafeInteger(minutes) || minutes > Math.floor(Number.MAX_SAFE_INTEGER / 60_000)) {
+        throw new LanesError("orphan_min_age_invalid", "Minimum orphan age is outside the supported range", { value });
+    }
+    return minutes;
+}
+export function parseOrphanUserIdleHours(value) {
+    if (value === undefined)
+        return DEFAULT_ORPHAN_USER_IDLE_HOURS;
+    if (!/^(0|[1-9]\d*)$/.test(value)) {
+        throw new LanesError("orphan_user_idle_hours_invalid", "User-senior idle hours must be a non-negative whole number", { value });
+    }
+    const hours = Number(value);
+    if (!Number.isSafeInteger(hours) || hours > Math.floor(Number.MAX_SAFE_INTEGER / 3_600_000)) {
+        throw new LanesError("orphan_user_idle_hours_invalid", "User-senior idle hours are outside the supported range", { value });
+    }
+    return hours;
+}
+export function findOrphanLanes(input) {
+    const nowMs = input.now.getTime();
+    if (!Number.isFinite(nowMs)) {
+        throw new LanesError("orphan_clock_invalid", "Current time for orphan detection is invalid", {});
+    }
+    const byId = new Map(input.lanes.map((lane) => [lane.lane_id, lane]));
+    const minAgeMs = input.minAgeMinutes * 60_000;
+    const userIdleMs = input.userIdleHours * 3_600_000;
+    const findings = [];
+    for (const lane of input.lanes) {
+        if (!input.candidateLaneIds.has(lane.lane_id))
+            continue;
+        if (!LIVE_LANE_STATES.has(lane.state))
+            continue;
+        if (lane.keep_alive_standing === true)
+            continue;
+        let userLastActivity;
+        if (lane.senior.kind === "user") {
+            userLastActivity = input.lastActivityAt(lane);
+            if (!Number.isFinite(userLastActivity)) {
+                throw new LanesError("orphan_lane_timestamp_invalid", `Lane ${lane.lane_id} has an invalid last activity timestamp`, { lane_id: lane.lane_id, field: "last_activity" });
+            }
+            if (userLastActivity > nowMs || nowMs - userLastActivity < userIdleMs || input.hasOpenStory(lane))
+                continue;
+        }
+        const createdAt = Date.parse(lane.created_at);
+        if (!Number.isFinite(createdAt)) {
+            throw new LanesError("orphan_lane_timestamp_invalid", `Lane ${lane.lane_id} has an invalid created_at timestamp`, { lane_id: lane.lane_id, field: "created_at" });
+        }
+        const ageMs = nowMs - createdAt;
+        if (ageMs < 0) {
+            throw new LanesError("orphan_lane_timestamp_future", `Lane ${lane.lane_id} was created after the current time`, { lane_id: lane.lane_id, created_at: lane.created_at });
+        }
+        if (ageMs < minAgeMs)
+            continue;
+        let seniorState;
+        let reason;
+        if (lane.senior.kind === "user") {
+            seniorState = "user_idle";
+            reason = "user_idle";
+        }
+        else if (lane.senior.kind === "lane") {
+            const senior = byId.get(lane.senior.id ?? "");
+            if (!senior) {
+                seniorState = "missing";
+                reason = "senior_missing";
+            }
+            else if (isTerminalLaneState(senior.state)) {
+                seniorState = senior.state;
+                reason = "senior_ended";
+            }
+        }
+        else if (lane.senior.kind === "session" && lane.senior.id !== undefined) {
+            if (input.sessionState(lane.senior.id, input.now) === "ended") {
+                seniorState = "ended";
+                reason = "senior_ended";
+            }
+        }
+        if (seniorState === undefined || reason === undefined)
+            continue;
+        findings.push({
+            lane_id: lane.lane_id,
+            senior: { ...lane.senior },
+            senior_state: seniorState,
+            age_minutes: Math.floor(ageMs / 60_000),
+            account: lane.account ?? null,
+            host: { ...lane.host },
+            reason,
+        });
+    }
+    return findings.sort((a, b) => b.age_minutes - a.age_minutes || a.lane_id.localeCompare(b.lane_id));
+}
+//# sourceMappingURL=orphans.js.map

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

@@ -0,0 +1,156 @@
+/**
+ * Push an Outpost-targeted lane through `hq outposts exec` (spec §5.2).
+ *
+ * The transport is the existing OutpostsClient submit/wait pair — the same
+ * path as `hq outposts exec --async`. Create stages a payload, then runs
+ * `hq lanes pickup --payload-url` on the box. A submit or wait failure is
+ * `outpost_dispatch_failed`, never a queued lane nobody will pick up.
+ */
+import { OutpostsClient } from "@indigoai-us/hq-cloud/outposts";
+import type { LaneHost, LaneRecord } from "./types.js";
+export declare const PICKUP_EXEC_TIMEOUT_SECONDS = 120;
+export declare const PICKUP_WAIT_MS: number;
+export interface OutpostPickupPayload {
+    lane: LaneRecord;
+    brief: string;
+    timeout?: {
+        timeout_secs: number;
+        deadline_at: string;
+    };
+}
+export interface OutpostDispatchResult {
+    commandId: string;
+    status: string;
+    done?: boolean;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+export interface OutpostLaneCommand {
+    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target";
+    laneId: string;
+    hqBinary?: string;
+    text?: string;
+    project?: string;
+    story?: string;
+    account?: string;
+    model?: string;
+    effort?: string;
+    worker?: string;
+    fromFailed?: boolean;
+    failedResumeContext?: string;
+    keepAlive?: boolean;
+    hire?: string;
+    grantContext?: string;
+    profileRepinContext?: string;
+    approvalContext?: string;
+    senior?: string;
+    reason?: string;
+    compact?: boolean;
+    tail?: string;
+    json?: boolean;
+    callerLaneId?: string;
+    callerSessionId?: string;
+}
+export declare function buildOutpostQuestionAnswerCommand(input: {
+    questionId: string;
+    choice?: string;
+    freeform?: string;
+    notes?: string;
+    company?: string;
+    hqBinary?: string;
+}): string;
+export interface OutpostExecPort {
+    stageExecInput: (outpostId?: string) => Promise<{
+        putUrl: string;
+        getUrl: string;
+    }>;
+    submitExec: (command: string, outpostId?: string, timeoutSeconds?: number) => Promise<{
+        commandId: string;
+    }>;
+    waitForExecResult: (commandId: string, outpostId?: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        status: string;
+        done: boolean;
+        exitCode?: number | null;
+        stdout?: string;
+        stderr?: string;
+    }>;
+}
+export declare function parseOutpostPickupPayload(raw: unknown): OutpostPickupPayload;
+/** Same wrapping `hq outposts exec` applies: run from the box's HQ folder. */
+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[];
+    laneUlids?: readonly string[];
+    active?: boolean;
+    hierarchy?: string | readonly string[];
+    snapshot?: boolean;
+}): string;
+/**
+ * Older Outpost CLIs do not know --lane-ulid. Filter their lane-list output on
+ * the owner host so the exec transport carries only the requested record.
+ */
+export declare function buildOutpostLegacyLaneUlidListCommand(input: {
+    hqBinary?: string;
+    ulid: string;
+}): string;
+/** Read questions on one Outpost, scoped to a company when supplied. */
+export declare function buildOutpostQuestionListCommand(input?: {
+    company?: string;
+}): string;
+/** Read one question's body and owner-computed audience from its Outpost. */
+export declare function buildOutpostQuestionShowCommand(questionId: string): string;
+/** Cancel an owner-hosted question through the existing questions command. */
+export declare function buildOutpostQuestionCancelCommand(input: {
+    questionId: string;
+    reason: string;
+}): string;
+/** Commit a queued lane move on the host that currently owns its state. */
+export declare function buildOutpostMoveTargetCommand(input: {
+    laneId: string;
+    host: LaneHost;
+    account: string;
+}): string;
+/** Move an owned Claude session between accounts while leaving its turn parked. */
+export declare function buildOutpostBalanceMoveCommand(input: {
+    laneId: string;
+    account: string;
+    fromAccount: string;
+    expectedState: LaneRecord["state"];
+}): string;
+/** Idempotently backfill the marker on the selected Outpost. */
+export declare function buildOutpostIdentityBackfillCommand(expectedId: string): string;
+/** Build the same `hq outposts exec` remote command used by lane pickup. */
+export declare function buildOutpostLaneCommand(input: OutpostLaneCommand): string;
+/** True when a remote CLI exited after rejecting the forwarded effort flag. */
+export declare function outpostRejectedEffortOption(result: Pick<OutpostDispatchResult, "exitCode" | "stdout" | "stderr">): boolean;
+export declare function stageOutpostPayload(port: Pick<OutpostExecPort, "stageExecInput">, outpostId: string, bytes: Uint8Array, put?: typeof fetch): Promise<{
+    getUrl: string;
+}>;
+export declare function dispatchOutpostPickup(port: OutpostExecPort, input: {
+    outpostId: string;
+    command: string;
+    timeoutSeconds?: number;
+    waitMs?: number;
+}): Promise<OutpostDispatchResult>;
+export declare function dispatchErrorMessage(err: unknown): string;
+/** Factory matching `hq outposts exec`'s client wiring. */
+export declare function createOutpostsClient(opts: {
+    transport: ConstructorParameters<typeof OutpostsClient>[0]["transport"];
+    token: ConstructorParameters<typeof OutpostsClient>[0]["token"];
+}): OutpostsClient;
+//# sourceMappingURL=outpost-dispatch.d.ts.map

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

@@ -0,0 +1,293 @@
+/**
+ * Push an Outpost-targeted lane through `hq outposts exec` (spec §5.2).
+ *
+ * The transport is the existing OutpostsClient submit/wait pair — the same
+ * path as `hq outposts exec --async`. Create stages a payload, then runs
+ * `hq lanes pickup --payload-url` on the box. A submit or wait failure is
+ * `outpost_dispatch_failed`, never a queued lane nobody will pick up.
+ */
+import { OutpostsClient, joinCommandParts, withRemoteHqDir } from "@indigoai-us/hq-cloud/outposts";
+import { LanesError } from "./errors.js";
+export const PICKUP_EXEC_TIMEOUT_SECONDS = 120;
+export const PICKUP_WAIT_MS = PICKUP_EXEC_TIMEOUT_SECONDS * 1000;
+export function buildOutpostQuestionAnswerCommand(input) {
+    const args = [
+        input.hqBinary?.trim() || "hq",
+        "lanes",
+        "questions",
+        "answer",
+        input.questionId,
+    ];
+    for (const [flag, value] of [
+        ["--choice", input.choice],
+        ["--freeform", input.freeform],
+        ["--notes", input.notes],
+        ["--company", input.company],
+    ]) {
+        if (value !== undefined)
+            args.push(flag, value);
+    }
+    return withRemoteHqDir(joinCommandParts(args));
+}
+export function parseOutpostPickupPayload(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new LanesError("outpost_payload_invalid", "Outpost pickup payload must be a JSON object", {});
+    }
+    const body = raw;
+    if (body.lane === null || typeof body.lane !== "object" || Array.isArray(body.lane)) {
+        throw new LanesError("outpost_payload_invalid", "Outpost pickup payload.lane must be an object", {});
+    }
+    if (typeof body.brief !== "string") {
+        throw new LanesError("outpost_payload_invalid", "Outpost pickup payload.brief must be a string", {});
+    }
+    let timeout;
+    if (body.timeout !== undefined && body.timeout !== null) {
+        if (typeof body.timeout !== "object" || Array.isArray(body.timeout)) {
+            throw new LanesError("outpost_payload_invalid", "Outpost pickup payload.timeout must be an object", {});
+        }
+        const t = body.timeout;
+        if (typeof t.timeout_secs !== "number" || typeof t.deadline_at !== "string") {
+            throw new LanesError("outpost_payload_invalid", "Outpost pickup payload.timeout needs timeout_secs and deadline_at", {});
+        }
+        timeout = { timeout_secs: t.timeout_secs, deadline_at: t.deadline_at };
+    }
+    return {
+        lane: body.lane,
+        brief: body.brief,
+        timeout,
+    };
+}
+/** Same wrapping `hq outposts exec` applies: run from the box's HQ folder. */
+export function buildOutpostPickupCommand(payloadUrl) {
+    return withRemoteHqDir(joinCommandParts(["hq", "lanes", "pickup", "--payload-url", payloadUrl]));
+}
+/** Bounded, read-only capacity query executed by the target Outpost CLI. */
+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",
+        "--json",
+    ];
+    for (const laneId of input.laneIds ?? [])
+        args.push("--lane", laneId);
+    for (const ulid of input.laneUlids ?? [])
+        args.push("--lane-ulid", ulid);
+    if (input.active)
+        args.push("--active");
+    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));
+}
+/**
+ * Older Outpost CLIs do not know --lane-ulid. Filter their lane-list output on
+ * the owner host so the exec transport carries only the requested record.
+ */
+export function buildOutpostLegacyLaneUlidListCommand(input) {
+    const hqBinary = input.hqBinary?.trim() || "hq";
+    const script = [
+        "const { spawnSync } = require('node:child_process');",
+        `const result = spawnSync(${JSON.stringify(hqBinary)}, ['lanes', 'list', '--json'], { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, env: { ...process.env, ${REMOTE_LANE_READ_ENV}: '1' } });`,
+        "if (result.error || result.status !== 0) { console.error(JSON.stringify({ error: result.error?.message || 'legacy Outpost lane list failed', status: result.status, signal: result.signal, stderr_tail: String(result.stderr || '').slice(-4096), stdout_tail: String(result.stdout || '').slice(-4096) })); process.exit(result.status || 1); }",
+        "try {",
+        "const payload = JSON.parse(result.stdout);",
+        "if (!payload || payload.ok !== true || payload.action !== 'list' || !Array.isArray(payload.lanes)) throw new Error('malformed lane list');",
+        `const ulid = ${JSON.stringify(input.ulid.toUpperCase())};`,
+        "payload.lanes = payload.lanes.filter(row => row && typeof row.lane_id === 'string' && row.lane_id.slice(0, 26).toUpperCase() === ulid);",
+        "process.stdout.write(JSON.stringify(payload));",
+        "} catch (error) { console.error('Legacy Outpost returned invalid lane-list JSON: ' + (error instanceof Error ? error.message : String(error))); process.exit(1); }",
+    ].join("\n");
+    return withRemoteHqDir(joinCommandParts(["node", "-e", script]));
+}
+/** Read questions on one Outpost, scoped to a company when supplied. */
+export function buildOutpostQuestionListCommand(input = {}) {
+    const args = ["hq", "lanes", "questions", "list"];
+    const company = input.company?.trim();
+    if (company)
+        args.push("--company", company);
+    return withRemoteHqDir(joinCommandParts(args));
+}
+/** Read one question's body and owner-computed audience from its Outpost. */
+export function buildOutpostQuestionShowCommand(questionId) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "questions",
+        "show",
+        questionId,
+    ]));
+}
+/** Cancel an owner-hosted question through the existing questions command. */
+export function buildOutpostQuestionCancelCommand(input) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "questions",
+        "cancel",
+        input.questionId,
+        "--reason",
+        input.reason,
+    ]));
+}
+/** Commit a queued lane move on the host that currently owns its state. */
+export function buildOutpostMoveTargetCommand(input) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "move-target",
+        input.laneId,
+        "--host-kind",
+        input.host.kind,
+        "--host-id",
+        input.host.id,
+        "--account",
+        input.account,
+    ]));
+}
+/** Move an owned Claude session between accounts while leaving its turn parked. */
+export function buildOutpostBalanceMoveCommand(input) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "balance-move-target",
+        input.laneId,
+        "--account",
+        input.account,
+        "--from-account",
+        input.fromAccount,
+        "--expected-state",
+        input.expectedState,
+    ]));
+}
+/** Idempotently backfill the marker on the selected Outpost. */
+export function buildOutpostIdentityBackfillCommand(expectedId) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "outpost-identity-backfill-target",
+        "--expected-id",
+        expectedId,
+    ]));
+}
+/** Build the same `hq outposts exec` remote command used by lane pickup. */
+export function buildOutpostLaneCommand(input) {
+    const args = [
+        input.hqBinary?.trim() || "hq",
+        "lanes",
+        input.action,
+        input.laneId,
+    ];
+    for (const [flag, value] of [
+        ["--text", input.text],
+        ["--project", input.project],
+        ["--story", input.story],
+        ["--account", input.account],
+        ["--model", input.model],
+        ["--effort", input.effort],
+        ["--worker", input.worker],
+        ["--hire", input.hire],
+        ["--grant-context", input.grantContext],
+        ["--profile-repin-context", input.profileRepinContext],
+        ["--approval-context", input.approvalContext],
+        ["--failed-resume-context", input.failedResumeContext],
+        ["--senior", input.senior],
+        ["--reason", input.reason],
+    ]) {
+        if (value !== undefined)
+            args.push(flag, value);
+    }
+    if (input.action === "resume" && input.fromFailed === true)
+        args.push("--from-failed");
+    if (input.action === "resume" && input.keepAlive === true)
+        args.push("--keep-alive");
+    if (input.compact === false)
+        args.push("--no-compact");
+    if (input.action === "logs" && input.tail !== undefined)
+        args.push("--tail", input.tail);
+    if (input.action === "logs" && input.json === true)
+        args.push("--json");
+    const callerLaneId = input.callerLaneId?.trim();
+    const callerSessionId = input.callerSessionId?.trim();
+    const callerEnv = [
+        callerLaneId ? `HQ_LANE_ID=${callerLaneId}` : undefined,
+        callerSessionId ? `HQ_SESSION_ID=${callerSessionId}` : undefined,
+    ].filter((value) => value !== undefined);
+    return withRemoteHqDir(joinCommandParts(callerEnv.length > 0 ? ["env", ...callerEnv, ...args] : args));
+}
+/** True when a remote CLI exited after rejecting the forwarded effort flag. */
+export function outpostRejectedEffortOption(result) {
+    if (result.exitCode === 0)
+        return false;
+    return /(?:unknown|unrecognized) option[^\n]{0,120}--effort/i.test(`${result.stderr}\n${result.stdout}`);
+}
+export async function stageOutpostPayload(port, outpostId, bytes, put = fetch) {
+    const staged = await port.stageExecInput(outpostId);
+    const upload = await put(staged.putUrl, {
+        method: "PUT",
+        headers: { "Content-Length": String(bytes.byteLength) },
+        body: bytes,
+    });
+    if (!upload.ok) {
+        throw new LanesError("outpost_dispatch_failed", `Could not upload lane payload: HTTP ${upload.status}`, { status: upload.status, outpost_id: outpostId });
+    }
+    return { getUrl: staged.getUrl };
+}
+export async function dispatchOutpostPickup(port, input) {
+    const submitted = await port.submitExec(input.command, input.outpostId, input.timeoutSeconds ?? PICKUP_EXEC_TIMEOUT_SECONDS);
+    const ac = new AbortController();
+    const waitMs = input.waitMs ?? PICKUP_WAIT_MS;
+    const timer = setTimeout(() => ac.abort(), waitMs);
+    try {
+        const result = await port.waitForExecResult(submitted.commandId, input.outpostId, { signal: ac.signal });
+        return {
+            commandId: submitted.commandId,
+            status: result.status,
+            done: result.done,
+            exitCode: result.exitCode ?? null,
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+        };
+    }
+    catch (err) {
+        const outcomeDetails = {
+            outpost_id: input.outpostId,
+            command_id: submitted.commandId,
+            done: false,
+            outcome_unknown: true,
+        };
+        if (ac.signal.aborted) {
+            throw new LanesError("outpost_dispatch_failed", `Timed out waiting for Outpost pickup (${waitMs}ms)`, outcomeDetails);
+        }
+        const message = dispatchErrorMessage(err);
+        throw new LanesError("outpost_dispatch_failed", `Failed waiting for Outpost pickup: ${message}`, { ...outcomeDetails, message });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function dispatchErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Factory matching `hq outposts exec`'s client wiring. */
+export function createOutpostsClient(opts) {
+    return new OutpostsClient(opts);
+}
+//# sourceMappingURL=outpost-dispatch.js.map

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

@@ -0,0 +1,22 @@
+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>;
+/** 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;
+})[], nowMs: number, existingEntries?: ReadonlyMap<string, OutpostHireSummaryCacheEntry>): void;
+//# sourceMappingURL=outpost-hire-cache.d.ts.map