@indigoai-us/hq-cli 5.222.0 → 5.224.0

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

@@ -1,16 +1,33 @@
-import { type LaneRecord, type QuestionRecord } from "./types.js";
+import { type LaneHost, type LaneProvider, 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 LaneWatchAccountStatus {
+    lane_id: string;
+    provider: LaneProvider;
+    account: string;
+    host: LaneHost;
+    logged_in: boolean | null;
+}
+export interface LaneAccountLoggedOutEvent {
+    event: "account_logged_out";
+    provider: LaneProvider;
+    account: string;
+    host: LaneHost;
+    lane_ids: string[];
+}
 export interface LaneWatchDeps {
     readLane?: (hqRoot: string, laneId: string) => LaneRecord | null;
     listQuestionIds?: (hqRoot: string) => string[];
     readQuestion?: (hqRoot: string, questionId: string) => QuestionRecord | null;
+    readAccountStatuses?: (lanes: readonly LaneRecord[]) => Promise<readonly LaneWatchAccountStatus[]>;
+    keepAliveEnabled?: (lane: LaneRecord) => boolean | Promise<boolean>;
     sleep?: (ms: number) => Promise<void>;
     intervalMs?: number;
     maxOutputLines?: number;
     writeLine?: (line: string) => void;
+    writeAccountEvent?: (event: LaneAccountLoggedOutEvent) => void;
     writeError?: (line: string) => void;
 }
 export interface LaneWatchResult {

package/dist/lib/lanes/watch.js

@@ -1,6 +1,8 @@
 import { listQuestionIds, readLane, readQuestion, } from "./store.js";
 import { LaneNotFoundError, LanesError } from "./errors.js";
-import { isTerminalLaneState } from "./types.js";
+import { providerSupportsSessionResume } from "./delivery.js";
+import { LEAD_LANE_KEEP_ALIVE_MAX_RESUMES } from "./keep-alive.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;
@@ -30,6 +32,30 @@ function validateLaneIds(laneIds) {
     }
     return unique;
 }
+function canResumeKeepAliveLane(lane) {
+    if (lane.keep_alive !== true ||
+        lane.keep_alive_opted_in_at === undefined ||
+        !Number.isFinite(Date.parse(lane.keep_alive_opted_in_at)) ||
+        lane.keep_alive_exhausted_at !== undefined ||
+        (lane.keep_alive_resume_count ?? 0) >= LEAD_LANE_KEEP_ALIVE_MAX_RESUMES ||
+        lane.keep_alive_blocked_reason === "retired" ||
+        lane.keep_alive_blocked_reason === "superseded" ||
+        lane.keep_alive_blocked_reason === "retired_list_invalid" ||
+        lane.keep_alive_blocked_reason === "terminal_state" ||
+        !providerSupportsSessionResume(lane.provider) ||
+        !(lane.provider_session_id ?? lane.last_resume?.session_id))
+        return false;
+    if (lane.state === "interrupted") {
+        return lane.terminal_reason === "exited_with_partial_output";
+    }
+    if (lane.state === "done") {
+        return lane.last_envelope?.decision === "done" &&
+            lane.story_complete !== true &&
+            lane.terminal_reason !== "provider_rejected" &&
+            lane.terminal_reason !== "account_not_logged_in";
+    }
+    return false;
+}
 export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
     const watchedIds = validateLaneIds(laneIds);
     const readLaneRecord = deps.readLane ?? readLane;
@@ -37,11 +63,15 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
     const readQuestionRecord = deps.readQuestion ?? readQuestion;
     const sleep = deps.sleep ?? defaultSleep;
     const writeLine = deps.writeLine ?? ((line) => console.log(line));
+    const writeAccountEvent = deps.writeAccountEvent ?? ((event) => {
+        writeLine(`account_logged_out provider=${event.provider} account=${event.account} host=${event.host.kind}:${event.host.id} lane_ids=${event.lane_ids.join(",")}`);
+    });
     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();
+    const previousAccountLogin = new Map();
     let polls = 0;
     let lines = 0;
     let suppressed = false;
@@ -57,6 +87,18 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
             suppressed = true;
         }
     };
+    const emitAccountEvent = (event) => {
+        if (lines < maxOutputLines - 1) {
+            writeAccountEvent(event);
+            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}`);
@@ -87,6 +129,15 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
                 previousStates.set(laneId, record.state);
             }
         }
+        const keepAliveWaiting = new Set();
+        if (deps.keepAliveEnabled !== undefined) {
+            for (const record of records) {
+                if (isTerminalLaneState(record.state) &&
+                    canResumeKeepAliveLane(record) &&
+                    await deps.keepAliveEnabled(record))
+                    keepAliveWaiting.add(record.lane_id);
+            }
+        }
         let questionIds = [];
         try {
             questionIds = listQuestions(hqRoot);
@@ -113,7 +164,76 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
             }
             previousQuestionStatuses.set(questionId, record.status);
         }
-        if (records.every((record) => isTerminalLaneState(record.state))) {
+        if (deps.readAccountStatuses !== undefined) {
+            const accountLanes = records.filter((record) => record.account !== undefined &&
+                (!isTerminalLaneState(record.state) || keepAliveWaiting.has(record.lane_id)));
+            let statuses;
+            try {
+                statuses = await deps.readAccountStatuses(accountLanes);
+            }
+            catch (err) {
+                const message = `account login status: ${readableError(err)}`;
+                writeError(`lane watch: ${message}`);
+                throw new LanesError("watch_account_status_unavailable", message, {
+                    cause: readableError(err),
+                });
+            }
+            const statusLanes = new Map(accountLanes.map((record) => [record.lane_id, record]));
+            const grouped = new Map();
+            const seenLaneIds = new Set();
+            for (const status of statuses) {
+                const lane = statusLanes.get(status.lane_id);
+                if (!lane || lane.provider !== status.provider || lane.account !== status.account ||
+                    lane.host.kind !== status.host.kind || lane.host.id !== status.host.id ||
+                    (status.logged_in !== true && status.logged_in !== false && status.logged_in !== null) ||
+                    seenLaneIds.has(status.lane_id)) {
+                    const message = `malformed account login status for lane ${JSON.stringify(status.lane_id)}`;
+                    writeError(`lane watch: ${message}`);
+                    throw new LanesError("watch_account_status_invalid", message, {
+                        lane_id: status.lane_id,
+                    });
+                }
+                seenLaneIds.add(status.lane_id);
+                const key = JSON.stringify([status.provider, status.account, status.host.kind, status.host.id]);
+                const existing = grouped.get(key);
+                if (existing && existing.status.logged_in !== status.logged_in) {
+                    const message = `conflicting account login statuses for ${status.provider} account ${status.account} on ${status.host.kind}:${status.host.id}`;
+                    writeError(`lane watch: ${message}`);
+                    throw new LanesError("watch_account_status_invalid", message, {
+                        provider: status.provider,
+                        account: status.account,
+                        host: status.host,
+                    });
+                }
+                const group = existing ?? { status, laneIds: new Set() };
+                group.laneIds.add(status.lane_id);
+                grouped.set(key, group);
+            }
+            const missingLane = accountLanes.find((lane) => !seenLaneIds.has(lane.lane_id));
+            if (missingLane) {
+                const message = `account login status is missing for lane ${missingLane.lane_id}`;
+                writeError(`lane watch: ${message}`);
+                throw new LanesError("watch_account_status_invalid", message, {
+                    lane_id: missingLane.lane_id,
+                });
+            }
+            for (const [key, group] of grouped) {
+                const { status } = group;
+                const prior = previousAccountLogin.get(key);
+                if (prior === true && status.logged_in === false) {
+                    emitAccountEvent({
+                        event: "account_logged_out",
+                        provider: status.provider,
+                        account: status.account,
+                        host: status.host,
+                        lane_ids: [...group.laneIds].sort(),
+                    });
+                }
+                if (status.logged_in !== null)
+                    previousAccountLogin.set(key, status.logged_in);
+            }
+        }
+        if (records.every((record) => isTerminalLaneState(record.state) && !keepAliveWaiting.has(record.lane_id))) {
             return { polls, lines, suppressed };
         }
         await sleep(intervalMs);

package/package.json

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