@indigoai-us/hq-cli 5.134.0 → 5.136.0

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

package/dist/lib/lanes/types.js

@@ -203,7 +203,7 @@ export const LANE_FIELD_WRITERS = {
     priority: ["command"], worker: ["creator"], worker_path: ["creator"], worker_pack: ["creator"],
     provider: ["creator"], account: ["creator", "spawn", "command"], account_history: ["command"], pending_resume: ["command", "spawn"], host: ["creator"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
-    last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"],
+    last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"], fast_mode: ["spawn"],
     last_message_at: ["command"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],

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

@@ -0,0 +1,22 @@
+import { type LaneRecord, type QuestionRecord } from "./types.js";
+export declare const DEFAULT_LANE_WATCH_INTERVAL_MS = 5000;
+export declare const MAX_LANE_WATCH_INTERVAL_MS = 30000;
+export declare const MAX_WATCHED_LANES = 64;
+export declare const MAX_WATCH_OUTPUT_LINES = 512;
+export interface LaneWatchDeps {
+    readLane?: (hqRoot: string, laneId: string) => LaneRecord | null;
+    listQuestionIds?: (hqRoot: string) => string[];
+    readQuestion?: (hqRoot: string, questionId: string) => QuestionRecord | null;
+    sleep?: (ms: number) => Promise<void>;
+    intervalMs?: number;
+    maxOutputLines?: number;
+    writeLine?: (line: string) => void;
+    writeError?: (line: string) => void;
+}
+export interface LaneWatchResult {
+    polls: number;
+    lines: number;
+    suppressed: boolean;
+}
+export declare function runLaneWatch(hqRoot: string, laneIds: readonly string[], deps?: LaneWatchDeps): Promise<LaneWatchResult>;
+//# sourceMappingURL=watch.d.ts.map

package/dist/lib/lanes/watch.js

@@ -0,0 +1,122 @@
+import { listQuestionIds, readLane, readQuestion, } from "./store.js";
+import { LaneNotFoundError, LanesError } from "./errors.js";
+import { isTerminalLaneState } from "./types.js";
+export const DEFAULT_LANE_WATCH_INTERVAL_MS = 5_000;
+export const MAX_LANE_WATCH_INTERVAL_MS = 30_000;
+export const MAX_WATCHED_LANES = 64;
+export const MAX_WATCH_OUTPUT_LINES = 512;
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function readableError(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function boundedInterval(intervalMs) {
+    const value = intervalMs ?? DEFAULT_LANE_WATCH_INTERVAL_MS;
+    if (!Number.isFinite(value))
+        return DEFAULT_LANE_WATCH_INTERVAL_MS;
+    return Math.min(MAX_LANE_WATCH_INTERVAL_MS, Math.max(100, Math.floor(value)));
+}
+function validateLaneIds(laneIds) {
+    const unique = [...new Set(laneIds.map((laneId) => laneId.trim()))];
+    if (unique.some((laneId) => laneId.length === 0)) {
+        throw new LanesError("watch_invalid_lane_id", "Lane ids must not be empty");
+    }
+    if (unique.length === 0) {
+        throw new LanesError("watch_no_lanes", "hq lanes watch requires at least one lane id");
+    }
+    if (unique.length > MAX_WATCHED_LANES) {
+        throw new LanesError("watch_too_many_lanes", `hq lanes watch accepts at most ${MAX_WATCHED_LANES} lane ids`, { max: MAX_WATCHED_LANES });
+    }
+    return unique;
+}
+export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
+    const watchedIds = validateLaneIds(laneIds);
+    const readLaneRecord = deps.readLane ?? readLane;
+    const listQuestions = deps.listQuestionIds ?? listQuestionIds;
+    const readQuestionRecord = deps.readQuestion ?? readQuestion;
+    const sleep = deps.sleep ?? defaultSleep;
+    const writeLine = deps.writeLine ?? ((line) => console.log(line));
+    const writeError = deps.writeError ?? ((line) => process.stderr.write(`${line}\n`));
+    const maxOutputLines = Math.max(1, Math.floor(deps.maxOutputLines ?? MAX_WATCH_OUTPUT_LINES));
+    const intervalMs = boundedInterval(deps.intervalMs);
+    const previousStates = new Map();
+    const previousQuestionStatuses = new Map();
+    let polls = 0;
+    let lines = 0;
+    let suppressed = false;
+    const emit = (line) => {
+        if (lines < maxOutputLines - 1) {
+            writeLine(line);
+            lines += 1;
+            return;
+        }
+        if (!suppressed) {
+            writeLine("lane watch: output limit reached; further events suppressed");
+            lines = maxOutputLines;
+            suppressed = true;
+        }
+    };
+    const unreadable = (kind, id, err) => {
+        const message = `${kind} ${id}: unreadable record (${readableError(err)})`;
+        writeError(`lane watch: ${message}`);
+        throw new LanesError("watch_record_unreadable", message, {
+            kind,
+            id,
+            cause: readableError(err),
+        });
+    };
+    while (true) {
+        polls += 1;
+        const records = [];
+        for (const laneId of watchedIds) {
+            let record = null;
+            try {
+                record = readLaneRecord(hqRoot, laneId);
+            }
+            catch (err) {
+                unreadable("lane", laneId, err);
+            }
+            if (!record) {
+                unreadable("lane", laneId, new LaneNotFoundError("lane", laneId));
+                continue;
+            }
+            records.push(record);
+            if (previousStates.get(laneId) !== record.state) {
+                emit(`lane ${laneId}: state=${record.state}${isTerminalLaneState(record.state) ? " (terminal)" : ""}`);
+                previousStates.set(laneId, record.state);
+            }
+        }
+        let questionIds = [];
+        try {
+            questionIds = listQuestions(hqRoot);
+        }
+        catch (err) {
+            unreadable("question", "<index>", err);
+        }
+        const watchedSet = new Set(watchedIds);
+        for (const questionId of questionIds) {
+            let record = null;
+            try {
+                record = readQuestionRecord(hqRoot, questionId);
+            }
+            catch (err) {
+                unreadable("question", questionId, err);
+            }
+            if (!record) {
+                unreadable("question", questionId, new LaneNotFoundError("question", questionId));
+                continue;
+            }
+            if (watchedSet.has(record.lane_id) &&
+                previousQuestionStatuses.get(questionId) !== record.status) {
+                emit(`lane ${record.lane_id}: question=${record.question_id} status=${record.status}`);
+            }
+            previousQuestionStatuses.set(questionId, record.status);
+        }
+        if (records.every((record) => isTerminalLaneState(record.state))) {
+            return { polls, lines, suppressed };
+        }
+        await sleep(intervalMs);
+    }
+}
+//# sourceMappingURL=watch.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.134.0",
+  "version": "5.136.0",
   "description": "HQ by Indigo management CLI \u2014 modules and cloud sync",
   "main": "dist/index.js",
   "bin": {