@indigoai-us/hq-cli 5.313.0 → 5.314.0

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

@@ -1,25 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,147 +0,0 @@
-/**
- * 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[];
-    active?: boolean;
-    hierarchy?: string | readonly string[];
-    snapshot?: boolean;
-}): 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

@@ -1,271 +0,0 @@
-/**
- * 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);
-    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));
-}
-/** 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

@@ -1,22 +0,0 @@
-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