@indigoai-us/hq-cli 5.134.0 → 5.135.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [5.135.0] — 2026-09-23
+
+### Added
+
+- Claude lanes now set Claude Code's `CLAUDE_CODE_AUTO_COMPACT_WINDOW=200000`
+  control on fresh launches and session resumes.
+  `providers.claude.auto_compact_tokens` sets a positive-integer override, and
+  Codex and Grok launch environments are unchanged.
+
+- Added `hq lanes watch` for bounded state and question polling, plus
+  `hq lanes monitor-check` for Claude Monitor coverage with distinct exit codes
+  for uncovered lanes and unreadable evidence. The reminder text is available
+  from `hq lanes monitor-check --reminder`.
+- Corrected watch JSONL output and question status transitions, bounded Monitor
+  recommendations to the watch limit, and made stale or unreadable Monitor
+  evidence fail closed.
+
+- Lanes can opt selected Codex model ids into fast mode with
+  `providers.codex.fast_mode_models`. Matching fresh and resumed runs pass
+  Codex's `service_tier="fast"` and `fast_mode` settings and record the
+  decision in the lane record and `spawn.json`.
+
 ## [5.134.0] — 2026-09-22
 
 ### Fixed

package/dist/command-catalog.generated.d.ts

@@ -6744,6 +6744,46 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "JSON on stdout (always)";
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "watch";
+        readonly description: "Watch lane state and question changes until all lanes are terminal";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options] <lane-id...>";
+        readonly arguments: readonly [{
+            readonly name: "lane-id";
+            readonly required: true;
+            readonly variadic: true;
+        }];
+        readonly options: readonly [{
+            readonly flags: "--interval-ms <ms>";
+            readonly description: "Polling interval, bounded to 100ms–30s";
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+        }];
+        readonly subcommands: readonly [];
+    }, {
+        readonly name: "monitor-check";
+        readonly description: "Check that active Claude senior lanes have live Monitor watch tasks";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options]";
+        readonly arguments: readonly [];
+        readonly options: readonly [{
+            readonly flags: "--session <id>";
+            readonly description: "Senior session id";
+        }, {
+            readonly flags: "--engine <engine>";
+            readonly description: "claude | codex | grok; defaults to HQ_CONDUCT_ENGINE or claude";
+        }, {
+            readonly flags: "--reminder";
+            readonly description: "Print the senior Monitor reminder text";
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "show";
         readonly description: "Show one lane";

package/dist/command-catalog.generated.js

@@ -8716,6 +8716,58 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "watch",
+                "description": "Watch lane state and question changes until all lanes are terminal",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options] <lane-id...>",
+                "arguments": [
+                    {
+                        "name": "lane-id",
+                        "required": true,
+                        "variadic": true
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--interval-ms <ms>",
+                        "description": "Polling interval, bounded to 100ms–30s"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)"
+                    }
+                ],
+                "subcommands": []
+            },
+            {
+                "name": "monitor-check",
+                "description": "Check that active Claude senior lanes have live Monitor watch tasks",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options]",
+                "arguments": [],
+                "options": [
+                    {
+                        "flags": "--session <id>",
+                        "description": "Senior session id"
+                    },
+                    {
+                        "flags": "--engine <engine>",
+                        "description": "claude | codex | grok; defaults to HQ_CONDUCT_ENGINE or claude"
+                    },
+                    {
+                        "flags": "--reminder",
+                        "description": "Print the senior Monitor reminder text"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "show",
                 "description": "Show one lane",

package/dist/commands/lanes.d.ts

@@ -1,13 +1,14 @@
 /**
  * `hq lanes` — worker lane management and decision queue (spec §5–§7, §10–§11).
  *
- * Every command prints JSON on stdout and takes no interactive input, except
+ * Existing commands print JSON on stdout and take no interactive input, except
  * `accounts login`, which hands the terminal to the vendor's own sign-in.
+ * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { Command } from "commander";
 import { type OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import { emitLaneDecisionEvents, type LaneMesh } from "../lib/lanes/mesh-events.js";
-import { MAX_LANE_DEPTH, type LaneCompanyRef, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
+import { MAX_LANE_DEPTH, type LaneCompanyRef, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { type RunCompactionFn } from "../lib/lanes/compaction.js";
 import { type KnownModelsDeps, type ProbeCommand } from "../lib/lanes/models.js";
@@ -76,6 +77,7 @@ export interface LanesCommandDeps {
     fetchText?: (url: string) => Promise<string>;
     runCompaction?: RunCompactionFn;
     locateTranscript?: (home: string, sessionId: string) => string | null;
+    monitorEvidence?: MonitorEvidenceReader;
 }
 export declare function readOutpostIdentity(existsSync?: (p: string) => boolean, readFileSync?: (p: string) => string): OutpostIdentity;
 export declare function parseSeniorRef(raw: string): SeniorRef;

package/dist/commands/lanes.js

@@ -1,8 +1,9 @@
 /**
  * `hq lanes` — worker lane management and decision queue (spec §5–§7, §10–§11).
  *
- * Every command prints JSON on stdout and takes no interactive input, except
+ * Existing commands print JSON on stdout and take no interactive input, except
  * `accounts login`, which hands the terminal to the vendor's own sign-in.
+ * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { spawn, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
@@ -17,7 +18,7 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountMaxRunning, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, MAX_LANE_DEPTH, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, readQuestion, resolveAccount, resolveLaneWorker, isLoggedOut, runReconcilePass, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasRecordedSessionId, providerSupportsSessionResume, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountMaxRunning, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, readQuestion, resolveAccount, resolveLaneWorker, isLoggedOut, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasRecordedSessionId, providerSupportsSessionResume, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { providerCompactAfterMs } from "../lib/lanes/config.js";
@@ -62,6 +63,24 @@ function wrap(action) {
         }
     };
 }
+function failText(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`hq lanes: ${message}\n`);
+    process.exit(MONITOR_ERROR_EXIT_CODE);
+}
+function wrapText(action) {
+    return async (...args) => {
+        let code;
+        try {
+            code = await action(...args);
+        }
+        catch (err) {
+            failText(err);
+        }
+        if (code !== 0)
+            process.exit(code);
+    };
+}
 function collectRepeatable(value, previous = []) {
     return previous.concat(value);
 }
@@ -206,6 +225,12 @@ function resolveDeps(deps = {}) {
         probeProvider: deps.probeProvider ?? defaultProbe,
         runCompaction: deps.runCompaction,
         locateTranscript: deps.locateTranscript,
+        monitorEvidence: deps.monitorEvidence ??
+            ((sessionId) => readLiveMonitorEvidence(sessionId, {
+                homedir: () => deps.homedir?.() ?? os.homedir(),
+                env,
+                now: deps.now ?? (() => new Date()),
+            })),
         stageOutpostPayload: deps.stageOutpostPayload ?? defaultStageOutpostPayload,
         dispatchOutpostExec: deps.dispatchOutpostExec ?? defaultDispatchOutpostExec,
         fetchText: deps.fetchText ?? defaultFetchText,
@@ -387,6 +412,115 @@ function loadAllLanes(hqRoot) {
 function loadAllQuestions(hqRoot) {
     return listQuestionIds(hqRoot).map((id) => readQuestion(hqRoot, id));
 }
+const MONITOR_ACTIVE_LANE_STATES = new Set([
+    "running",
+    "queued",
+    "awaiting_input",
+    "blocked",
+]);
+function resolveMonitorEngine(requested, env) {
+    const value = requested?.trim().toLowerCase() ||
+        env.HQ_CONDUCT_ENGINE?.trim().toLowerCase() ||
+        "claude";
+    if (!MONITOR_ENGINES.includes(value)) {
+        throw new LanesError("monitor_invalid_engine", `Unknown monitor-check engine ${JSON.stringify(value)}. Accepted: ${MONITOR_ENGINES.join(", ")}`, { accepted: [...MONITOR_ENGINES], value });
+    }
+    return value;
+}
+async function runWatch(ctx, laneIds, opts) {
+    const rawInterval = opts.intervalMs === undefined ? undefined : Number(opts.intervalMs);
+    await runLaneWatch(ctx.hqRoot(), laneIds, {
+        intervalMs: rawInterval,
+        sleep: ctx.sleep,
+        writeLine: (line) => console.log(opts.json ? JSON.stringify({ event: line }) : line),
+        writeError: (line) => process.stderr.write(`${line}\n`),
+    });
+    return 0;
+}
+function monitorCallsForLaneIds(laneIds) {
+    const calls = [];
+    for (let offset = 0; offset < laneIds.length; offset += MAX_WATCHED_LANES) {
+        const chunk = laneIds.slice(offset, offset + MAX_WATCHED_LANES);
+        calls.push({
+            command: `hq lanes watch ${chunk.join(" ")}`,
+            timeout_ms: MONITOR_MAX_TIMEOUT_MS,
+            persistent: true,
+        });
+    }
+    return calls;
+}
+async function runMonitorCheck(ctx, opts) {
+    if (opts.reminder) {
+        console.log(monitorReminderText());
+        return 0;
+    }
+    const sessionId = opts.session?.trim();
+    if (!sessionId) {
+        throw new LanesError("monitor_session_required", "hq lanes monitor-check requires --session <id> unless --reminder is used");
+    }
+    const engine = resolveMonitorEngine(opts.engine, ctx.env);
+    const activeLanes = loadAllLanes(ctx.hqRoot()).filter((lane) => lane.senior.kind === "session" &&
+        lane.senior.id === sessionId &&
+        MONITOR_ACTIVE_LANE_STATES.has(lane.state));
+    if (engine !== "claude") {
+        if (opts.json) {
+            printJson({
+                ok: true,
+                action: "monitor-check",
+                session_id: sessionId,
+                engine,
+                active_lane_ids: activeLanes.map((lane) => lane.lane_id),
+                covered_lane_ids: [],
+                uncovered_lane_ids: [],
+                skipped: "engine_has_no_claude_monitor",
+            });
+        }
+        return 0;
+    }
+    if (activeLanes.length === 0) {
+        if (opts.json) {
+            printJson({
+                ok: true,
+                action: "monitor-check",
+                session_id: sessionId,
+                engine,
+                active_lane_ids: [],
+                covered_lane_ids: [],
+                uncovered_lane_ids: [],
+            });
+        }
+        return 0;
+    }
+    const evidence = await ctx.monitorEvidence(sessionId);
+    if (evidence.sessionId !== sessionId) {
+        throw new LanesError("monitor_evidence_session_mismatch", `Monitor evidence was for ${JSON.stringify(evidence.sessionId)}, expected ${JSON.stringify(sessionId)}`);
+    }
+    const covered = coveredLaneIds(evidence, ctx.now());
+    const activeIds = activeLanes.map((lane) => lane.lane_id);
+    const uncovered = activeIds.filter((laneId) => !covered.has(laneId));
+    const monitorCalls = monitorCallsForLaneIds(uncovered);
+    if (opts.json) {
+        printJson({
+            ok: uncovered.length === 0,
+            action: "monitor-check",
+            session_id: sessionId,
+            engine,
+            active_lane_ids: activeIds,
+            covered_lane_ids: activeIds.filter((laneId) => covered.has(laneId)),
+            uncovered_lane_ids: uncovered,
+            monitor_call: monitorCalls.length === 1 ? monitorCalls[0] : null,
+            monitor_calls: monitorCalls,
+        });
+    }
+    else if (uncovered.length > 0) {
+        for (const laneId of uncovered)
+            console.log(`uncovered lane: ${laneId}`);
+        for (const monitorCall of monitorCalls) {
+            console.log(`Monitor(command=${JSON.stringify(monitorCall.command)}, timeout_ms=${monitorCall.timeout_ms}, persistent=true)`);
+        }
+    }
+    return uncovered.length > 0 ? MONITOR_UNCOVERED_EXIT_CODE : 0;
+}
 function sessionMetaPath(hqRoot, sessionId) {
     return path.join(hqRoot, "workspace", "sessions", sessionId, "meta.yaml");
 }
@@ -3193,6 +3327,20 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (opts) => {
         await runList(ctx, opts);
     }));
+    lanes
+        .command("watch")
+        .description("Watch lane state and question changes until all lanes are terminal")
+        .argument("<lane-id...>", "Lane ids to watch")
+        .option("--interval-ms <ms>", "Polling interval, bounded to 100ms–30s", "5000")
+        .action(wrapText(async (laneIds, opts) => runWatch(ctx, laneIds, opts)));
+    lanes
+        .command("monitor-check")
+        .description("Check that active Claude senior lanes have live Monitor watch tasks")
+        .option("--session <id>", "Senior session id")
+        .option("--engine <engine>", "claude | codex | grok; defaults to HQ_CONDUCT_ENGINE or claude")
+        .option("--reminder", "Print the senior Monitor reminder text")
+        .option("--json", "JSON on stdout")
+        .action(wrapText(async (opts) => runMonitorCheck(ctx, opts)));
     lanes
         .command("show")
         .description("Show one lane")

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

@@ -18,6 +18,11 @@ export declare const DEFAULT_MIN_AVAILABLE_MEM_MB = 1024;
  * run compact". Override per provider with `compact_after_ms`.
  */
 export declare const DEFAULT_COMPACT_AFTER_MS: number;
+/**
+ * Claude Code's auto-compaction window, in tokens. Override with
+ * `providers.claude.auto_compact_tokens`.
+ */
+export declare const DEFAULT_AUTO_COMPACT_TOKENS = 200000;
 /**
  * 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
@@ -66,6 +71,8 @@ export interface ConfigWriteDeps {
 export declare function writeLanesConfig(hqRoot: string, config: LanesConfig, deps?: ConfigWriteDeps): void;
 /** Resume-time compaction threshold for a provider, defaulting to one hour. */
 export declare function providerCompactAfterMs(provider: ProviderConfig): number;
+/** Claude Code auto-compaction threshold, defaulting to 200,000 tokens. */
+export declare function providerAutoCompactTokens(provider: ProviderConfig): number;
 /** Minimum gap between two `lane_progress` events, defaulting to five minutes. */
 export declare function providerProgressEventMinIntervalMs(provider: ProviderConfig): number;
 /** Hold for a reset-less 429 on this provider's accounts. */

package/dist/lib/lanes/config.js

@@ -22,6 +22,11 @@ export const DEFAULT_MIN_AVAILABLE_MEM_MB = 1024;
  * run compact". Override per provider with `compact_after_ms`.
  */
 export const DEFAULT_COMPACT_AFTER_MS = 60 * 60 * 1000;
+/**
+ * Claude Code's auto-compaction window, in tokens. Override with
+ * `providers.claude.auto_compact_tokens`.
+ */
+export const DEFAULT_AUTO_COMPACT_TOKENS = 200_000;
 /**
  * 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
@@ -159,6 +164,15 @@ function nonEmptyModel(value, field) {
     }
     return value.trim();
 }
+function parseFastModeModels(value, field) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) ||
+        value.some((model) => typeof model !== "string" || model.trim().length === 0)) {
+        throw new LanesConfigError("invalid_fast_mode_models", `${field} must be an array of non-empty strings`, { field, value });
+    }
+    return value.map((model) => model.trim());
+}
 function rejectDuplicateHomes(provider, accounts) {
     const seen = new Map();
     for (const [id, account] of Object.entries(accounts)) {
@@ -219,6 +233,9 @@ function parseProvider(provider, raw, deps) {
         max_queued: positiveInt(raw.max_queued, `providers.${provider}.max_queued`, DEFAULT_MAX_QUEUED),
         accounts,
     };
+    if (provider === "codex") {
+        parsed.fast_mode_models = parseFastModeModels(raw.fast_mode_models, `providers.${provider}.fast_mode_models`);
+    }
     if (defaultAccount !== undefined)
         parsed.default_account = defaultAccount;
     if (raw.model !== undefined) {
@@ -230,6 +247,9 @@ function parseProvider(provider, raw, deps) {
     if (raw.compact_after_ms !== undefined) {
         parsed.compact_after_ms = positiveInt(raw.compact_after_ms, `providers.${provider}.compact_after_ms`);
     }
+    if (raw.auto_compact_tokens !== undefined) {
+        parsed.auto_compact_tokens = positiveInt(raw.auto_compact_tokens, `providers.${provider}.auto_compact_tokens`);
+    }
     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`);
     }
@@ -277,11 +297,14 @@ function parseLiveness(raw) {
 export function documentedDefaultConfig(deps = defaultDeps()) {
     const providers = {};
     for (const provider of LANE_PROVIDERS) {
-        providers[provider] = {
+        const providerConfig = {
             max_running: DEFAULT_PROVIDER_MAX_RUNNING[provider],
             max_queued: DEFAULT_MAX_QUEUED,
             accounts: defaultAccountMap(provider, deps),
         };
+        if (provider === "codex")
+            providerConfig.fast_mode_models = [];
+        providers[provider] = providerConfig;
     }
     return {
         schema_version: CONFIG_SCHEMA_VERSION,
@@ -399,6 +422,10 @@ export function writeLanesConfig(hqRoot, config, deps = defaultWriteDeps()) {
 export function providerCompactAfterMs(provider) {
     return provider.compact_after_ms ?? DEFAULT_COMPACT_AFTER_MS;
 }
+/** Claude Code auto-compaction threshold, defaulting to 200,000 tokens. */
+export function providerAutoCompactTokens(provider) {
+    return provider.auto_compact_tokens ?? DEFAULT_AUTO_COMPACT_TOKENS;
+}
 /** 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;

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

@@ -5,7 +5,7 @@ export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersion
 export { MAX_LANE_DEPTH } from "./constants.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
 export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LaneRecord, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
-export { DEFAULT_ACCOUNT_HOMES, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
+export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";
 export { resolveLanesHqRoot } from "./hq-root.js";
 export type { LanesHqRootOpts } from "./hq-root.js";
@@ -13,6 +13,10 @@ export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost
 export type { OutpostDispatchResult, OutpostPickupPayload, } from "./outpost-dispatch.js";
 export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, updateLane, updateQuestion, } from "./store.js";
 export type { StoreDeps } from "./store.js";
+export { DEFAULT_LANE_WATCH_INTERVAL_MS, MAX_LANE_WATCH_INTERVAL_MS, MAX_WATCHED_LANES, MAX_WATCH_OUTPUT_LINES, runLaneWatch, } from "./watch.js";
+export type { LaneWatchDeps, LaneWatchResult } from "./watch.js";
+export { MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_TASK_OUTPUT_MAX_BYTES, MONITOR_TRANSCRIPT_MAX_BYTES, MONITOR_UNCOVERED_EXIT_CODE, coveredLaneIds, isMonitorTaskLive, monitorReminderText, parseCanonicalWatchCommand, parseMonitorTranscript, readLiveMonitorEvidence, } from "./monitor.js";
+export type { LiveMonitorEvidenceOptions, MonitorEngine, MonitorEvidence, MonitorEvidenceReader, MonitorTaskEvidence, } from "./monitor.js";
 export { IMDS_HOST, IMDS_INSTANCE_ID_URL, IMDS_TIMEOUT_MS, IMDS_TOKEN_URL, defaultReadImdsInstanceId, resolveMachineIdentity, } from "./machine-identity.js";
 export type { MachineIdentity, MachineIdentityDeps } from "./machine-identity.js";
 export { LANES_RUNS_REL as SPAWN_LANES_RUNS_REL, PID_LIVENESS_DECISIONS, PROVIDER_COMMAND, PROVIDER_MODEL_FLAG, SPAWN_TERMINAL_REASONS, ANSWERED_QUESTIONS_FILE, appendModelFlag, armLaneWatcher, buildProviderCommand, parseCliModel, resolveLaneModel, defaultProveDetached, isPidRecordAlive, laneRunDir, missingPidProbe, nextEnvelopePath, markSpawnFailure, parsePidRecord, parseProcStat, parseSpawnTerminalReason, probePidRecord, readPidRecord, readProcStarttime, readProcStarttimeDetailed, readSpawnManifest, resumePrompt, envelopeInstruction, spawnLaneWorker, stopLaneProcesses, watcherMainPath, workerEnv, } from "./spawn.js";

package/dist/lib/lanes/index.js

@@ -4,10 +4,12 @@
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
-export { DEFAULT_ACCOUNT_HOMES, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
+export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export { resolveLanesHqRoot } from "./hq-root.js";
 export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
 export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, updateLane, updateQuestion, } from "./store.js";
+export { DEFAULT_LANE_WATCH_INTERVAL_MS, MAX_LANE_WATCH_INTERVAL_MS, MAX_WATCHED_LANES, MAX_WATCH_OUTPUT_LINES, runLaneWatch, } from "./watch.js";
+export { MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_TASK_OUTPUT_MAX_BYTES, MONITOR_TRANSCRIPT_MAX_BYTES, MONITOR_UNCOVERED_EXIT_CODE, coveredLaneIds, isMonitorTaskLive, monitorReminderText, parseCanonicalWatchCommand, parseMonitorTranscript, readLiveMonitorEvidence, } from "./monitor.js";
 export { IMDS_HOST, IMDS_INSTANCE_ID_URL, IMDS_TIMEOUT_MS, IMDS_TOKEN_URL, defaultReadImdsInstanceId, resolveMachineIdentity, } from "./machine-identity.js";
 export { LANES_RUNS_REL as SPAWN_LANES_RUNS_REL, PID_LIVENESS_DECISIONS, PROVIDER_COMMAND, PROVIDER_MODEL_FLAG, SPAWN_TERMINAL_REASONS, ANSWERED_QUESTIONS_FILE, appendModelFlag, armLaneWatcher, buildProviderCommand, parseCliModel, resolveLaneModel, defaultProveDetached, isPidRecordAlive, laneRunDir, missingPidProbe, nextEnvelopePath, markSpawnFailure, parsePidRecord, parseProcStat, parseSpawnTerminalReason, probePidRecord, readPidRecord, readProcStarttime, readProcStarttimeDetailed, readSpawnManifest, resumePrompt, envelopeInstruction, spawnLaneWorker, stopLaneProcesses, watcherMainPath, workerEnv, } from "./spawn.js";
 export { SILENCE_MS, WATCHER_DECISION_EVENTS, WATCHER_OUT_MAX_BYTES, WATCHER_POLL_MS, WATCHER_SIGNAL_KINDS, appendCappedLog, appendWatcherSignal, applyTerminalToLane, classifyLaneExit, clearLaneStalled, isPidAlive, laneIdentityFromRecord, markLaneStalled, notifySlotFreed, parseWatcherSignalKind, readLatestEnvelope, runWatcherLoop, stalledReason, tickWatcher, watcherEventsPath, watcherLastSignalPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";

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

@@ -0,0 +1,48 @@
+export declare const MONITOR_MAX_TIMEOUT_MS = 1800000;
+export declare const MONITOR_UNCOVERED_EXIT_CODE = 2;
+export declare const MONITOR_ERROR_EXIT_CODE = 3;
+export declare const MONITOR_TRANSCRIPT_MAX_BYTES: number;
+export declare const MONITOR_TASK_OUTPUT_MAX_BYTES: number;
+export type MonitorEngine = "claude" | "codex" | "grok";
+export declare const MONITOR_ENGINES: readonly MonitorEngine[];
+export interface MonitorTaskEvidence {
+    taskId: string;
+    command: string;
+    startedAt: string;
+    timeoutMs: number;
+    persistent?: boolean;
+    stopped?: boolean;
+    outputPresent: boolean;
+    outputText?: string;
+    processAlive?: boolean;
+    outputPath?: string;
+}
+export interface MonitorEvidence {
+    sessionId: string;
+    tasks: readonly MonitorTaskEvidence[];
+    transcriptPaths?: readonly string[];
+    taskOutputPaths?: readonly string[];
+    processCommands?: readonly string[];
+}
+export interface LiveMonitorEvidenceOptions {
+    homedir?: () => string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    transcriptMaxBytes?: number;
+    taskOutputMaxBytes?: number;
+    readProcessCommands?: () => readonly string[];
+}
+/**
+ * Parse only the JSONL shape emitted by Claude Code's Monitor tool. The
+ * caller supplies a bounded tail; malformed or partial lines are ignored so a
+ * torn final write cannot turn into positive liveness evidence.
+ */
+export declare function parseMonitorTranscript(text: string): MonitorTaskEvidence[];
+/** Return argv only for the exact command form the gate arms. */
+export declare function parseCanonicalWatchCommand(command: string): string[] | null;
+export declare function isMonitorTaskLive(task: MonitorTaskEvidence, now: Date): boolean;
+export declare function coveredLaneIds(evidence: MonitorEvidence, now: Date): Set<string>;
+export declare function readLiveMonitorEvidence(sessionId: string, options?: LiveMonitorEvidenceOptions): MonitorEvidence;
+export type MonitorEvidenceReader = (sessionId: string) => MonitorEvidence | Promise<MonitorEvidence>;
+export declare function monitorReminderText(): string;
+//# sourceMappingURL=monitor.d.ts.map