@indigoai-us/hq-cli 5.134.0 → 5.135.0

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.135.0",
   "description": "HQ by Indigo management CLI \u2014 modules and cloud sync",
   "main": "dist/index.js",
   "bin": {