@indigoai-us/hq-cli 5.134.0 → 5.135.0

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 };

package/dist/lib/lanes/spawn.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from "node:url";
 import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, } from "./accounts.js";
 import { COMPACTION_PROMPT, compactionAfterUsage, compactionDue, compactLaneSession, } from "./compaction.js";
 import { installDrainHook } from "./hooks-install.js";
-import { loadLanesConfig, providerCompactAfterMs } from "./config.js";
+import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } from "./config.js";
 import { appendEffortFlag, resolveLaneEffort } from "./effort.js";
 import { claimableStatesFor, planLaneLaunch, providerSupportsSessionResume, } from "./delivery.js";
 import { AccountResolutionError, LanesError } from "./errors.js";
@@ -64,6 +64,14 @@ export const PROVIDER_MODEL_FLAG = {
     codex: "-m",
     grok: "-m",
 };
+export const CLAUDE_AUTO_COMPACT_ENV = "CLAUDE_CODE_AUTO_COMPACT_WINDOW";
+/** Codex CLI overrides required for its ChatGPT fast service tier. */
+export const CODEX_FAST_MODE_FLAGS = [
+    "-c",
+    'service_tier="fast"',
+    "--enable",
+    "fast_mode",
+];
 export function parseCliModel(raw) {
     if (raw === undefined)
         return undefined;
@@ -101,6 +109,16 @@ export function appendModelFlag(provider, args, model) {
     }
     return [...args, flag, model];
 }
+/** Add Codex fast-mode flags before the prompt/positional separator. */
+export function appendFastModeFlags(provider, args, enabled) {
+    if (provider !== "codex" || enabled !== true)
+        return args;
+    const flags = [...CODEX_FAST_MODE_FLAGS];
+    const end = args.indexOf("--");
+    if (end === -1)
+        return [...args, ...flags];
+    return [...args.slice(0, end), ...flags, ...args.slice(end)];
+}
 export const PID_LIVENESS_DECISIONS = [
     "esrch",
     "starttime_mismatch",
@@ -695,10 +713,10 @@ export function buildProviderCommand(provider, input) {
     }
     return {
         command,
-        args: appendEffortFlag(parsed, appendModelFlag(parsed, args, input.model), input.effort),
+        args: appendFastModeFlags(parsed, appendEffortFlag(parsed, appendModelFlag(parsed, args, input.model), input.effort), input.fastMode),
     };
 }
-export function workerEnv(base, resolved, laneId, hqRoot) {
+export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens) {
     const accepted = Object.values(PROVIDER_HOME_ENV);
     if (!accepted.includes(resolved.envVar)) {
         throw new LanesError("unknown_provider_home_env", `Unknown provider home variable ${JSON.stringify(resolved.envVar)}. Accepted: ${accepted.join(", ")}`, { accepted, value: resolved.envVar });
@@ -707,6 +725,10 @@ export function workerEnv(base, resolved, laneId, hqRoot) {
     delete env.HQ_PROJECT_ID;
     delete env.HQ_STORY_ID;
     env[resolved.envVar] = resolved.home;
+    delete env[CLAUDE_AUTO_COMPACT_ENV];
+    if (resolved.envVar === PROVIDER_HOME_ENV.claude && autoCompactTokens !== undefined) {
+        env[CLAUDE_AUTO_COMPACT_ENV] = String(autoCompactTokens);
+    }
     env.HQ_LANE_ID = laneId;
     env.HQ_ROOT = hqRoot;
     return env;
@@ -883,6 +905,7 @@ function writeSpawnManifest(runDir, input) {
         envelope_path: input.envelopePath,
         resume: input.resume,
         worker_out_offset: input.workerOutOffset,
+        ...(input.fastMode ? { fast_mode: true } : {}),
     }, null, 2)}\n`);
 }
 /** Arm (or re-arm) the detached per-lane watcher. */
@@ -944,6 +967,8 @@ export function readSpawnManifest(runDir) {
         rec.worker_out_offset >= 0) {
         out.worker_out_offset = rec.worker_out_offset;
     }
+    if (typeof rec.fast_mode === "boolean")
+        out.fast_mode = rec.fast_mode;
     if (rec.resume &&
         typeof rec.resume === "object" &&
         typeof rec.resume.session_id === "string") {
@@ -1042,7 +1067,6 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         process.stderr.write(`hq lanes: drain hook install failed for ${resolved.home}: ${err instanceof Error ? err.message : String(err)}\n`);
         throw err;
     }
-    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot);
     const briefPath = path.join(runDir, "brief.md");
     const envelopePath = nextEnvelopePath(runDir);
     const lastMessagePath = path.join(logsDir, "last-message.txt");
@@ -1051,6 +1075,10 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         ? `Previously answered questions are at ${answersPath}; treat those choices as operator decisions that outrank the brief.`
         : undefined;
     const accountCfg = config.providers[lane.provider].accounts[resolved.id];
+    const autoCompactTokens = lane.provider === "claude"
+        ? providerAutoCompactTokens(config.providers.claude)
+        : undefined;
+    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens);
     const model = resolveLaneModel({
         cliModel: lane.model,
         accountModel: accountCfg?.model,
@@ -1062,6 +1090,9 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         providerEffort: config.providers[lane.provider].effort,
         model,
     });
+    const fastMode = lane.provider === "codex" &&
+        model !== undefined &&
+        (config.providers.codex.fast_mode_models ?? []).includes(model);
     const resume = plan.mode === "resume"
         ? {
             session_id: plan.session_id,
@@ -1090,6 +1121,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         extraPrompt,
         model,
         effort: effort.effort,
+        fastMode,
         resume,
     });
     // A systemd PATH mismatch is an environment defect, not a lane failure.
@@ -1137,6 +1169,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 lastMessagePath,
                 model,
                 effort: effort.effort,
+                fastMode,
                 resume: { session_id: resume.session_id, prompt: COMPACTION_PROMPT },
             });
             compaction = compactLaneSession({
@@ -1187,6 +1220,10 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             next.effort = effort.effort;
         else
             delete next.effort;
+        if (fastMode)
+            next.fast_mode = true;
+        else
+            delete next.fast_mode;
         // Freeze the counters of the run that followed the previous compaction
         // before this launch replaces last_resume.
         if (current.last_compaction && current.last_compaction.after === null) {
@@ -1257,6 +1294,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             envelopePath,
             resume: resume ? { session_id: resume.session_id } : null,
             workerOutOffset,
+            fastMode,
         });
     }
     catch (err) {
@@ -1300,6 +1338,7 @@ export function envelopeRepairMode(provider) {
  * 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 function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
     const env = deps.env ?? process.env;
@@ -1321,7 +1360,10 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
         existsSync,
         model: lane.model,
     });
-    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot);
+    const autoCompactTokens = lane.provider === "claude"
+        ? providerAutoCompactTokens(config.providers.claude)
+        : undefined;
+    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens);
     const accountCfg = config.providers[lane.provider].accounts[resolved.id];
     const model = resolveLaneModel({
         cliModel: lane.model,
@@ -1334,6 +1376,9 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
         providerEffort: config.providers[lane.provider].effort,
         model,
     });
+    const fastMode = lane.provider === "codex" &&
+        model !== undefined &&
+        (config.providers.codex.fast_mode_models ?? []).includes(model);
     const repairPrompt = envelopeRepairPrompt({
         envelopePath: input.envelopePath,
         error: input.error,
@@ -1346,6 +1391,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
         lastMessagePath: path.join(logsDir, "last-message.txt"),
         model,
         effort: effort.effort,
+        fastMode,
         ...(mode === "resume" && sessionId !== null
             ? { resume: { session_id: sessionId, prompt: repairPrompt } }
             : { freshTurnPrompt: repairPrompt }),
@@ -1371,6 +1417,15 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             envelopePath: previous.envelope_path ?? input.envelopePath,
             resume: mode === "resume" && sessionId !== null ? { session_id: sessionId } : null,
             workerOutOffset,
+            fastMode,
+        });
+        retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
+            const next = { ...current };
+            if (fastMode)
+                next.fast_mode = true;
+            else
+                delete next.fast_mode;
+            return next;
         });
     }
     catch (err) {

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

@@ -300,6 +300,8 @@ export interface LaneRecord {
     effort?: string;
     /** Where `effort` came from. `cli` pins it across later spawns. */
     effort_source?: "cli" | "account" | "provider" | "default_rule" | "none";
+    /** Whether the last spawn used Codex fast mode, including false when disabled. */
+    fast_mode?: boolean;
     /** Time of the last operator message accepted for this lane. Drives compaction. */
     last_message_at?: string;
     /** Last automatic compaction of a resumed session (compaction.ts). */
@@ -540,11 +542,15 @@ export interface ProviderConfig {
     model?: string;
     /** Default effort for this provider when the account does not set one. */
     effort?: string;
+    /** Codex model ids that should use the provider's fast service tier. */
+    fast_mode_models?: string[];
     /**
      * Resume-time compaction threshold: a resumed session whose last message is
      * at least this old is compacted first. Absent means the one-hour default.
      */
     compact_after_ms?: number;
+    /** Claude Code auto-compaction threshold, in tokens. */
+    auto_compact_tokens?: number;
     /**
      * Watcher throttle for `lane_progress` thread events: at most one per this
      * interval, and only on a tick that saw new tool activity or output. Absent