@indigoai-us/hq-cli 5.126.0 → 5.127.0

package/dist/lib/lanes/config.js

@@ -9,6 +9,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { parseConfigEffort } from "./effort.js";
 import { LanesConfigError } from "./errors.js";
 import { CONFIG_SCHEMA_VERSION, LANE_PROVIDERS, isLaneProvider, parseMajorSchema, } from "./types.js";
 export const LANES_CONFIG_REL = path.join("personal", "lanes", "config.json");
@@ -16,6 +17,17 @@ export const DEFAULT_MAX_QUEUED = 3;
 export const DEFAULT_CPU_BUSY_PAUSE = 0.85;
 export const DEFAULT_CPU_BUSY_RESUME = 0.7;
 export const DEFAULT_MIN_AVAILABLE_MEM_MB = 1024;
+/**
+ * Owner directive 2026-09-22: "if it's been an hour since last msg, always
+ * run compact". Override per provider with `compact_after_ms`.
+ */
+export const DEFAULT_COMPACT_AFTER_MS = 60 * 60 * 1000;
+/**
+ * Watcher `lane_progress` throttle: at most one thread event per five minutes
+ * per lane, and only when the tick saw new activity. Override per provider
+ * with `progress_event_min_interval_ms`.
+ */
+export const DEFAULT_PROGRESS_EVENT_MIN_INTERVAL_MS = 5 * 60 * 1000;
 /** Spec §9: last event within 10 minutes → live. */
 export const DEFAULT_LIVE_WITHIN_MS = 10 * 60 * 1000;
 /** Spec §9: turn_start with no turn_end after 2 hours → lost. */
@@ -131,8 +143,20 @@ function parseAccount(provider, id, raw, deps) {
     if (raw.max_running !== undefined) {
         account.max_running = positiveInt(raw.max_running, `providers.${provider}.accounts.${id}.max_running`);
     }
+    if (raw.model !== undefined) {
+        account.model = nonEmptyModel(raw.model, `providers.${provider}.accounts.${id}.model`);
+    }
+    if (raw.effort !== undefined) {
+        account.effort = parseConfigEffort(provider, raw.effort, `providers.${provider}.accounts.${id}.effort`);
+    }
     return account;
 }
+function nonEmptyModel(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new LanesConfigError("invalid_config", `${field} must be a non-empty string`, { field, value });
+    }
+    return value.trim();
+}
 function rejectDuplicateHomes(provider, accounts) {
     const seen = new Map();
     for (const [id, account] of Object.entries(accounts)) {
@@ -176,18 +200,38 @@ function parseProvider(provider, raw, deps) {
         }
     }
     rejectDuplicateHomes(provider, accounts);
-    const defaultAccount = typeof raw.default_account === "string" && raw.default_account.length > 0
-        ? raw.default_account
-        : "a";
-    if (Object.keys(accounts).length > 0 && accounts[defaultAccount] === undefined) {
-        throw new LanesConfigError("invalid_config", `providers.${provider}.default_account ${JSON.stringify(defaultAccount)} is not a configured account`, { provider, default_account: defaultAccount, accounts: Object.keys(accounts) });
+    // default_account is accepted so existing files parse, and ignored for
+    // selection. An omitted field is not an error.
+    let defaultAccount;
+    if (raw.default_account !== undefined) {
+        if (typeof raw.default_account !== "string" || raw.default_account.length === 0) {
+            throw new LanesConfigError("invalid_config", `providers.${provider}.default_account must be a non-empty string`, { provider, field: "default_account" });
+        }
+        defaultAccount = raw.default_account;
+        if (Object.keys(accounts).length > 0 && accounts[defaultAccount] === undefined) {
+            throw new LanesConfigError("invalid_config", `providers.${provider}.default_account ${JSON.stringify(defaultAccount)} is not a configured account`, { provider, default_account: defaultAccount, accounts: Object.keys(accounts) });
+        }
     }
-    return {
+    const parsed = {
         max_running: positiveInt(raw.max_running, `providers.${provider}.max_running`, DEFAULT_PROVIDER_MAX_RUNNING[provider]),
         max_queued: positiveInt(raw.max_queued, `providers.${provider}.max_queued`, DEFAULT_MAX_QUEUED),
-        default_account: defaultAccount,
         accounts,
     };
+    if (defaultAccount !== undefined)
+        parsed.default_account = defaultAccount;
+    if (raw.model !== undefined) {
+        parsed.model = nonEmptyModel(raw.model, `providers.${provider}.model`);
+    }
+    if (raw.effort !== undefined) {
+        parsed.effort = parseConfigEffort(provider, raw.effort, `providers.${provider}.effort`);
+    }
+    if (raw.compact_after_ms !== undefined) {
+        parsed.compact_after_ms = positiveInt(raw.compact_after_ms, `providers.${provider}.compact_after_ms`);
+    }
+    if (raw.progress_event_min_interval_ms !== undefined) {
+        parsed.progress_event_min_interval_ms = positiveInt(raw.progress_event_min_interval_ms, `providers.${provider}.progress_event_min_interval_ms`);
+    }
+    return parsed;
 }
 function parseThrottle(raw) {
     const obj = raw === undefined ? {} : raw;
@@ -231,7 +275,6 @@ export function documentedDefaultConfig(deps = defaultDeps()) {
         providers[provider] = {
             max_running: DEFAULT_PROVIDER_MAX_RUNNING[provider],
             max_queued: DEFAULT_MAX_QUEUED,
-            default_account: "a",
             accounts: defaultAccountMap(provider, deps),
         };
     }
@@ -263,6 +306,12 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
             throw new LanesConfigError("unknown_provider", `Unknown provider(s) ${unknown.join(", ")}. Accepted: ${LANE_PROVIDERS.join(", ")}`, { accepted: [...LANE_PROVIDERS], value: unknown });
         }
     }
+    // Spec §5.5: a missing *file* yields the documented defaults, and the
+    // enable switch — not omission — is how an operator turns an account off.
+    // The provider set is fixed at {claude, codex, grok} (§5), so a present
+    // config that names only `grok` still receives the documented claude and
+    // codex defaults (including real-home `~/.claude` / `~/.codex`). Omitting
+    // a provider key is not a disable.
     const providers = {};
     for (const provider of LANE_PROVIDERS) {
         const entry = isPlainObject(providersRaw) ? providersRaw[provider] : undefined;
@@ -341,6 +390,14 @@ export function writeLanesConfig(hqRoot, config, deps = defaultWriteDeps()) {
         throw err;
     }
 }
+/** Resume-time compaction threshold for a provider, defaulting to one hour. */
+export function providerCompactAfterMs(provider) {
+    return provider.compact_after_ms ?? DEFAULT_COMPACT_AFTER_MS;
+}
+/** Minimum gap between two `lane_progress` events, defaulting to five minutes. */
+export function providerProgressEventMinIntervalMs(provider) {
+    return provider.progress_event_min_interval_ms ?? DEFAULT_PROGRESS_EVENT_MIN_INTERVAL_MS;
+}
 /** Account running cap, defaulting to the provider ceiling when unset. */
 export function accountMaxRunning(provider, accountId) {
     const account = provider.accounts[accountId];

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

@@ -0,0 +1,151 @@
+/**
+ * Follow-up delivery decision, per provider and per lane state, in one place.
+ *
+ * Two mechanisms exist. A live provider process drains the drop box on its
+ * next `PreToolUse` event (dropbox.ts). A Claude process is print-and-exit,
+ * so after it exits the only way to deliver is `claude -p --resume <sid>`,
+ * which continues the recorded session and keeps its prompt cache. Codex
+ * (0.155.1) has `codex exec resume <thread-id>`; the id is the `thread_id`
+ * of the `thread.started` event on the `--json` stdout stream, and the same
+ * id comes back on every resumed turn. Grok's CLI (1.0.34) has
+ * `--resume <id>` and its `--single --output-format json` result carries a
+ * `sessionId`, but no live run has shown `--single --resume` continue a
+ * session (the grok account was out of balance when this was written), so
+ * an exited grok lane keeps no delivery path until that is proven.
+ *
+ * Every dispatch site (`hq lanes message`, spawn, reconcile resume) asks this
+ * module rather than testing provider or state inline. A guard bound at one
+ * site and not another is the defect class this branch has already shipped.
+ */
+import { type LaneProvider, type LaneRecord, type LaneState } from "./types.js";
+/** Which providers can continue an exited worker from a recorded session id. */
+export declare const PROVIDER_SESSION_RESUME: Record<LaneProvider, boolean>;
+export declare function providerSupportsSessionResume(provider: LaneProvider): boolean;
+/**
+ * States an operator message may resume from, given a session id.
+ *
+ * `done`: the worker finished its brief, wrote a done envelope and exited on
+ * its own. Nothing about the lane says the operator is finished with it; a
+ * follow-up is the normal next step, and the session is intact.
+ *
+ * `blocked`: the worker exited after writing a blocked envelope that names
+ * what it needs. An operator message is usually that missing input. The state
+ * is not terminal (spec §6.7) and nothing stopped the lane deliberately.
+ *
+ * Refused by `hq lanes message`:
+ * `awaiting_input` has its own path, `hq lanes questions answer`, and the
+ * reconcile pass resumes it once every question is answered. `killed` and
+ * `cancelled` were stopped on purpose by the operator; a message must not
+ * silently restart them. `failed` means the run ended without an envelope or
+ * never started; the operator has not seen why. `interrupted` exited with
+ * partial output and no envelope, so the lane's state was never closed
+ * cleanly; only the explicit `hq lanes resume` opt-in continues it
+ * (RESUME_COMMAND_STATES). `queued` and `running` take the drop box, not a
+ * resume.
+ */
+export declare const RESUMABLE_LANE_STATES: readonly ["done", "blocked"];
+export type ResumableLaneState = (typeof RESUMABLE_LANE_STATES)[number];
+export declare function isResumableLaneState(state: LaneState): state is ResumableLaneState;
+/**
+ * States `hq lanes resume` continues from. `interrupted` is the one a plain
+ * message refuses: the run ended without closing its state, and continuing
+ * it is a decision the operator makes by name. `done` and `blocked` are here
+ * so the one command covers every exited-with-a-session case.
+ */
+export declare const RESUME_COMMAND_STATES: readonly ["interrupted", "done", "blocked"];
+export type ResumeCommandState = (typeof RESUME_COMMAND_STATES)[number];
+export declare function isResumeCommandState(state: LaneState): state is ResumeCommandState;
+export declare const LANE_DELIVERY_MECHANISMS: readonly ["dropbox", "resume", "none"];
+export type LaneDeliveryMechanism = (typeof LANE_DELIVERY_MECHANISMS)[number];
+export type DeliveryLane = Pick<LaneRecord, "state" | "provider" | "provider_session_id">;
+/**
+ * `dropbox`: a process is (or is about to be) alive to drain the inbox.
+ * `resume`: the process has exited, the provider can resume, the state allows
+ * it, and a session id was recorded from the worker's own result.
+ * `none`: nothing can deliver; the caller must refuse and write nothing.
+ */
+export declare function laneDeliveryMechanism(lane: DeliveryLane): LaneDeliveryMechanism;
+export declare function hasRecordedSessionId(lane: Pick<LaneRecord, "provider_session_id">): lane is Pick<LaneRecord, "provider_session_id"> & {
+    provider_session_id: string;
+};
+export declare function deliveryRefusalReason(lane: DeliveryLane): string;
+/** Reasons a resumable provider's exit recorded no session id. Never a fabricated value. */
+export declare const SESSION_ID_ABSENT_REASONS: readonly ["worker_out_missing", "no_result_json", "no_session_id_field", "no_thread_started_event"];
+export type SessionIdAbsentReason = (typeof SESSION_ID_ABSENT_REASONS)[number];
+export interface WorkerRunResult {
+    session_id: string | null;
+    session_id_absent: SessionIdAbsentReason | null;
+    cache_read_input_tokens: number | null;
+    cache_creation_input_tokens: number | null;
+}
+/**
+ * Parse the `claude -p --output-format json` result. stdout is appended
+ * across runs of the same lane, so the last `type: "result"` object is this
+ * run's. Only `session_id` and the two cache counters are read out; the
+ * prompt, the response body and everything else in the payload stay on disk.
+ */
+export declare function parseClaudeResultOutput(text: string): WorkerRunResult;
+/**
+ * Parse the `codex exec --json` event stream. The first event of a run is
+ * `{"type":"thread.started","thread_id":"<uuid>"}`; that id is what
+ * `codex exec resume <id>` takes, and a resumed run emits the same id again.
+ * Usage comes from the last `turn.completed` event: `cached_input_tokens`
+ * is the cache read and `cache_write_input_tokens` the cache creation.
+ * Nothing else on the stream is read out.
+ */
+export declare function parseCodexEventOutput(text: string): WorkerRunResult;
+/** Per-provider stdout parser; null for a provider whose exit carries nothing to record. */
+export declare function parseWorkerRunOutput(provider: LaneProvider, text: string): WorkerRunResult | null;
+/**
+ * Read this run's result from the worker's own stdout. stdout is opened in
+ * append mode across runs, so only bytes past `workerOutOffset` (recorded in
+ * spawn.json at launch) are this run's. Returns null for a provider whose
+ * exit carries nothing to record, so those lanes keep behaving exactly as
+ * before.
+ */
+export declare function readWorkerRunResult(runDir: string, provider: LaneProvider, 
+/** Bytes of worker.out that belong to earlier runs; parsing starts after them. */
+workerOutOffset?: number): WorkerRunResult | null;
+export declare const LAUNCH_TRIGGERS: readonly ["admit", "answered_questions", "message", "resume"];
+export type LaunchTriggerKind = (typeof LAUNCH_TRIGGERS)[number];
+export type LaunchTrigger = {
+    kind: "admit";
+} | {
+    kind: "answered_questions";
+} | {
+    kind: "message";
+    text: string;
+    message_id: string;
+} | {
+    /** `hq lanes resume`: the operator's explicit opt-in to continue an exited lane. */
+    kind: "resume";
+    /** Lane state at the moment of the command; recorded as `last_resume.resumed_from`. */
+    from: ResumeCommandState;
+    text?: string;
+    message_id?: string;
+};
+export type LaunchPlan = {
+    mode: "fresh";
+} | {
+    mode: "resume";
+    session_id: string;
+};
+/**
+ * Refusal for `hq lanes resume`, in precedence order: wrong state, provider
+ * without a resume path, no recorded session. Null when the resume can go.
+ */
+export declare function resumeCommandRefusal(lane: DeliveryLane): {
+    error: "lane_not_resumable" | "resume_unsupported" | "no_provider_session";
+    message: string;
+} | null;
+/**
+ * Decide fresh-vs-resume for a spawn. Admission always starts fresh with the
+ * brief. Answered questions resume the recorded session when the provider
+ * can, else start fresh with the answers file (today's behaviour). An operator
+ * message can only be a resume, and only when `laneDeliveryMechanism` says so.
+ * `hq lanes resume` is also always a resume, gated by `resumeCommandRefusal`.
+ */
+export declare function planLaneLaunch(lane: DeliveryLane, trigger: LaunchTrigger): LaunchPlan;
+/** Lane states a launch may claim `running` from, per trigger. */
+export declare function claimableStatesFor(trigger: LaunchTrigger): readonly LaneState[];
+//# sourceMappingURL=delivery.d.ts.map

package/dist/lib/lanes/delivery.js

@@ -0,0 +1,354 @@
+/**
+ * Follow-up delivery decision, per provider and per lane state, in one place.
+ *
+ * Two mechanisms exist. A live provider process drains the drop box on its
+ * next `PreToolUse` event (dropbox.ts). A Claude process is print-and-exit,
+ * so after it exits the only way to deliver is `claude -p --resume <sid>`,
+ * which continues the recorded session and keeps its prompt cache. Codex
+ * (0.155.1) has `codex exec resume <thread-id>`; the id is the `thread_id`
+ * of the `thread.started` event on the `--json` stdout stream, and the same
+ * id comes back on every resumed turn. Grok's CLI (1.0.34) has
+ * `--resume <id>` and its `--single --output-format json` result carries a
+ * `sessionId`, but no live run has shown `--single --resume` continue a
+ * session (the grok account was out of balance when this was written), so
+ * an exited grok lane keeps no delivery path until that is proven.
+ *
+ * Every dispatch site (`hq lanes message`, spawn, reconcile resume) asks this
+ * module rather than testing provider or state inline. A guard bound at one
+ * site and not another is the defect class this branch has already shipped.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+import { parseLaneProvider, } from "./types.js";
+/** Which providers can continue an exited worker from a recorded session id. */
+export const PROVIDER_SESSION_RESUME = {
+    claude: true,
+    codex: true,
+    grok: false,
+};
+export function providerSupportsSessionResume(provider) {
+    return PROVIDER_SESSION_RESUME[parseLaneProvider(provider)];
+}
+/**
+ * States an operator message may resume from, given a session id.
+ *
+ * `done`: the worker finished its brief, wrote a done envelope and exited on
+ * its own. Nothing about the lane says the operator is finished with it; a
+ * follow-up is the normal next step, and the session is intact.
+ *
+ * `blocked`: the worker exited after writing a blocked envelope that names
+ * what it needs. An operator message is usually that missing input. The state
+ * is not terminal (spec §6.7) and nothing stopped the lane deliberately.
+ *
+ * Refused by `hq lanes message`:
+ * `awaiting_input` has its own path, `hq lanes questions answer`, and the
+ * reconcile pass resumes it once every question is answered. `killed` and
+ * `cancelled` were stopped on purpose by the operator; a message must not
+ * silently restart them. `failed` means the run ended without an envelope or
+ * never started; the operator has not seen why. `interrupted` exited with
+ * partial output and no envelope, so the lane's state was never closed
+ * cleanly; only the explicit `hq lanes resume` opt-in continues it
+ * (RESUME_COMMAND_STATES). `queued` and `running` take the drop box, not a
+ * resume.
+ */
+export const RESUMABLE_LANE_STATES = ["done", "blocked"];
+export function isResumableLaneState(state) {
+    return RESUMABLE_LANE_STATES.includes(state);
+}
+/**
+ * States `hq lanes resume` continues from. `interrupted` is the one a plain
+ * message refuses: the run ended without closing its state, and continuing
+ * it is a decision the operator makes by name. `done` and `blocked` are here
+ * so the one command covers every exited-with-a-session case.
+ */
+export const RESUME_COMMAND_STATES = ["interrupted", "done", "blocked"];
+export function isResumeCommandState(state) {
+    return RESUME_COMMAND_STATES.includes(state);
+}
+export const LANE_DELIVERY_MECHANISMS = ["dropbox", "resume", "none"];
+/**
+ * `dropbox`: a process is (or is about to be) alive to drain the inbox.
+ * `resume`: the process has exited, the provider can resume, the state allows
+ * it, and a session id was recorded from the worker's own result.
+ * `none`: nothing can deliver; the caller must refuse and write nothing.
+ */
+export function laneDeliveryMechanism(lane) {
+    if (lane.state === "queued" || lane.state === "running")
+        return "dropbox";
+    if (providerSupportsSessionResume(lane.provider) &&
+        isResumableLaneState(lane.state) &&
+        hasRecordedSessionId(lane)) {
+        return "resume";
+    }
+    return "none";
+}
+export function hasRecordedSessionId(lane) {
+    return (typeof lane.provider_session_id === "string" &&
+        lane.provider_session_id.trim().length > 0);
+}
+export function deliveryRefusalReason(lane) {
+    const state = lane.state;
+    switch (state) {
+        case "queued":
+        case "running":
+            return "";
+        case "awaiting_input":
+            return "Lane is awaiting_input. The worker has exited after writing an ask envelope. Use hq lanes questions answer <question-id>.";
+        case "done":
+        case "blocked": {
+            if (!providerSupportsSessionResume(lane.provider)) {
+                return `Lane is ${state}. Provider ${lane.provider} cannot resume an exited worker; there is no delivery path.`;
+            }
+            if (!hasRecordedSessionId(lane)) {
+                return `Lane is ${state}. No provider session id was recorded from the worker's result, so the session cannot be resumed.`;
+            }
+            return "";
+        }
+        case "killed":
+        case "cancelled":
+            return `Lane is ${state}. The operator stopped it on purpose; a message does not restart it. Resuming from ${state} needs an explicit opt-in, which does not exist yet.`;
+        case "interrupted":
+            return `Lane is ${state}. The run did not close cleanly and the operator has not decided what to do with it. Resuming from ${state} needs an explicit opt-in: hq lanes resume <lane-id> [--text <message>].`;
+        case "failed":
+            return `Lane is ${state}. The run did not close cleanly and the operator has not decided what to do with it. Resuming from ${state} needs an explicit opt-in, which does not exist yet.`;
+        default: {
+            const _exhaustive = state;
+            return _exhaustive;
+        }
+    }
+}
+/** Reasons a resumable provider's exit recorded no session id. Never a fabricated value. */
+export const SESSION_ID_ABSENT_REASONS = [
+    "worker_out_missing",
+    "no_result_json",
+    "no_session_id_field",
+    "no_thread_started_event",
+];
+function nonNegativeInt(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0
+        ? value
+        : null;
+}
+/**
+ * Parse the `claude -p --output-format json` result. stdout is appended
+ * across runs of the same lane, so the last `type: "result"` object is this
+ * run's. Only `session_id` and the two cache counters are read out; the
+ * prompt, the response body and everything else in the payload stay on disk.
+ */
+export function parseClaudeResultOutput(text) {
+    const lines = text.split("\n");
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = (lines[i] ?? "").trim();
+        if (!line.startsWith("{"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        const rec = parsed;
+        if (rec.type !== "result")
+            continue;
+        const usage = rec.usage && typeof rec.usage === "object" && !Array.isArray(rec.usage)
+            ? rec.usage
+            : {};
+        const sessionId = typeof rec.session_id === "string" && rec.session_id.trim().length > 0
+            ? rec.session_id.trim()
+            : null;
+        return {
+            session_id: sessionId,
+            session_id_absent: sessionId === null ? "no_session_id_field" : null,
+            cache_read_input_tokens: nonNegativeInt(usage.cache_read_input_tokens),
+            cache_creation_input_tokens: nonNegativeInt(usage.cache_creation_input_tokens),
+        };
+    }
+    return {
+        session_id: null,
+        session_id_absent: "no_result_json",
+        cache_read_input_tokens: null,
+        cache_creation_input_tokens: null,
+    };
+}
+/**
+ * Parse the `codex exec --json` event stream. The first event of a run is
+ * `{"type":"thread.started","thread_id":"<uuid>"}`; that id is what
+ * `codex exec resume <id>` takes, and a resumed run emits the same id again.
+ * Usage comes from the last `turn.completed` event: `cached_input_tokens`
+ * is the cache read and `cache_write_input_tokens` the cache creation.
+ * Nothing else on the stream is read out.
+ */
+export function parseCodexEventOutput(text) {
+    let threadId = null;
+    let usage = {};
+    let sawEvent = false;
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (!line.startsWith("{"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        const rec = parsed;
+        if (typeof rec.type !== "string")
+            continue;
+        sawEvent = true;
+        if (rec.type === "thread.started" && threadId === null) {
+            threadId =
+                typeof rec.thread_id === "string" && rec.thread_id.trim().length > 0
+                    ? rec.thread_id.trim()
+                    : null;
+        }
+        else if (rec.type === "turn.completed") {
+            usage =
+                rec.usage && typeof rec.usage === "object" && !Array.isArray(rec.usage)
+                    ? rec.usage
+                    : {};
+        }
+    }
+    return {
+        session_id: threadId,
+        session_id_absent: threadId !== null ? null : sawEvent ? "no_thread_started_event" : "no_result_json",
+        cache_read_input_tokens: nonNegativeInt(usage.cached_input_tokens),
+        cache_creation_input_tokens: nonNegativeInt(usage.cache_write_input_tokens),
+    };
+}
+/** Per-provider stdout parser; null for a provider whose exit carries nothing to record. */
+export function parseWorkerRunOutput(provider, text) {
+    switch (parseLaneProvider(provider)) {
+        case "claude":
+            return parseClaudeResultOutput(text);
+        case "codex":
+            return parseCodexEventOutput(text);
+        case "grok":
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Read this run's result from the worker's own stdout. stdout is opened in
+ * append mode across runs, so only bytes past `workerOutOffset` (recorded in
+ * spawn.json at launch) are this run's. Returns null for a provider whose
+ * exit carries nothing to record, so those lanes keep behaving exactly as
+ * before.
+ */
+export function readWorkerRunResult(runDir, provider, 
+/** Bytes of worker.out that belong to earlier runs; parsing starts after them. */
+workerOutOffset = 0) {
+    if (!providerSupportsSessionResume(provider))
+        return null;
+    const outPath = path.join(runDir, "logs", "worker.out");
+    let text;
+    try {
+        const bytes = fs.readFileSync(outPath);
+        text = bytes.subarray(Math.min(workerOutOffset, bytes.length)).toString("utf8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            return {
+                session_id: null,
+                session_id_absent: "worker_out_missing",
+                cache_read_input_tokens: null,
+                cache_creation_input_tokens: null,
+            };
+        }
+        process.stderr.write(`hq lanes: failed to read ${outPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        throw err;
+    }
+    return parseWorkerRunOutput(provider, text);
+}
+export const LAUNCH_TRIGGERS = ["admit", "answered_questions", "message", "resume"];
+/**
+ * Refusal for `hq lanes resume`, in precedence order: wrong state, provider
+ * without a resume path, no recorded session. Null when the resume can go.
+ */
+export function resumeCommandRefusal(lane) {
+    if (!isResumeCommandState(lane.state)) {
+        return {
+            error: "lane_not_resumable",
+            message: `Lane is ${lane.state}. hq lanes resume continues a lane in ${RESUME_COMMAND_STATES.join(", ")}; ${lane.state === "awaiting_input"
+                ? "use hq lanes questions answer <question-id>."
+                : lane.state === "queued" || lane.state === "running"
+                    ? "use hq lanes message for a live lane."
+                    : "a lane in this state is not resumed."}`,
+        };
+    }
+    if (!providerSupportsSessionResume(lane.provider)) {
+        return {
+            error: "resume_unsupported",
+            message: `Lane is ${lane.state}. Provider ${lane.provider} cannot resume an exited worker; there is no delivery path.`,
+        };
+    }
+    if (!hasRecordedSessionId(lane)) {
+        return {
+            error: "no_provider_session",
+            message: `Lane is ${lane.state}. No provider session id was recorded from the worker's result, so the session cannot be resumed.`,
+        };
+    }
+    return null;
+}
+/**
+ * Decide fresh-vs-resume for a spawn. Admission always starts fresh with the
+ * brief. Answered questions resume the recorded session when the provider
+ * can, else start fresh with the answers file (today's behaviour). An operator
+ * message can only be a resume, and only when `laneDeliveryMechanism` says so.
+ * `hq lanes resume` is also always a resume, gated by `resumeCommandRefusal`.
+ */
+export function planLaneLaunch(lane, trigger) {
+    switch (trigger.kind) {
+        case "admit":
+            return { mode: "fresh" };
+        case "answered_questions":
+            if (providerSupportsSessionResume(lane.provider) && hasRecordedSessionId(lane)) {
+                return { mode: "resume", session_id: lane.provider_session_id };
+            }
+            return { mode: "fresh" };
+        case "message": {
+            if (laneDeliveryMechanism(lane) !== "resume" || !hasRecordedSessionId(lane)) {
+                throw new LanesError("lane_not_accepting_messages", deliveryRefusalReason(lane) || `Lane is ${lane.state} and cannot be resumed`, { state: lane.state, provider: lane.provider });
+            }
+            return { mode: "resume", session_id: lane.provider_session_id };
+        }
+        case "resume": {
+            const refusal = resumeCommandRefusal(lane);
+            if (refusal !== null || !hasRecordedSessionId(lane)) {
+                throw new LanesError(refusal?.error ?? "no_provider_session", refusal?.message ?? `Lane is ${lane.state} and has no recorded provider session`, { state: lane.state, provider: lane.provider });
+            }
+            return { mode: "resume", session_id: lane.provider_session_id };
+        }
+        default: {
+            const _exhaustive = trigger;
+            return _exhaustive;
+        }
+    }
+}
+/** Lane states a launch may claim `running` from, per trigger. */
+export function claimableStatesFor(trigger) {
+    switch (trigger.kind) {
+        case "admit":
+            return ["queued"];
+        case "answered_questions":
+            return ["awaiting_input"];
+        case "message":
+            return RESUMABLE_LANE_STATES;
+        case "resume":
+            return RESUME_COMMAND_STATES;
+        default: {
+            const _exhaustive = trigger;
+            return _exhaustive;
+        }
+    }
+}
+//# sourceMappingURL=delivery.js.map