@indigoai-us/hq-cli 5.134.0 → 5.136.0

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

package/dist/lib/lanes/monitor.js

@@ -0,0 +1,409 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+export const MONITOR_MAX_TIMEOUT_MS = 1_800_000;
+export const MONITOR_UNCOVERED_EXIT_CODE = 2;
+export const MONITOR_ERROR_EXIT_CODE = 3;
+export const MONITOR_TRANSCRIPT_MAX_BYTES = 512 * 1024;
+export const MONITOR_TASK_OUTPUT_MAX_BYTES = 64 * 1024;
+const SESSION_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+const LANE_ID_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+const TERMINAL_TASK_OUTPUT = /(?:\[(?:exited|killed|terminated|stopped)(?:\b|\])|task\s+(?:stopped|killed)|monitor\s+(?:stopped|expired))/i;
+export const MONITOR_ENGINES = [
+    "claude",
+    "codex",
+    "grok",
+];
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((item) => {
+        if (typeof item === "string")
+            return item;
+        if (item && typeof item === "object") {
+            const text = item.text;
+            const contentValue = item.content;
+            return typeof text === "string"
+                ? text
+                : typeof contentValue === "string"
+                    ? contentValue
+                    : "";
+        }
+        return "";
+    })
+        .join("\n");
+}
+function toolUseBlocks(row) {
+    const message = row.message;
+    if (!message || typeof message !== "object")
+        return [];
+    const content = message.content;
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((item) => Boolean(item && typeof item === "object" && item.type === "tool_use"));
+}
+function toolResultText(row) {
+    const message = row.message;
+    if (!message || typeof message !== "object")
+        return "";
+    return contentText(message.content);
+}
+function toolResultUseId(row) {
+    const message = row.message;
+    if (!message || typeof message !== "object")
+        return undefined;
+    const content = message.content;
+    if (!Array.isArray(content))
+        return undefined;
+    for (const item of content) {
+        if (!item || typeof item !== "object")
+            continue;
+        const block = item;
+        if (block.type === "tool_result") {
+            return stringValue(block.tool_use_id) ?? stringValue(block.toolUseId);
+        }
+    }
+    return undefined;
+}
+function monitorTaskId(text) {
+    const match = /\btask\s+([A-Za-z0-9_-]+)\b/i.exec(text);
+    return match?.[1];
+}
+function isMissingFilesystemEntry(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    const code = err.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+function monitorEvidenceUnreadable(filePath, err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    return new LanesError("monitor_evidence_unreadable", `Unable to read monitor evidence ${filePath}: ${cause}`, { path: filePath, cause });
+}
+/**
+ * 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 function parseMonitorTranscript(text) {
+    const pending = [];
+    const stoppedIds = new Set();
+    for (const line of text.split("\n")) {
+        if (line.length === 0)
+            continue;
+        let row;
+        try {
+            const parsed = JSON.parse(line);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                continue;
+            row = parsed;
+        }
+        catch {
+            continue;
+        }
+        for (const block of toolUseBlocks(row)) {
+            const name = stringValue(block.name);
+            const input = block.input;
+            const inputObject = input && typeof input === "object" && !Array.isArray(input)
+                ? input
+                : {};
+            if (name === "Monitor") {
+                const command = stringValue(inputObject.command);
+                const startedAt = stringValue(row.timestamp);
+                const timeoutMs = numberValue(inputObject.timeout_ms);
+                if (command && startedAt && timeoutMs && timeoutMs > 0) {
+                    pending.push({
+                        command,
+                        startedAt,
+                        timeoutMs,
+                        toolUseId: stringValue(block.id),
+                        persistent: typeof inputObject.persistent === "boolean"
+                            ? inputObject.persistent
+                            : undefined,
+                    });
+                }
+            }
+            else if (name === "TaskStop") {
+                const taskId = stringValue(inputObject.task_id) ?? stringValue(inputObject.taskId);
+                if (taskId)
+                    stoppedIds.add(taskId);
+            }
+        }
+        const toolUseResult = row.toolUseResult;
+        if (toolUseResult &&
+            typeof toolUseResult === "object" &&
+            !Array.isArray(toolUseResult)) {
+            const result = toolUseResult;
+            const taskId = stringValue(result.taskId) ??
+                stringValue(result.task_id) ??
+                monitorTaskId(toolResultText(row));
+            const resultUseId = toolResultUseId(row);
+            const candidate = resultUseId
+                ? pending.find((item) => item.taskId === undefined && item.toolUseId === resultUseId)
+                : pending.find((item) => item.taskId === undefined);
+            if (taskId && candidate) {
+                candidate.taskId = taskId;
+                candidate.timeoutMs =
+                    numberValue(result.timeoutMs) ?? candidate.timeoutMs;
+                if (typeof result.persistent === "boolean") {
+                    candidate.persistent = result.persistent;
+                }
+                const file = result.file;
+                if (file && typeof file === "object" && !Array.isArray(file)) {
+                    candidate.outputPath = stringValue(file.filePath);
+                }
+            }
+        }
+        else {
+            const taskId = monitorTaskId(toolResultText(row));
+            const resultUseId = toolResultUseId(row);
+            const candidate = resultUseId
+                ? pending.find((item) => item.taskId === undefined && item.toolUseId === resultUseId)
+                : pending.find((item) => item.taskId === undefined);
+            if (taskId && candidate)
+                candidate.taskId = taskId;
+        }
+    }
+    return pending
+        .filter((item) => Boolean(item.taskId))
+        .map((item) => ({
+        taskId: item.taskId,
+        command: item.command,
+        startedAt: item.startedAt,
+        timeoutMs: item.timeoutMs,
+        persistent: item.persistent,
+        stopped: item.stopped || stoppedIds.has(item.taskId),
+        outputPresent: false,
+        outputPath: item.outputPath,
+    }));
+}
+/** Return argv only for the exact command form the gate arms. */
+export function parseCanonicalWatchCommand(command) {
+    const tokens = command.trim().split(/\s+/u);
+    if (tokens.length < 4)
+        return null;
+    const executable = path.basename(tokens[0]);
+    if (executable !== "hq" || tokens[1] !== "lanes" || tokens[2] !== "watch") {
+        return null;
+    }
+    const laneIds = tokens.slice(3);
+    if (laneIds.some((laneId) => !LANE_ID_PATTERN.test(laneId)))
+        return null;
+    return laneIds;
+}
+function taskOutputIsTerminal(outputText) {
+    return outputText ? TERMINAL_TASK_OUTPUT.test(outputText) : false;
+}
+export function isMonitorTaskLive(task, now) {
+    if (task.stopped || task.processAlive !== true)
+        return false;
+    if (taskOutputIsTerminal(task.outputText))
+        return false;
+    const startedAt = Date.parse(task.startedAt);
+    if (!Number.isFinite(startedAt) || !Number.isFinite(task.timeoutMs) || task.timeoutMs <= 0) {
+        return false;
+    }
+    const deadline = startedAt + Math.min(task.timeoutMs, MONITOR_MAX_TIMEOUT_MS);
+    return now.getTime() < deadline;
+}
+export function coveredLaneIds(evidence, now) {
+    const covered = new Set();
+    for (const task of evidence.tasks) {
+        if (!isMonitorTaskLive(task, now))
+            continue;
+        const laneIds = parseCanonicalWatchCommand(task.command);
+        if (!laneIds)
+            continue;
+        for (const laneId of laneIds)
+            covered.add(laneId);
+    }
+    return covered;
+}
+function boundedTail(filePath, maxBytes) {
+    let fd;
+    let content = null;
+    let failure;
+    try {
+        const stat = fs.statSync(filePath);
+        const size = Math.min(stat.size, maxBytes);
+        fd = fs.openSync(filePath, "r");
+        const buffer = Buffer.alloc(size);
+        fs.readSync(fd, buffer, 0, size, Math.max(0, stat.size - size));
+        content = buffer.toString("utf8");
+    }
+    catch (err) {
+        if (!isMissingFilesystemEntry(err))
+            failure = monitorEvidenceUnreadable(filePath, err);
+    }
+    if (fd !== undefined) {
+        try {
+            fs.closeSync(fd);
+        }
+        catch (err) {
+            if (!isMissingFilesystemEntry(err) && !failure) {
+                failure = monitorEvidenceUnreadable(filePath, err);
+            }
+        }
+    }
+    if (failure)
+        throw failure;
+    return content;
+}
+function configDirs(home, env) {
+    const found = new Set();
+    const configured = env.CLAUDE_CONFIG_DIR?.trim() || path.join(home, ".claude");
+    found.add(configured);
+    try {
+        for (const name of fs.readdirSync(home)) {
+            if (name === ".claude" || name.startsWith(".claude-")) {
+                found.add(path.join(home, name));
+                found.add(path.join(home, name, ".claude"));
+            }
+        }
+    }
+    catch (err) {
+        if (!isMissingFilesystemEntry(err))
+            throw monitorEvidenceUnreadable(home, err);
+    }
+    const accountRoot = path.join(home, ".claude-accounts");
+    try {
+        for (const account of fs.readdirSync(accountRoot)) {
+            found.add(path.join(accountRoot, account, ".claude"));
+        }
+    }
+    catch (err) {
+        if (!isMissingFilesystemEntry(err))
+            throw monitorEvidenceUnreadable(accountRoot, err);
+    }
+    return [...found];
+}
+function transcriptPathsFor(home, env, sessionId) {
+    const paths = [];
+    for (const configDir of configDirs(home, env)) {
+        const projectsDir = path.join(configDir, "projects");
+        let projectDirs;
+        try {
+            projectDirs = fs.readdirSync(projectsDir);
+        }
+        catch (err) {
+            if (!isMissingFilesystemEntry(err))
+                throw monitorEvidenceUnreadable(projectsDir, err);
+            continue;
+        }
+        for (const projectDir of projectDirs) {
+            const candidate = path.join(projectsDir, projectDir, `${sessionId}.jsonl`);
+            try {
+                if (fs.statSync(candidate).isFile())
+                    paths.push(candidate);
+            }
+            catch (err) {
+                if (!isMissingFilesystemEntry(err))
+                    throw monitorEvidenceUnreadable(candidate, err);
+            }
+        }
+    }
+    return [...new Set(paths)];
+}
+function taskOutputCandidates(transcriptPath, sessionId, task) {
+    const candidates = [];
+    if (task.outputPath)
+        candidates.push(task.outputPath);
+    const projectDir = path.basename(path.dirname(transcriptPath));
+    try {
+        for (const tempName of fs.readdirSync(os.tmpdir())) {
+            if (!tempName.startsWith("claude-"))
+                continue;
+            candidates.push(path.join(os.tmpdir(), tempName, projectDir, sessionId, "tasks", `${task.taskId}.output`));
+        }
+    }
+    catch (err) {
+        if (!isMissingFilesystemEntry(err))
+            throw monitorEvidenceUnreadable(os.tmpdir(), err);
+    }
+    return [...new Set(candidates)];
+}
+function defaultProcessCommands() {
+    try {
+        const output = execFileSync("ps", ["-eww", "-o", "args="], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return output
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function processHasExactCommand(processCommands, command) {
+    return processCommands.some((line) => line.trim() === command);
+}
+export function readLiveMonitorEvidence(sessionId, options = {}) {
+    if (!SESSION_ID_PATTERN.test(sessionId)) {
+        throw new LanesError("monitor_invalid_session", `Invalid senior session id ${JSON.stringify(sessionId)}`);
+    }
+    const home = options.homedir?.() ?? os.homedir();
+    const env = options.env ?? process.env;
+    const transcriptMaxBytes = options.transcriptMaxBytes ?? MONITOR_TRANSCRIPT_MAX_BYTES;
+    const taskOutputMaxBytes = options.taskOutputMaxBytes ?? MONITOR_TASK_OUTPUT_MAX_BYTES;
+    const processCommands = options.readProcessCommands?.() ?? defaultProcessCommands();
+    const tasks = new Map();
+    const transcriptPaths = transcriptPathsFor(home, env, sessionId);
+    const taskOutputPaths = [];
+    for (const transcriptPath of transcriptPaths) {
+        const transcript = boundedTail(transcriptPath, transcriptMaxBytes);
+        if (transcript === null)
+            continue;
+        for (const parsed of parseMonitorTranscript(transcript)) {
+            const outputCandidates = taskOutputCandidates(transcriptPath, sessionId, parsed);
+            let outputPath;
+            let outputText;
+            for (const candidate of outputCandidates) {
+                const content = boundedTail(candidate, taskOutputMaxBytes);
+                if (content === null)
+                    continue;
+                outputPath = candidate;
+                outputText = content;
+                taskOutputPaths.push(candidate);
+                break;
+            }
+            tasks.set(parsed.taskId, {
+                ...parsed,
+                outputPresent: outputPath !== undefined,
+                outputPath: outputPath ?? parsed.outputPath,
+                outputText,
+                processAlive: processHasExactCommand(processCommands, parsed.command)
+                    ? true
+                    : undefined,
+            });
+        }
+    }
+    return {
+        sessionId,
+        tasks: [...tasks.values()],
+        transcriptPaths,
+        taskOutputPaths: [...new Set(taskOutputPaths)],
+        processCommands,
+    };
+}
+export function monitorReminderText() {
+    return [
+        "For active Claude senior lanes, arm one live Claude Code Monitor task per uncovered lane:",
+        'Monitor(command="hq lanes watch <lane-id>...", timeout_ms=1800000, persistent=true)',
+        "Use `hq lanes monitor-check --session <id>` to verify coverage. `persistent=true` is requested where the installed Monitor tool honors it; Claude Code caps Monitor tasks at 30 minutes, so re-arm after expiry.",
+        "The caller must pass `--engine codex` or `--engine grok` (or set HQ_CONDUCT_ENGINE) for sessions whose engine has no Claude Monitor tool; those engines are never required to provide one.",
+    ].join("\n");
+}
+//# sourceMappingURL=monitor.js.map

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

@@ -21,6 +21,9 @@ declare const PROVIDER_COMMAND: Record<LaneProvider, string>;
 export declare function providerCommandOnPath(command: string, pathEnv: string | undefined): boolean;
 /** Per-provider model flag. A missing entry means --model is refused. */
 export declare const PROVIDER_MODEL_FLAG: Record<LaneProvider, string>;
+export declare const CLAUDE_AUTO_COMPACT_ENV = "CLAUDE_CODE_AUTO_COMPACT_WINDOW";
+/** Codex CLI overrides required for its ChatGPT fast service tier. */
+export declare const CODEX_FAST_MODE_FLAGS: readonly ["-c", "service_tier=\"fast\"", "--enable", "fast_mode"];
 export declare function parseCliModel(raw: string | undefined): string | undefined;
 export declare function resolveLaneModel(input: {
     cliModel?: string;
@@ -28,6 +31,8 @@ export declare function resolveLaneModel(input: {
     providerModel?: string;
 }): string | undefined;
 export declare function appendModelFlag(provider: LaneProvider, args: string[], model: string | undefined): string[];
+/** Add Codex fast-mode flags before the prompt/positional separator. */
+export declare function appendFastModeFlags(provider: LaneProvider, args: string[], enabled: boolean | undefined): string[];
 export type DetachedStdio = ["ignore", number, number];
 export interface DetachedSpawnOptions {
     detached: true;
@@ -190,6 +195,8 @@ export declare function buildProviderCommand(provider: LaneProvider, input: {
     model?: string;
     /** Validated against the provider's own value set by appendEffortFlag. */
     effort?: string;
+    /** Enable Codex's fast service tier for this resolved model. */
+    fastMode?: boolean;
     /** Continue a recorded session. Only providers in PROVIDER_SESSION_RESUME accept this. */
     resume?: ProviderResumeInput;
     /**
@@ -202,7 +209,7 @@ export declare function buildProviderCommand(provider: LaneProvider, input: {
 export declare function workerEnv(base: NodeJS.ProcessEnv, resolved: {
     envVar: string;
     home: string;
-}, laneId: string, hqRoot: string): NodeJS.ProcessEnv;
+}, laneId: string, hqRoot: string, autoCompactTokens?: number): NodeJS.ProcessEnv;
 export declare function markSpawnFailure(hqRoot: string, laneId: string, reasonRaw: string, details: Record<string, unknown>): LaneRecord;
 /**
  * Spec §5.2 executing-side check. Compares this machine's identity to
@@ -219,6 +226,7 @@ export interface SpawnManifestFile {
     } | null;
     /** Byte length of logs/worker.out before this run started; its result is after this. */
     worker_out_offset?: number;
+    fast_mode?: boolean;
 }
 /** Read the per-run manifest. Missing file or field reads as absent. */
 export declare function readSpawnManifest(runDir: string): SpawnManifestFile;
@@ -268,6 +276,7 @@ export declare function envelopeRepairMode(provider: LaneProvider): EnvelopeRepa
  * prompt as a fresh single turn on the same account (`fresh_turn` mode). It
  * replaces `worker.pid` and rewrites `spawn.json` so the watcher's next tick
  * follows the new process. The account is the one already bound on the record.
+ * Fast-mode evidence is updated after the replacement is proven detached.
  */
 export declare function spawnEnvelopeRepair(hqRoot: string, lane: LaneRecord, input: EnvelopeRepairSpawnInput, deps?: SpawnLaneDeps): number;
 export { PROVIDER_HOME_ENV, PROVIDER_COMMAND };