@indigoai-us/hq-cli 5.345.75 → 5.345.77

package/dist/lib/bot/runtime-failure.js

@@ -0,0 +1,180 @@
+/**
+ * What went wrong with a bot's coding tool (Claude Code, Codex, Grok), in a
+ * class a person can act on.
+ *
+ * A failed model turn used to be reported by quoting the runtime's own error
+ * in the DM ("Sorry, I couldn't get started on my own (codex failed: The
+ * 'gpt-6-astra' model requires a newer version of Codex ...)"), and the
+ * fallback copy told the person to check the sign-in even when the cause was
+ * something else. Now every failure is classified here, the person gets one
+ * plain sentence plus one next step, and the raw text goes only to the bot
+ * log. For the four repairable classes the DM also carries a machine-readable
+ * `runtime-repair` block in its `richContent` so the desktop can render a
+ * repair card; the plain body stays the fallback.
+ *
+ * Matching is narrow on purpose: each class has its own known error shapes,
+ * and anything unrecognised is `unknown`, which never blames the sign-in.
+ */
+import { isRuntimeSignInFailure, runtimeDisplayName } from "./runtime-sign-in.js";
+export const RUNTIME_REPAIR_ACTIONS = {
+    "signed-out": "signIn",
+    "cli-outdated": "update",
+    "model-unsupported": "switchModel",
+    transient: "tryAgain",
+};
+export function isRuntimeRepairClass(cls) {
+    return cls in RUNTIME_REPAIR_ACTIONS;
+}
+const NOT_INSTALLED = /\bis not installed or not on PATH\b|\bspawn \S+ ENOENT\b|\bcommand not found\b/i;
+/**
+ * The tool says it is too old for the model. Codex: "The 'gpt-6-astra' model
+ * requires a newer version of Codex. Please upgrade to the latest app or CLI
+ * and try again." Claude Code words it "... requires a newer version of
+ * Claude Code".
+ */
+const VERSION_TOO_OLD = /\brequires a newer version of (?:codex|claude code|grok|the (?:app|cli))\b|\bplease upgrade to the latest (?:app or cli|version of (?:codex|claude code|grok))\b/i;
+/** The failing model id inside a version-too-old message, when it names one. */
+const VERSION_TOO_OLD_MODEL = /\bthe ['"`]([^'"`\s]{1,128})['"`] model requires a newer version of\b/i;
+/**
+ * Claude Code: "There's an issue with the selected model" (its own wording for
+ * a model the account cannot use) and the API's 404 not_found_error whose
+ * message starts "model: <id>". Codex and the OpenAI API: model_not_found,
+ * "does not exist or you do not have access", "not supported when using
+ * Codex with a ChatGPT account".
+ */
+const MODEL_UNSUPPORTED = /there'?s an issue with the selected model|\bnot_found_error\b[^\n]{0,200}\bmodel:\s|\bmodel_not_found\b|\b(?:unknown|invalid|unsupported) model\b|\bthe (?:requested )?model ['"`]?[^'"`\s]{1,128}['"`]? (?:does not exist|is not supported|is not available|was not found|has been deprecated)\b|\bmodel ['"`][^'"`\s]{1,128}['"`] (?:does not exist|is not supported|is not available|not found)\b|\bdo(?:es)? not have access to (?:the )?model\b|\bmodel is not supported when using codex with a chatgpt account\b/i;
+const TRANSIENT = /\brate[_ ]limit|\busage[_ ]limit|\byou've hit your usage limit\b|\btoo many requests\b|\b429\b|\boverloaded\b|\b(?:502|503|504|529)\b|\bservice unavailable\b|\bbad gateway\b|\bgateway time-?out\b|\binternal server error\b|\bECONNRESET\b|\bECONNREFUSED\b|\bETIMEDOUT\b|\bENOTFOUND\b|\bEAI_AGAIN\b|\bENETUNREACH\b|\bsocket hang up\b|\bnetwork (?:error|is unreachable)\b|\bstream (?:disconnected|error)\b|\bconnection (?:reset|refused|closed|error)\b|\btimed out\b|\bexceeded \d+ms \(HQ_BOT_TURN_TIMEOUT_MS\)/i;
+/** Sort a runtime's failure text into one class. Order matters: most specific first. */
+export function classifyRuntimeFailure(text) {
+    const t = (text ?? "").trim();
+    if (!t)
+        return "unknown";
+    if (NOT_INSTALLED.test(t))
+        return "not-installed";
+    if (VERSION_TOO_OLD.test(t))
+        return "cli-outdated";
+    if (isRuntimeSignInFailure(t))
+        return "signed-out";
+    if (MODEL_UNSUPPORTED.test(t))
+        return "model-unsupported";
+    if (TRANSIENT.test(t))
+        return "transient";
+    return "unknown";
+}
+/**
+ * Class of a failed turn's error. A RuntimeError's excerpt (the runtime's own
+ * reported error: failureReason, turn.failed, stderr) is the better evidence;
+ * its message (what HQ saw, e.g. "codex is not installed or not on PATH")
+ * decides when the excerpt says nothing known. An excerpt that is only a tail
+ * of the runtime's ordinary output (`excerptIsOutputTail`) is never read: the
+ * model may have printed "command not found" or a 503 itself.
+ */
+export function classifyRuntimeError(err) {
+    if (err && typeof err === "object" && "stderrExcerpt" in err) {
+        const e = err;
+        const message = typeof e.message === "string" ? e.message : "";
+        if (e.excerptIsOutputTail === true)
+            return classifyRuntimeFailure(message);
+        const fromExcerpt = classifyRuntimeFailure(typeof e.stderrExcerpt === "string" ? e.stderrExcerpt : "");
+        if (fromExcerpt !== "unknown")
+            return fromExcerpt;
+        return classifyRuntimeFailure(message);
+    }
+    return classifyRuntimeFailure(err instanceof Error ? err.message : String(err ?? ""));
+}
+export function isRuntimeVersionTooOld(text) {
+    return VERSION_TOO_OLD.test((text ?? "").trim());
+}
+/** "gpt-6-astra" from "The 'gpt-6-astra' model requires a newer version of Codex ...". */
+export function versionTooOldModel(text) {
+    return VERSION_TOO_OLD_MODEL.exec(text ?? "")?.[1];
+}
+/**
+ * The plain reason, as a sentence fragment without a closing period
+ * ("my Codex app is out of date"). Used in job run dispositions.
+ */
+export function runtimeFailureReason(cls, runtime) {
+    const tool = runtimeDisplayName(runtime);
+    switch (cls) {
+        case "signed-out":
+            return `${tool} needs you to sign in again on this computer`;
+        case "cli-outdated":
+            return `my ${tool} app is out of date`;
+        case "model-unsupported":
+            return `the model I'm set to use isn't available in ${tool} here`;
+        case "transient":
+            return `${tool} is busy or out of reach right now`;
+        case "not-installed":
+            return `${tool} isn't installed on this computer`;
+        default:
+            return `${tool} stopped with an error`;
+    }
+}
+/** The one next step, as a full sentence. */
+export function runtimeFailureNextStep(cls, runtime, context = "message") {
+    const tool = runtimeDisplayName(runtime);
+    switch (cls) {
+        case "signed-out":
+            return `Use "Sign in to ${tool}" in HQ, then send me any message.`;
+        case "cli-outdated":
+            return `Update ${tool}, then send me any message.`;
+        case "model-unsupported":
+            return `Choose a different model in my settings, then send me any message.`;
+        case "transient":
+            return context === "kickoff"
+                ? `Send me any message in a few minutes and I'll get started.`
+                : `Send your message again in a few minutes.`;
+        case "not-installed":
+            return `Install ${tool} from HQ, then send me any message.`;
+        default:
+            return context === "kickoff"
+                ? `Send me any message and I'll try again. If it keeps happening, restart me from HQ.`
+                : `Send your message again. If it keeps happening, restart me from HQ.`;
+    }
+}
+function capitalize(s) {
+    return s ? s[0].toUpperCase() + s.slice(1) : s;
+}
+/** "My Codex app is out of date. Update Codex, then send me any message." */
+export function runtimeFailureText(cls, runtime, context = "message") {
+    return `${capitalize(runtimeFailureReason(cls, runtime))}. ${runtimeFailureNextStep(cls, runtime, context)}`;
+}
+/** A failure after the model started (and maybe posted part of the answer). */
+export function runtimeDidNotFinishText(cls, runtime, progressPosted) {
+    return `I didn't finish that. ${runtimeFailureText(cls, runtime)}${progressPosted ? " The messages above show how far I got." : ""}`;
+}
+export function runtimeRepairBlock(args) {
+    return {
+        v: 1,
+        kind: "runtime-repair",
+        class: args.cls,
+        runtime: args.runtime,
+        action: RUNTIME_REPAIR_ACTIONS[args.cls],
+        botName: args.botName,
+        ...(args.retryOf ? { retryOf: args.retryOf } : {}),
+        ...(args.suggestedModel ? { suggestedModel: args.suggestedModel.slice(0, 128) } : {}),
+    };
+}
+/** The plain body plus, for a repairable class, the repair block. */
+export function runtimeRepairNotice(args) {
+    const text = args.text ?? runtimeFailureText(args.cls, args.runtime, args.context);
+    if (!isRuntimeRepairClass(args.cls))
+        return { cls: args.cls, text };
+    return {
+        cls: args.cls,
+        text,
+        richContent: {
+            v: 1,
+            blocks: [
+                runtimeRepairBlock({
+                    cls: args.cls,
+                    runtime: args.runtime,
+                    botName: args.botName,
+                    ...(args.retryOf ? { retryOf: args.retryOf } : {}),
+                    ...(args.suggestedModel ? { suggestedModel: args.suggestedModel } : {}),
+                }),
+            ],
+        },
+    };
+}
+//# sourceMappingURL=runtime-failure.js.map

package/dist/lib/bot/runtime-sign-in.js

@@ -10,7 +10,7 @@
  */
 /** Time between the bot's own retries while its sign-in is broken. */
 export const SIGN_IN_RETRY_MS = 60_000;
-const SIGN_IN_FAILURE = /failed to authenticate|authentication[_ ]failed|not logged in|not signed in|please (?:run \/login|log ?in|sign ?in)|(?:oauth|access|refresh) token (?:has been |was )?(?:expired|revoked|invalid)|oauth session expired|invalid api key|\b401\b|unauthori[sz]ed|login (?:required|expired)|sign-?in (?:required|expired)/i;
+const SIGN_IN_FAILURE = /failed to authenticate|authentication[_ ]failed|not logged in|not signed in|please (?:run \/login|log ?in|sign ?in)|(?:oauth|access|refresh) token (?:has been |has |was )?(?:expired|revoked|invalid)|oauth session expired|invalid api key|\b401\b|unauthori[sz]ed|login (?:required|expired)|sign-?in (?:required|expired)/i;
 /** Usage and rate limits are a different problem; a new sign-in does not fix them. */
 const NOT_SIGN_IN = /usage[_ ]limit|rate[_ ]limit|quota|too many requests|credits/i;
 export function isRuntimeSignInFailure(text) {
@@ -26,6 +26,6 @@ export function runtimeDisplayName(runtime) {
 export function signInNeededText(runtime, kickoff = false) {
     const tool = runtimeDisplayName(runtime);
     return (`I can't work right now: ${tool} needs you to sign in again on this computer. ` +
-        `Use "Sign in to ${tool}" in HQ, and I'll ${kickoff ? "get started" : "answer this"} as soon as it works again — no need to send it twice.`);
+        `Use "Sign in to ${tool}" in HQ, and I'll ${kickoff ? "get started" : "answer this"} as soon as it works again. No need to send it twice.`);
 }
 //# sourceMappingURL=runtime-sign-in.js.map

package/dist/lib/bot/status.d.ts

@@ -44,6 +44,27 @@ export interface BotStatusFile {
      * reason); cleared by the next turn that works. `null` = known to work.
      */
     runtimeSignIn?: RuntimeSignInIssue | null;
+    /**
+     * Set when the installed coding tool is too old for the model it was asked
+     * to use and the last turn ran on `to` instead (`from` is "" when the model
+     * came from the tool's own config). `null` once a turn runs on the model it
+     * was asked for again. Updating the tool clears it.
+     */
+    runtimeModelFallback?: {
+        from: string;
+        to: string;
+        at: string;
+    } | null;
+    /**
+     * Set while the bot holds its model turns after FAILURE_LIMIT failures in a
+     * window (it used to exit instead, and a bot that exited could neither load
+     * an updated hq-cli nor answer the next message). `null` once the hold is
+     * over; the next message then runs a fresh turn.
+     */
+    modelHold?: {
+        until: string;
+        reason: string;
+    } | null;
     /** hq-cli version this process loaded (a bot keeps it until it restarts). */
     cliVersion?: string;
     updatedAt: string;

package/dist/lib/index-render/companies.js

@@ -1,26 +1,35 @@
 import * as fs from "fs";
 import * as path from "path";
-import { basename, countImmediate, date, exists, immediateEntries, isHidden, log, projectStatus, readJson, sanitize, titleize, truncate, write } from "./shared.js";
+import { basename, countImmediate, exists, immediateEntries, isHidden, log, prdProjectStatus, readJson, sanitize, titleize, truncate, writeIfChanged } from "./shared.js";
 export class CompanyIndexUserError extends Error {
     constructor(message) {
         super(message);
         this.name = "CompanyIndexUserError";
     }
 }
+/**
+ * One-line summary for a top-level company directory.
+ *
+ * Output must be identical on every machine that holds the same synced tree,
+ * because company INDEX.md files are synced. So nothing here reads local-only
+ * state: `repos/` (never synced), `data/` (partly synced), whether
+ * `knowledge/` is an embedded git checkout, or symlink targets. Counts use
+ * lstat so a symlinked child is never counted as a directory or file.
+ */
 function description(root, company, name) {
     const base = `companies/${company}/${name}`;
-    const nonHidden = (child) => !isHidden(child);
+    const realDirectory = (n, f) => !isHidden(n) && fs.lstatSync(f).isDirectory();
     switch (name) {
-        case "data": return `${countImmediate(root, base, nonHidden)} item(s)`;
-        case "knowledge": return exists(root, `${base}/.git`) ? "Embedded git repo" : `Inline knowledge (${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} subdirs)`;
-        case "settings": return `${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} integration(s)`;
+        case "data": return "Company data";
+        case "knowledge": return `Company knowledge (${countImmediate(root, base, realDirectory)} subdirs)`;
+        case "settings": return `${countImmediate(root, base, realDirectory)} integration(s)`;
         case "policies": return `${countImmediate(root, base, (n) => n.endsWith(".md"))} policy file(s)`;
         // Match `find -type d`: count actual directories, not symlinks to directories.
-        case "projects": return `${countImmediate(root, base, (n, f) => !n.startsWith("_") && !isHidden(n) && fs.lstatSync(f).isDirectory())} project(s)`;
-        case "workers": return `${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} worker(s)`;
-        case "repos": return `${countImmediate(root, base, (n, f) => { const s = fs.lstatSync(f); return !isHidden(n) && (s.isDirectory() || s.isSymbolicLink()); })} repo link(s)`;
+        case "projects": return `${countImmediate(root, base, (n, f) => !n.startsWith("_") && realDirectory(n, f))} project(s)`;
+        case "workers": return `${countImmediate(root, base, realDirectory)} worker(s)`;
+        case "repos": return "Local repo links (not synced)";
         case "registry": return `Resource registry (${countImmediate(root, `${base}/resources`, (n) => n.endsWith(".yaml"))} resource(s))`;
-        case "scripts": return `${countImmediate(root, base, (_n, f) => fs.statSync(f).isFile())} script(s)`;
+        case "scripts": return `${countImmediate(root, base, (_n, f) => fs.lstatSync(f).isFile())} script(s)`;
         default: return "—";
     }
 }
@@ -56,6 +65,7 @@ export function renderCompanies(context, args = []) {
         }
     }
     const written = [];
+    const unchanged = [];
     let scopedDirectories;
     if (selectedCompany === undefined) {
         scopedDirectories = immediateEntries(context.root, "companies", "dir");
@@ -87,7 +97,9 @@ export function renderCompanies(context, args = []) {
         const company = basename(directory);
         if (company.startsWith("_") || isHidden(company))
             continue;
-        const lines = [`# ${titleize(company)}`, "", `> Auto-generated. Updated: ${date(context.now)}`, "", "| Name | Description |", "|------|-------------|"];
+        // No date line: the file must only change when its content changes. The
+        // `> Auto-generated.` marker stays, since hq-cloud detects generated INDEX.md by it.
+        const lines = [`# ${titleize(company)}`, "", "> Auto-generated.", "", "| Name | Description |", "|------|-------------|"];
         for (const name of ["data", "knowledge", "policies", "projects", "registry", "repos", "scripts", "settings", "workers"]) {
             if (exists(context.root, `companies/${company}/${name}`))
                 lines.push(`| \`${name}/\` | ${sanitize(description(context.root, company, name))} |`);
@@ -104,18 +116,23 @@ export function renderCompanies(context, args = []) {
                 const parsed = readJson(prd);
                 let text = typeof parsed?.description === "string" ? parsed.description : "";
                 text = truncate(sanitize(text), 110) || "—";
-                lines.push(`| \`${project}\` | ${projectStatus(context.root, project, prd, "active", prd)} | ${text} |`);
+                lines.push(`| \`${project}\` | ${prdProjectStatus(prd, "active")} | ${text} |`);
             }
         }
         else
             lines.push("_No projects directory._");
         lines.push("", "## Deployments", "", "_See `companies/manifest.yaml` for deployment targets._", "");
         const output = `companies/${company}/INDEX.md`;
-        write(context, output, lines.join("\n"));
-        written.push(output);
-        log(context, `rebuild-companies-index: wrote ${output}`);
+        if (writeIfChanged(context, output, lines.join("\n"))) {
+            written.push(output);
+            log(context, `rebuild-companies-index: wrote ${output}`);
+        }
+        else {
+            unchanged.push(output);
+            log(context, `rebuild-companies-index: unchanged ${output}`);
+        }
     }
-    log(context, `rebuild-companies-index: regenerated ${written.length} company INDEX.md file(s)`);
-    return { written };
+    log(context, `rebuild-companies-index: regenerated ${written.length + unchanged.length} company INDEX.md file(s)`);
+    return { written, unchanged };
 }
 //# sourceMappingURL=companies.js.map

package/dist/lib/index-render/shared.d.ts

@@ -10,6 +10,8 @@ export type RenderContext = {
 };
 export type RenderResult = {
     written: string[];
+    /** Relative paths whose rendered content matched the file on disk, so no write happened. */
+    unchanged?: string[];
 };
 export declare function rel(root: string, file: string): string;
 export declare function at(root: string, relative: string): string;
@@ -32,6 +34,15 @@ export declare function atomicWrite(file: string, content: string | Buffer, opti
     mode?: number;
 }): void;
 export declare function write(context: RenderContext, relative: string, content: string): string;
+/**
+ * Write only when the rendered bytes differ from the file on disk. Returns
+ * true when the file was written, false when it was already identical.
+ *
+ * The comparison is exact rather than `generatedFingerprint`: that fingerprint
+ * drops keep fences and trailing newlines, which would hide real differences.
+ * Callers that want a skip must render deterministic content (no dates).
+ */
+export declare function writeIfChanged(context: RenderContext, relative: string, content: string): boolean;
 /** Drop keep fences, the generated stamp, and the rolling date so two generated bodies can be compared. */
 export declare function generatedFingerprint(content: string): string;
 /** Insert a content stamp after the Auto-generated line. Idempotent. */
@@ -42,6 +53,13 @@ export declare function looksAutoGenerated(content: string): boolean;
 export declare function generatedStamp(content: string): string | undefined;
 export declare function log(context: RenderContext, message: string): void;
 export declare function projectStatus(root: string, project: string, prdPath: string, fallback: string, expectedStatePrdPath?: string): string;
+/**
+ * Project status from prd.json alone: "complete" when every story passes,
+ * otherwise `fallback`. Unlike `projectStatus`, this never reads the
+ * machine-local `workspace/orchestrator/<project>/state.json`, so synced
+ * output renders the same on every machine.
+ */
+export declare function prdProjectStatus(prdPath: string, fallback: string): string;
 export declare function basename(file: string): string;
 export declare function isHidden(name: string): boolean;
 export declare function mtime(file: string): number;

package/dist/lib/index-render/shared.js

@@ -100,6 +100,21 @@ export function write(context, relative, content) {
     atomicWrite(at(context.root, relative), content);
     return relative;
 }
+/**
+ * Write only when the rendered bytes differ from the file on disk. Returns
+ * true when the file was written, false when it was already identical.
+ *
+ * The comparison is exact rather than `generatedFingerprint`: that fingerprint
+ * drops keep fences and trailing newlines, which would hide real differences.
+ * Callers that want a skip must render deterministic content (no dates).
+ */
+export function writeIfChanged(context, relative, content) {
+    const file = at(context.root, relative);
+    if (readText(file) === content)
+        return false;
+    atomicWrite(file, content);
+    return true;
+}
 const GENERATED_DATE_LINE = /^> Auto-generated\. Updated: \d{4}-\d{2}-\d{2}$/m;
 const GENERATED_STAMP_LINE = /^<!-- hq-generated-sha256: [a-f0-9]{64} -->\n?/m;
 function keepFencePattern() {
@@ -149,6 +164,15 @@ export function projectStatus(root, project, prdPath, fallback, expectedStatePrd
             return "active";
         return raw;
     }
+    return prdProjectStatus(prdPath, fallback);
+}
+/**
+ * Project status from prd.json alone: "complete" when every story passes,
+ * otherwise `fallback`. Unlike `projectStatus`, this never reads the
+ * machine-local `workspace/orchestrator/<project>/state.json`, so synced
+ * output renders the same on every machine.
+ */
+export function prdProjectStatus(prdPath, fallback) {
     const prd = readJson(prdPath);
     if (prd && Array.isArray(prd.userStories) && prd.userStories.length > 0 && prd.userStories.every((story) => Boolean(story.passes)))
         return "complete";

package/dist/lib/lanes/monitor.js

@@ -347,26 +347,41 @@ function defaultProcessCommands() {
         return [];
     }
 }
+const WATCH_RUNTIME_EXECUTABLES = ["bun", "deno", "node", "nodejs", "ts-node", "tsx"];
+// The hq executable path may contain spaces (the desktop toolchain installs
+// under "~/Library/Application Support/Indigo HQ/..."), so the ps line cannot
+// be split on whitespace to find it. Match the fixed "lanes watch <ids>" suffix
+// on the raw line, then validate whatever precedes it as an hq invocation.
+// A path form (absolute or ./, ../) is required so an unrelated leading
+// command such as "vim /tmp/hq" is not absorbed into the path.
+function isHqExecutablePath(candidate) {
+    if (candidate === "hq")
+        return true;
+    if (!/^\.{0,2}\//u.test(candidate) || path.basename(candidate) !== "hq") {
+        return false;
+    }
+    return !candidate.split(" ").some((piece) => piece.startsWith("-"));
+}
+function isHqInvocationPrefix(prefix) {
+    if (isHqExecutablePath(prefix))
+        return true;
+    const runtimeEnd = prefix.indexOf(" ");
+    if (runtimeEnd === -1)
+        return false;
+    const runtime = path.basename(prefix.slice(0, runtimeEnd));
+    return (WATCH_RUNTIME_EXECUTABLES.includes(runtime) &&
+        isHqExecutablePath(prefix.slice(runtimeEnd + 1)));
+}
 function processHasExactCommand(processCommands, command) {
     const laneIds = parseCanonicalWatchCommand(command);
     if (!laneIds)
         return false;
-    const expectedSuffix = ["lanes", "watch", ...laneIds];
-    return processCommands.some((line) => {
-        const tokens = line.trim().split(/\s+/u);
-        const suffixStart = tokens.length - expectedSuffix.length;
-        if (suffixStart < 1)
-            return false;
-        if (!expectedSuffix.every((token, index) => tokens[suffixStart + index] === token)) {
-            return false;
-        }
-        const hqToken = tokens[suffixStart - 1];
-        if (path.basename(hqToken) !== "hq")
+    const expectedSuffix = ` lanes watch ${laneIds.join(" ")}`;
+    return processCommands.some((rawLine) => {
+        const line = rawLine.trim().replace(/\s+/gu, " ");
+        if (!line.endsWith(expectedSuffix))
             return false;
-        const prefix = tokens.slice(0, suffixStart - 1);
-        return (prefix.length === 0 ||
-            (prefix.length === 1 &&
-                ["bun", "deno", "node", "nodejs", "ts-node", "tsx"].includes(path.basename(prefix[0]))));
+        return isHqInvocationPrefix(line.slice(0, -expectedSuffix.length));
     });
 }
 export function readLiveMonitorEvidence(sessionId, options = {}) {

package/package.json

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