@indigoai-us/hq-cli 5.133.0 → 5.135.0

package/dist/lib/doctor/checks/bots.js

@@ -76,11 +76,14 @@ function runChecks(deps) {
         const status = readBotStatus(dir);
         const alive = !!status && status.state === "running" && isPidAlive(status.pid);
         if (alive && status.lastHeartbeatOk === false) {
+            const heartbeatMessage = status.lastHeartbeatReason === "identity_mismatch"
+                ? `${name} heartbeat stopped: identity mismatch (configured agent ${status.lastHeartbeatConfiguredAgentUid ?? config.agentUid}; token agent ${status.lastHeartbeatTokenAgentUid ?? "unknown"}).`
+                : `${name} is running but cannot heartbeat to HQ${status.lastHeartbeatError ? ` (${status.lastHeartbeatError})` : ""}.`;
             results.push({
                 status: "FAIL",
                 checkId: `bots.${name}.heartbeat`,
                 target: dir,
-                message: `${name} is running but cannot heartbeat to HQ${status.lastHeartbeatError ? ` (${status.lastHeartbeatError})` : ""}.`,
+                message: heartbeatMessage,
                 remediation: `hq bot logs ${name}`,
             });
         }

package/dist/lib/heartbeat-identity.d.ts

@@ -0,0 +1,29 @@
+import type { CaptureContext } from "@sentry/node";
+export declare const HEARTBEAT_IDENTITY_MISMATCH_CODE = "AGENT_IDENTITY_MISMATCH";
+export type HeartbeatRunner = "agent-kit" | "bot";
+export type HeartbeatAgentUidSource = "config_file" | "env" | "flag";
+export type HeartbeatCredsSource = "explicit" | "default";
+export interface HeartbeatFailure {
+    status: number;
+    code?: string;
+    message?: string;
+}
+export interface HeartbeatIdentityMismatchContext {
+    runner: HeartbeatRunner;
+    configuredAgentUid: string;
+    tokenAgentUid?: string;
+    agentUidSource: HeartbeatAgentUidSource;
+    credsSource: HeartbeatCredsSource;
+}
+export type HeartbeatIdentityMismatchReporter = (context: HeartbeatIdentityMismatchContext) => void;
+/** Parse only the bounded fields the heartbeat route uses for classification. */
+export declare function parseHeartbeatFailureBody(bodyText: string | undefined): {
+    code?: string;
+    message?: string;
+};
+/** Match the server's registered code/name, never an arbitrary 403. */
+export declare function isHeartbeatIdentityMismatch(failure: HeartbeatFailure): boolean;
+/** Read the agent uid claim for diagnostics only; this never authorizes a call. */
+export declare function tokenAgentUid(token: string): string | undefined;
+export declare function captureHeartbeatIdentityMismatch(context: HeartbeatIdentityMismatchContext, captureMessage?: (message: string, context: CaptureContext) => string): void;
+//# sourceMappingURL=heartbeat-identity.d.ts.map

package/dist/lib/heartbeat-identity.js

@@ -0,0 +1,71 @@
+import { CLI_VERSION } from "../cli-version.js";
+import { Sentry } from "../sentry.js";
+import { peekIdToken } from "../utils/id-token.js";
+export const HEARTBEAT_IDENTITY_MISMATCH_CODE = "AGENT_IDENTITY_MISMATCH";
+const AGENT_UID_RE = /^agt_[A-Za-z0-9_-]{1,100}$/;
+function normalize(value) {
+    return (value ?? "").replace(/[^A-Za-z0-9]/g, "").toLowerCase();
+}
+function safeAgentUid(value) {
+    return typeof value === "string" && AGENT_UID_RE.test(value) ? value : undefined;
+}
+/** Parse only the bounded fields the heartbeat route uses for classification. */
+export function parseHeartbeatFailureBody(bodyText) {
+    if (!bodyText)
+        return {};
+    try {
+        const body = JSON.parse(bodyText);
+        const code = typeof body.code === "string" ? body.code.slice(0, 120) : undefined;
+        const message = typeof body.error === "string"
+            ? body.error.slice(0, 300)
+            : typeof body.message === "string"
+                ? body.message.slice(0, 300)
+                : undefined;
+        return { ...(code ? { code } : {}), ...(message ? { message } : {}) };
+    }
+    catch {
+        return {};
+    }
+}
+/** Match the server's registered code/name, never an arbitrary 403. */
+export function isHeartbeatIdentityMismatch(failure) {
+    if (failure.status !== 403)
+        return false;
+    const code = normalize(failure.code);
+    if (code === normalize(HEARTBEAT_IDENTITY_MISMATCH_CODE) || code === "agentidentitymismatcherror")
+        return true;
+    const message = normalize(failure.message);
+    return (message.includes("heartbeatmustbereportedbytheagentsownmachineidentity") ||
+        message.includes("agentidentitymismatcherror"));
+}
+/** Read the agent uid claim for diagnostics only; this never authorizes a call. */
+export function tokenAgentUid(token) {
+    const claims = peekIdToken(token);
+    return (safeAgentUid(claims["custom:entityUid"]) ??
+        safeAgentUid(claims.entityUid) ??
+        safeAgentUid(claims.sub));
+}
+function diagnosticUid(value) {
+    return safeAgentUid(value) ?? "unknown";
+}
+function captureHeartbeatIdentityMismatchMessage(message, context) {
+    return Sentry.captureMessage(message, context);
+}
+export function captureHeartbeatIdentityMismatch(context, captureMessage = captureHeartbeatIdentityMismatchMessage) {
+    const options = {
+        level: "warning",
+        fingerprint: ["heartbeat-identity-mismatch"],
+        tags: {
+            agent_uid_source: context.agentUidSource,
+            creds_source: context.credsSource,
+            runner: context.runner,
+            hq_cli_version: CLI_VERSION,
+        },
+        extra: {
+            configured_agent_uid: diagnosticUid(context.configuredAgentUid),
+            ...(context.tokenAgentUid ? { token_agent_uid: diagnosticUid(context.tokenAgentUid) } : {}),
+        },
+    };
+    captureMessage("heartbeat identity mismatch", options);
+}
+//# sourceMappingURL=heartbeat-identity.js.map

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