@indigoai-us/hq-cli 5.95.0 → 5.97.0

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## [Unreleased]
 
+## [5.97.0]
+
+### Added
+
+- `hq reindex` now keeps files over GitHub's 100MB limit out of the HQ repo.
+  The HQ root is a git repo that `git add -A` sweeps wholesale after every
+  sync, and session logs and package stores routinely pass that limit — once
+  such a blob is committed, every later push is rejected with GH001
+  permanently, because the blob is in history. Oversized files now gain an
+  anchored `.gitignore` rule, and any already in the index are dropped with
+  `git rm --cached`, which leaves the working-tree file untouched. Every
+  affected path is named on stdout, since untracking mutates the user's index
+  and must never be silent. The scan runs through git rather than the
+  filesystem, so nested checkouts under `repos/` are excluded automatically,
+  and it is throttled to once an hour per root so the hook-driven reindex path
+  stays cheap. (#346)
+
+## [5.96.0]
+
+### Changed
+
+- The CLI now updates itself instead of nagging. When a newer version is
+  available, an ordinary command quietly installs it and re-runs on the new
+  version rather than printing "a new version is available" on every
+  invocation; the warning now appears only if the update itself fails, along
+  with the exact command to run by hand. hq-pro's soft "update recommended"
+  signal is handled the same way. Updates are serialized across concurrent
+  `hq` processes with a lock so a busy multi-agent box can't race
+  `npm install -g` into a broken partial install, and the package manager's
+  output is captured so it never corrupts a `--json` command's stdout. (#344)
+
+### Fixed
+
+- `hq rescue` now brings the CLI itself up to the latest version (and re-runs
+  the rescue on it) before touching the HQ core. The rescue logic ships inside
+  the CLI, so an out-of-date CLI was running an out-of-date rescue. Skipped for
+  `--check` dry-runs and behind a new `--no-self-update` flag; best-effort, so
+  any update failure falls back to rescuing on the current version. (#344)
+
+All self-update behavior honors the existing `HQ_NO_UPDATE_CHECK=1` opt-out.
+
 ## [5.94.3]
 
 ### Fixed

package/dist/commands/reindex.js

@@ -30,6 +30,7 @@ import * as yaml from 'js-yaml';
 import { reindex, rescue } from '@indigoai-us/hq-cloud';
 import { trustHqRuntimeHooks } from '../utils/hook-trust.js';
 import { findHqRoot } from '../utils/manifest.js';
+import { guardLargeFiles } from '../utils/large-file-guard.js';
 const HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse'];
 const HOOK_CHECK_RELATIVE_PATH = path.join('core', 'scripts', 'check-hq-hooks.sh');
 /** Resolve the same root the repair/check commands must operate on. */
@@ -205,6 +206,25 @@ export function repairExtremeHookDrift(hqRoot, allowRepair = true) {
         printHookHealthWarning(hqRoot, 'hook configuration repair could not run');
     }
 }
+/**
+ * Keep files above GitHub's 100MB limit out of the HQ repo, and say so.
+ *
+ * Untracking is a mutation of the user's index, so it is never silent: every
+ * affected path is named on stdout. Throttled internally to one scan per hour
+ * per root, so the hook-driven reindex path stays cheap.
+ */
+function reportLargeFileGuard(hqRoot) {
+    const { scanned, ignored, untracked } = guardLargeFiles(hqRoot);
+    if (!scanned)
+        return;
+    const removed = new Set(untracked);
+    for (const file of untracked) {
+        console.log(`reindex: ${file} exceeds GitHub's 100MB limit — removed from git tracking and ignored (the file itself is untouched)`);
+    }
+    for (const file of ignored.filter((f) => !removed.has(f))) {
+        console.log(`reindex: ${file} exceeds GitHub's 100MB limit — added to .gitignore`);
+    }
+}
 export function registerReindexCommand(program) {
     program
         .command('reindex')
@@ -239,6 +259,9 @@ export function registerReindexCommand(program) {
         repairExtremeHookDrift(hqRoot, status === 0);
         if (status === 0)
             await trustHqRuntimeHooks(hqRoot);
+        // Runs even when reindex failed: a failed reindex does not make an
+        // oversized blob any less likely to wedge the next push.
+        reportLargeFileGuard(hqRoot);
         process.exit(status);
     });
 }

package/dist/commands/rescue.d.ts

@@ -12,6 +12,12 @@
  * installed version (read from core/core.yaml). Staging (`--staging`): targets
  * `indigoai-us/hq-core-staging@main` and lets the script read its on-disk
  * sync stamp for the floor.
+ *
+ * Before touching the HQ root, rescue also self-updates hq-cli itself to npm
+ * latest and re-execs (`selfUpdateAndReexec`) so the bundled rescue script is
+ * current too — see utils/self-update.ts. Skipped for `--check` (a dry-run
+ * must not mutate the global install), `--no-self-update`, and
+ * `HQ_NO_UPDATE_CHECK=1`; always best-effort.
  */
 import { Command } from 'commander';
 export interface RescueTarget {
@@ -29,5 +35,15 @@ export declare function resolveRescueTarget(opts: {
     source?: string;
     ref?: string;
 }, latestTag?: string): RescueTarget;
+/**
+ * Whether this invocation should try the CLI self-update. Pure + exported for
+ * tests. A dry-run (`--check`) must not mutate the global install, and
+ * commander maps `--no-self-update` to `selfUpdate: false`. Env-based opt-outs
+ * (HQ_NO_UPDATE_CHECK, the re-exec guard) live inside selfUpdateAndReexec.
+ */
+export declare function shouldAttemptSelfUpdate(opts: {
+    check?: boolean;
+    selfUpdate?: boolean;
+}): boolean;
 export declare function registerRescueCommand(program: Command): void;
 //# sourceMappingURL=rescue.d.ts.map

package/dist/commands/rescue.js

@@ -5,6 +5,7 @@ import * as yaml from 'js-yaml';
 import chalk from 'chalk';
 import { rescue } from '@indigoai-us/hq-cloud';
 import { findHqRoot } from '../utils/manifest.js';
+import { selfUpdateAndReexec } from '../utils/self-update.js';
 const PROD_SOURCE = 'indigoai-us/hq-core';
 const STAGING_SOURCE = 'indigoai-us/hq-core-staging';
 /**
@@ -18,6 +19,15 @@ export function resolveRescueTarget(opts, latestTag) {
     }
     return { source: opts.source ?? PROD_SOURCE, ref: opts.ref ?? latestTag };
 }
+/**
+ * Whether this invocation should try the CLI self-update. Pure + exported for
+ * tests. A dry-run (`--check`) must not mutate the global install, and
+ * commander maps `--no-self-update` to `selfUpdate: false`. Env-based opt-outs
+ * (HQ_NO_UPDATE_CHECK, the re-exec guard) live inside selfUpdateAndReexec.
+ */
+export function shouldAttemptSelfUpdate(opts) {
+    return opts.selfUpdate !== false && !opts.check;
+}
 /** Resolve a GitHub token: prefer `gh auth token`, fall back to env. */
 function resolveGhToken() {
     try {
@@ -105,9 +115,20 @@ export function registerRescueCommand(program) {
         .option('--check', 'Plan only — classify and report, change nothing on disk (--dry-run)')
         .option('-y, --yes', 'Skip the confirmation prompt')
         .option('--no-backup', 'Skip the pre-op safety snapshot under ~/.hq/backups')
+        .option('--no-self-update', 'Skip updating hq-cli itself to the latest version first')
         .option('--cloud-update', 'Cloud-update mode')
         .action(async (opts) => {
         try {
+            // Bring the CLI itself to latest first: the rescue script is bundled
+            // with this install, so an outdated CLI would run an outdated rescue.
+            // On a successful update the rescue re-runs on the new version and we
+            // exit with its status; on any failure we continue on this version.
+            if (shouldAttemptSelfUpdate(opts)) {
+                const outcome = await selfUpdateAndReexec(process.argv);
+                if (outcome.action === 'reexec') {
+                    process.exit(outcome.reexecStatus ?? 0);
+                }
+            }
             const hqRoot = opts.hqRoot ?? findHqRoot();
             const token = resolveGhToken();
             let { source, ref } = resolveRescueTarget(opts);

package/dist/main.js

@@ -67,8 +67,9 @@ import { isEpipe } from "./utils/epipe.js";
 import { isInterceptedProcessExit } from "./utils/intercepted-process-exit.js";
 import { isAuthError } from "./utils/auth-error.js";
 import { isCompanySelectionError } from "./utils/company-selection-error.js";
-import { maybeWarnNewVersion, refreshVersionCache, } from "./utils/version-check.js";
+import { refreshVersionCache, staleAgainstCachedLatest, } from "./utils/version-check.js";
 import { enforceVersionGate, shouldSkipGate, } from "./utils/version-gate.js";
+import { autoUpdateAndReexec } from "./utils/self-update.js";
 import { CLI_VERSION } from "./cli-version.js";
 import { emitCliSessionStarted } from "./utils/cli-telemetry.js";
 import { settleWithin } from "./utils/settle-with-timeout.js";
@@ -91,7 +92,6 @@ const onPipeError = (err) => {
 process.stdout.on("error", onPipeError);
 process.stderr.on("error", onPipeError);
 initSentry();
-maybeWarnNewVersion();
 const program = new Command();
 program
     .name("hq")
@@ -239,19 +239,46 @@ program.hook("preAction", async () => {
     await emitCliSessionStarted();
 });
 export async function runCli() {
+    // Set when a self-update re-exec'd this command on a newer CLI: the child
+    // already did the work, so this process only has to carry its exit status
+    // out (after the finally block's telemetry, hence not process.exit here).
+    let reexecStatus = null;
     try {
         Sentry.addBreadcrumb({
             category: "command",
             message: sanitizeArgv(process.argv.slice(2)).join(" "),
             level: "info",
         });
-        // Hard version gate: ask hq-pro whether this CLI is below the floor and
-        // auto-update if so (exits the process on update). Skipped for inspection
-        // flags (`--version`, `--help`) so users debugging a broken install can
-        // still introspect what they have. Silent on any failure — never blocks
-        // the CLI on a flaky network or hq-pro hiccup. See `utils/version-gate.ts`.
+        // Version handling, both halves. Skipped for inspection flags
+        // (`--version`, `--help`) so users debugging a broken install can still
+        // introspect what they have, and silent on any failure — neither half may
+        // block the CLI on a flaky network or an hq-pro hiccup.
+        //
+        // 1. Hard gate: hq-pro says this version is below the enforced floor →
+        //    update and exit (the user reruns). See `utils/version-gate.ts`.
+        // 2. Soft: we're merely behind npm `latest` → update in place and re-run
+        //    this exact command on the new version, so the user never sees the
+        //    old "a new version is available" nag. Two independent signals feed
+        //    it (hq-pro's `updateRecommended` and the cached npm latest from
+        //    `version-check.ts`); whichever fires first re-execs, and the child
+        //    carries a guard env so it can never update again.
         if (!shouldSkipGate(process.argv)) {
-            await enforceVersionGate();
+            const gate = await enforceVersionGate(async (decision) => {
+                const outcome = await autoUpdateAndReexec(process.argv, decision.latestVersion);
+                if (outcome.action === "reexec")
+                    reexecStatus = outcome.reexecStatus ?? 0;
+                return outcome.action === "reexec";
+            });
+            if (gate === "reexec")
+                return;
+            const cachedLatest = staleAgainstCachedLatest();
+            if (cachedLatest) {
+                const outcome = await autoUpdateAndReexec(process.argv, cachedLatest);
+                if (outcome.action === "reexec") {
+                    reexecStatus = outcome.reexecStatus ?? 0;
+                    return;
+                }
+            }
         }
         await program.parseAsync();
     }
@@ -269,6 +296,10 @@ export async function runCli() {
         // command has completed, so a bounded best-effort wait is the terminal
         // lifecycle boundary for this invocation.
         await settleWithin([refreshVersionCache(), Sentry.flush(2000)], RELEASE_HEALTH_SETTLE_TIMEOUT_MS);
+        // Last, so it wins over anything the (skipped) command path would have
+        // set: the re-exec'd child's status IS this invocation's result.
+        if (reexecStatus !== null)
+            process.exitCode = reexecStatus;
     }
 }
 const defaultTopLevelErrorDependencies = {

package/dist/utils/large-file-guard.d.ts

@@ -0,0 +1,39 @@
+/** GitHub rejects any single file above this size. */
+export declare const DEFAULT_THRESHOLD_BYTES: number;
+/** At most one scan per hour per root. */
+export declare const SCAN_THROTTLE_MS: number;
+export interface LargeFileGuardResult {
+    /** False when the root is not a git repo, or the scan was throttled. */
+    scanned: boolean;
+    /** Repo-relative paths newly added to `.gitignore`. */
+    ignored: string[];
+    /** Repo-relative paths removed from the index (still on disk). */
+    untracked: string[];
+}
+export interface LargeFileGuardOptions {
+    /** Defaults to {@link DEFAULT_THRESHOLD_BYTES}. */
+    thresholdBytes?: number;
+    /** Injectable clock, in epoch milliseconds. */
+    now?: number;
+    /** Bypass the throttle. */
+    force?: boolean;
+}
+/**
+ * Render a repo-relative path as a literal `.gitignore` pattern.
+ *
+ * The leading slash anchors it to the repo root — without it a bare filename
+ * would also ignore same-named files in every subdirectory. Glob and
+ * character-class metacharacters are escaped so the rule matches the one real
+ * path and nothing else, and a trailing space is escaped because git strips
+ * unescaped ones.
+ */
+export declare function toGitignorePattern(relPath: string): string;
+/**
+ * Scan `hqRoot` for files above the size limit, ignore them, and drop any that
+ * are already in the index.
+ *
+ * Never throws: every failure path degrades to "did nothing", because a guard
+ * that can take `hq reindex` down is worse than the problem it prevents.
+ */
+export declare function guardLargeFiles(hqRoot: string, options?: LargeFileGuardOptions): LargeFileGuardResult;
+//# sourceMappingURL=large-file-guard.d.ts.map

package/dist/utils/large-file-guard.js

@@ -0,0 +1,249 @@
+/**
+ * Large-file guard — keep blobs over GitHub's hard limit out of the HQ repo.
+ *
+ * HQ's root is a git repo that `git add -A` sweeps wholesale (the desktop app's
+ * git-mirror does exactly that after every sync). Session logs and package
+ * stores routinely blow past GitHub's 100 MB per-file limit, and once such a
+ * blob is committed every subsequent push is rejected with GH001 — permanently,
+ * since the blob is in history. Recovering means rewriting history.
+ *
+ * This guard runs from `hq reindex` and closes the door before that happens:
+ *   - oversized files gain a `.gitignore` rule, so `git add -A` skips them;
+ *   - oversized files already in the index are dropped from it with
+ *     `git rm --cached`, which leaves the working-tree file untouched.
+ *
+ * Design constraints that shaped this:
+ *
+ * - **Git-aware, not filesystem-aware.** A naive `find -size +100M` over an HQ
+ *   root takes ~37s and surfaces files inside nested checkouts under `repos/`,
+ *   which the outer repo does not own. Driving everything through git costs
+ *   ~13s and gets nested-repo boundaries right for free.
+ * - **Index, not HEAD.** `git rm --cached` mutates the index and leaves HEAD
+ *   alone until the next commit, so enumerating HEAD would re-report the same
+ *   file on every run.
+ * - **Throttled.** `hq reindex` also fires from a PostToolUse hook shim on
+ *   skill/worker/policy edits. A stamp file in the git dir bounds the scan to
+ *   once an hour so a policy-editing session doesn't pay the cost repeatedly.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** GitHub rejects any single file above this size. */
+export const DEFAULT_THRESHOLD_BYTES = 100 * 1024 * 1024;
+/** At most one scan per hour per root. */
+export const SCAN_THROTTLE_MS = 60 * 60 * 1000;
+/** Lives in the git dir, so it is never committed, synced, or seen by status. */
+const STAMP_BASENAME = "hq-large-file-scan.stamp";
+const GITIGNORE_HEADER = "# hq reindex: files over GitHub's 100MB limit (added automatically)";
+/**
+ * git output for a fully-populated HQ root runs to tens of megabytes
+ * (~450k tracked paths). The Node default of 1 MiB would truncate it.
+ */
+const MAX_GIT_BUFFER = 512 * 1024 * 1024;
+const SKIPPED = Object.freeze({
+    scanned: false,
+    ignored: [],
+    untracked: [],
+});
+function git(cwd, args, input) {
+    try {
+        const out = spawnSync("git", args, {
+            cwd,
+            input,
+            encoding: "utf8",
+            maxBuffer: MAX_GIT_BUFFER,
+        });
+        if (out.error || out.status !== 0)
+            return { ok: false, stdout: "" };
+        return { ok: true, stdout: out.stdout ?? "" };
+    }
+    catch {
+        // A missing cwd or an absent git binary must degrade to "guard did
+        // nothing", never take reindex down with it.
+        return { ok: false, stdout: "" };
+    }
+}
+/** Absolute path to the repo's git dir, or undefined when cwd is not a repo. */
+function resolveGitDir(hqRoot) {
+    if (!fs.existsSync(hqRoot))
+        return undefined;
+    const out = git(hqRoot, ["rev-parse", "--git-dir"]);
+    if (!out.ok)
+        return undefined;
+    const raw = out.stdout.trim();
+    if (!raw)
+        return undefined;
+    return path.isAbsolute(raw) ? raw : path.resolve(hqRoot, raw);
+}
+function isThrottled(stampPath, now) {
+    try {
+        const last = Number(fs.readFileSync(stampPath, "utf8").trim());
+        if (!Number.isFinite(last))
+            return false;
+        return now - last < SCAN_THROTTLE_MS;
+    }
+    catch {
+        return false; // no stamp yet, or unreadable — scan.
+    }
+}
+function writeStamp(stampPath, now) {
+    try {
+        fs.writeFileSync(stampPath, `${now}\n`);
+    }
+    catch {
+        // Losing the stamp only costs an extra scan next time.
+    }
+}
+/** Split a NUL-delimited git record stream, dropping the trailing empty field. */
+function splitNul(raw) {
+    return raw.split("\0").filter((entry) => entry.length > 0);
+}
+/**
+ * Oversized blobs in the *index*.
+ *
+ * `git ls-files -s` yields `<mode> <object> <stage>\t<path>`; the object ids are
+ * piped through `cat-file --batch-check` so sizes come from the object database
+ * rather than ~450k filesystem stats.
+ */
+function oversizedInIndex(hqRoot, threshold) {
+    const listed = git(hqRoot, ["ls-files", "-s", "-z"]);
+    if (!listed.ok)
+        return [];
+    const entries = [];
+    for (const record of splitNul(listed.stdout)) {
+        const tab = record.indexOf("\t");
+        if (tab === -1)
+            continue;
+        const fields = record.slice(0, tab).split(" ");
+        if (fields.length < 2)
+            continue;
+        entries.push({ oid: fields[1], file: record.slice(tab + 1) });
+    }
+    if (entries.length === 0)
+        return [];
+    const sizes = git(hqRoot, ["cat-file", "--batch-check=%(objectsize)"], `${entries.map((e) => e.oid).join("\n")}\n`);
+    if (!sizes.ok)
+        return [];
+    // One output line per input line, in order.
+    const lines = sizes.stdout.split("\n");
+    const oversized = [];
+    for (let i = 0; i < entries.length; i += 1) {
+        const size = Number(lines[i]);
+        if (Number.isFinite(size) && size > threshold)
+            oversized.push(entries[i].file);
+    }
+    return oversized;
+}
+/**
+ * Oversized files git would pick up on the next `add -A` — untracked or
+ * modified. `git status` already honours `.gitignore` and stops at nested
+ * repository boundaries, so neither needs handling here.
+ */
+function oversizedInWorktree(hqRoot, threshold) {
+    const status = git(hqRoot, ["status", "--porcelain", "-z", "--untracked-files=all"]);
+    if (!status.ok)
+        return [];
+    const records = splitNul(status.stdout);
+    const oversized = [];
+    for (let i = 0; i < records.length; i += 1) {
+        const record = records[i];
+        if (record.length < 4)
+            continue;
+        const code = record.slice(0, 2);
+        const file = record.slice(3);
+        // Renames and copies emit the source path as a second record; consume it
+        // so it is not parsed as a status line of its own.
+        if (code.startsWith("R") || code.startsWith("C"))
+            i += 1;
+        if (code.includes("D"))
+            continue; // going away — nothing to guard
+        try {
+            const stat = fs.statSync(path.join(hqRoot, file));
+            if (stat.isFile() && stat.size > threshold)
+                oversized.push(file);
+        }
+        catch {
+            // Vanished between status and stat; nothing to do.
+        }
+    }
+    return oversized;
+}
+/**
+ * Render a repo-relative path as a literal `.gitignore` pattern.
+ *
+ * The leading slash anchors it to the repo root — without it a bare filename
+ * would also ignore same-named files in every subdirectory. Glob and
+ * character-class metacharacters are escaped so the rule matches the one real
+ * path and nothing else, and a trailing space is escaped because git strips
+ * unescaped ones.
+ */
+export function toGitignorePattern(relPath) {
+    const escaped = relPath.replace(/([\\*?[\]!#])/g, "\\$1");
+    const anchored = `/${escaped}`;
+    return anchored.endsWith(" ") ? `${anchored.slice(0, -1)}\\ ` : anchored;
+}
+function appendGitignore(hqRoot, patterns) {
+    if (patterns.length === 0)
+        return true;
+    const file = path.join(hqRoot, ".gitignore");
+    let existing = "";
+    try {
+        existing = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        // No .gitignore yet — it gets created below.
+    }
+    const present = new Set(existing.split("\n").map((line) => line.trim()));
+    const fresh = patterns.filter((p) => !present.has(p));
+    if (fresh.length === 0)
+        return true;
+    const needsNewline = existing.length > 0 && !existing.endsWith("\n");
+    const header = existing.includes(GITIGNORE_HEADER) ? "" : `${GITIGNORE_HEADER}\n`;
+    try {
+        fs.appendFileSync(file, `${needsNewline ? "\n" : ""}${header}${fresh.join("\n")}\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Scan `hqRoot` for files above the size limit, ignore them, and drop any that
+ * are already in the index.
+ *
+ * Never throws: every failure path degrades to "did nothing", because a guard
+ * that can take `hq reindex` down is worse than the problem it prevents.
+ */
+export function guardLargeFiles(hqRoot, options = {}) {
+    const threshold = options.thresholdBytes ?? DEFAULT_THRESHOLD_BYTES;
+    const now = options.now ?? Date.now();
+    const gitDir = resolveGitDir(hqRoot);
+    if (!gitDir)
+        return SKIPPED;
+    const stampPath = path.join(gitDir, STAMP_BASENAME);
+    if (!options.force && isThrottled(stampPath, now))
+        return SKIPPED;
+    writeStamp(stampPath, now);
+    const tracked = oversizedInIndex(hqRoot, threshold);
+    const trackedSet = new Set(tracked);
+    const worktree = oversizedInWorktree(hqRoot, threshold).filter((p) => !trackedSet.has(p));
+    const all = [...tracked, ...worktree];
+    if (all.length === 0)
+        return { scanned: true, ignored: [], untracked: [] };
+    // Ignore first, so a concurrent `git add -A` cannot re-stage what we are
+    // about to remove from the index.
+    const patterns = all.map(toGitignorePattern);
+    const wroteIgnore = appendGitignore(hqRoot, patterns);
+    const untracked = [];
+    for (const file of tracked) {
+        const removed = git(hqRoot, ["rm", "--cached", "--quiet", "--ignore-unmatch", "--", file]);
+        if (removed.ok)
+            untracked.push(file);
+    }
+    return {
+        scanned: true,
+        ignored: wroteIgnore ? all : [],
+        untracked,
+    };
+}
+//# sourceMappingURL=large-file-guard.js.map

package/dist/utils/self-update.d.ts

@@ -0,0 +1,111 @@
+/**
+ * CLI self-update: replace the running hq-cli global install with npm `latest`
+ * and re-exec the user's command so it runs on the fresh version.
+ *
+ * Two entry points, one mechanism:
+ *
+ *   - `autoUpdateAndReexec` — the default startup path. Previously the CLI just
+ *     printed "⚠ A new version is available" on every single command; now it
+ *     performs the update and re-runs the command, and only warns when the
+ *     update itself fails. Installs quietly (the package manager's stdout is
+ *     captured, never forwarded) because `--json` consumers parse ours.
+ *
+ *   - `selfUpdateAndReexec` — `hq rescue`. The rescue script ships inside this
+ *     install's `@indigoai-us/hq-cloud` dependency, so a stale CLI runs a stale
+ *     rescue; rescue therefore updates unconditionally-if-stale rather than
+ *     waiting for the cached npm signal, and shows the install output because
+ *     the user is watching a long recovery operation.
+ *
+ * Relationship to the other two update surfaces:
+ *   - `version-gate.ts` hard-updates when hq-pro reports the version is below
+ *     the enforced `minVersion` (and now delegates its softer
+ *     "updateRecommended" case here instead of nagging).
+ *   - `version-check.ts` maintains the cached npm `latest` that the startup
+ *     path reads, so the common case costs a small file read, not a fetch.
+ *
+ * Best-effort by design: registry unreachable, npm/pnpm missing, install
+ * failure, or `hq` not on PATH for the re-exec all degrade to running the
+ * command on the current version. Self-updating must never make a command less
+ * available than it was before.
+ *
+ * Opt-outs: `HQ_NO_UPDATE_CHECK=1` (the shared knob that also silences
+ * version-check), `hq rescue --no-self-update`, and the re-exec guard env.
+ */
+import { type RunningInstall, type UpdateResult } from "./version-gate.js";
+/**
+ * Set on the re-exec'd child so it can never self-update (and re-exec) again.
+ * One update + one re-exec per user invocation, ever.
+ */
+export declare const REEXEC_GUARD_ENV = "HQ_RESCUE_SELF_UPDATED";
+export type SelfUpdateAction = 
+/** Opted out, guard set, lock held elsewhere, or latest unknown — nothing attempted. */
+"skipped"
+/** Already at (or ahead of) npm latest. */
+ | "current"
+/** An update was attempted and failed; continue on the current version. */
+ | "update-failed"
+/** Updated, but the re-exec couldn't start; continue on the current (in-memory) version. */
+ | "updated-no-reexec"
+/** Updated and the command re-ran on the new version; exit with `reexecStatus`. */
+ | "reexec";
+export interface SelfUpdateOutcome {
+    action: SelfUpdateAction;
+    /** Exit status of the re-exec'd `hq …` (action === "reexec"). */
+    reexecStatus?: number;
+    latest?: string;
+}
+/**
+ * The manager-aware install argv for this layout — same routing as the hard
+ * gate: a pnpm-managed install must be updated by pnpm (npm would drop a copy
+ * the pnpm shim never reads), and an npm install goes through the resolved
+ * prefix so the copy that is actually running is the one replaced.
+ */
+export declare function buildSelfUpdatePlan(install: RunningInstall): {
+    cmd: string;
+    args: string[];
+};
+/**
+ * Install without letting the package manager write to OUR stdout. The startup
+ * path runs ahead of every command, including `--json` ones whose stdout is
+ * parsed by scripts and by HQ itself, and `npm install -g` prints its summary
+ * to stdout. Progress is summarised on stderr by the caller instead; captured
+ * stderr is kept only to explain a failure.
+ */
+export declare function runUpdateQuiet(cmd: string, args: string[]): UpdateResult;
+/**
+ * Serialize self-updates across concurrent `hq` processes. Without this, a
+ * machine running several HQ agents can fire many `npm install -g` at the same
+ * global prefix at once, and the losers fail with ENOTEMPTY mid-rename — the
+ * exact partial-install state `cleanStalePartialInstall` exists to repair.
+ * A caller that cannot take the lock simply skips its update: another process
+ * is already installing the very version it wanted.
+ *
+ * `mkdir` is the atomic primitive (same approach as version-check's refresh
+ * lock); a lock left behind by a killed process goes stale and is reclaimed.
+ */
+export declare function acquireUpdateLock(now?: number): (() => void) | null;
+/** Injectable surface so the flow is unit-testable without network or spawns. */
+export interface SelfUpdateDeps {
+    env?: NodeJS.ProcessEnv;
+    currentVersion?: string;
+    fetchLatest?: () => Promise<string | null>;
+    resolveInstall?: () => RunningInstall;
+    runner?: (cmd: string, args: string[]) => UpdateResult;
+    reexec?: (argv: string[], env: NodeJS.ProcessEnv) => number | null;
+    acquireLock?: () => (() => void) | null;
+}
+/**
+ * Startup path: the running CLI is behind npm `latest`, so update in place and
+ * re-run the user's command on the new version. `latest` is normally the cached
+ * value from `version-check.ts` (no fetch on the hot path); pass null to let
+ * this resolve it from the registry.
+ */
+export declare function autoUpdateAndReexec(argv: readonly string[], latest: string | null, deps?: SelfUpdateDeps): Promise<SelfUpdateOutcome>;
+/**
+ * Rescue path: update to npm latest and re-exec the rescue on the new version.
+ * `argv` is the full process argv (`process.argv`); the re-exec re-runs
+ * `argv.slice(2)` verbatim so flags like `--staging` / `--yes` / `--hq-root`
+ * are preserved.
+ */
+export declare function selfUpdateAndReexec(argv: readonly string[], deps?: SelfUpdateDeps): Promise<SelfUpdateOutcome>;
+//# sourceMappingURL=self-update.d.ts.map

package/dist/utils/self-update.js

@@ -0,0 +1,247 @@
+/**
+ * CLI self-update: replace the running hq-cli global install with npm `latest`
+ * and re-exec the user's command so it runs on the fresh version.
+ *
+ * Two entry points, one mechanism:
+ *
+ *   - `autoUpdateAndReexec` — the default startup path. Previously the CLI just
+ *     printed "⚠ A new version is available" on every single command; now it
+ *     performs the update and re-runs the command, and only warns when the
+ *     update itself fails. Installs quietly (the package manager's stdout is
+ *     captured, never forwarded) because `--json` consumers parse ours.
+ *
+ *   - `selfUpdateAndReexec` — `hq rescue`. The rescue script ships inside this
+ *     install's `@indigoai-us/hq-cloud` dependency, so a stale CLI runs a stale
+ *     rescue; rescue therefore updates unconditionally-if-stale rather than
+ *     waiting for the cached npm signal, and shows the install output because
+ *     the user is watching a long recovery operation.
+ *
+ * Relationship to the other two update surfaces:
+ *   - `version-gate.ts` hard-updates when hq-pro reports the version is below
+ *     the enforced `minVersion` (and now delegates its softer
+ *     "updateRecommended" case here instead of nagging).
+ *   - `version-check.ts` maintains the cached npm `latest` that the startup
+ *     path reads, so the common case costs a small file read, not a fetch.
+ *
+ * Best-effort by design: registry unreachable, npm/pnpm missing, install
+ * failure, or `hq` not on PATH for the re-exec all degrade to running the
+ * command on the current version. Self-updating must never make a command less
+ * available than it was before.
+ *
+ * Opt-outs: `HQ_NO_UPDATE_CHECK=1` (the shared knob that also silences
+ * version-check), `hq rescue --no-self-update`, and the re-exec guard env.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import semver from "semver";
+import chalk from "chalk";
+import { CLI_NAME, CLI_VERSION } from "../cli-version.js";
+import { buildPnpmInstallArgv, buildPrefixedInstallArgv, buildSpawnPlan, resolveRunningInstall, runUpdateCommand, } from "./version-gate.js";
+/**
+ * Set on the re-exec'd child so it can never self-update (and re-exec) again.
+ * One update + one re-exec per user invocation, ever.
+ */
+export const REEXEC_GUARD_ENV = "HQ_RESCUE_SELF_UPDATED";
+const REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(CLI_NAME)}/latest`;
+const FETCH_TIMEOUT_MS = 3_000;
+/** A held update lock older than this is treated as abandoned (crashed owner). */
+const UPDATE_LOCK_STALE_MS = 10 * 60 * 1000;
+/** Tail of captured package-manager stderr kept for the failure warning. */
+const DETAIL_MAX_CHARS = 400;
+/** npm `latest` for this package, or null on any failure (offline, 5xx, bad body). */
+async function fetchLatestVersion() {
+    try {
+        const res = await fetch(REGISTRY_URL, {
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return typeof body.version === "string" ? body.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The manager-aware install argv for this layout — same routing as the hard
+ * gate: a pnpm-managed install must be updated by pnpm (npm would drop a copy
+ * the pnpm shim never reads), and an npm install goes through the resolved
+ * prefix so the copy that is actually running is the one replaced.
+ */
+export function buildSelfUpdatePlan(install) {
+    if (install.manager === "pnpm")
+        return { cmd: "pnpm", args: buildPnpmInstallArgv() };
+    if (install.prefix)
+        return { cmd: "npm", args: buildPrefixedInstallArgv(install.prefix) };
+    return { cmd: "npm", args: ["install", "-g", `${CLI_NAME}@latest`] };
+}
+/**
+ * Install without letting the package manager write to OUR stdout. The startup
+ * path runs ahead of every command, including `--json` ones whose stdout is
+ * parsed by scripts and by HQ itself, and `npm install -g` prints its summary
+ * to stdout. Progress is summarised on stderr by the caller instead; captured
+ * stderr is kept only to explain a failure.
+ */
+export function runUpdateQuiet(cmd, args) {
+    try {
+        const plan = buildSpawnPlan(cmd, args);
+        const result = spawnSync(plan.cmd, plan.args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: plan.shell,
+            encoding: "utf-8",
+        });
+        if (result.error) {
+            const code = result.error.code;
+            return { ok: false, code, detail: result.error.message };
+        }
+        if (result.status !== 0) {
+            const stderr = (result.stderr ?? "").trim();
+            const tail = stderr ? stderr.slice(-DETAIL_MAX_CHARS) : "";
+            return {
+                ok: false,
+                detail: tail || `exit ${result.status ?? "signal"}`,
+            };
+        }
+        return { ok: true };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            code: err?.code,
+            detail: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function lockDir() {
+    return path.join(os.homedir(), ".hq", "self-update.lock");
+}
+/**
+ * Serialize self-updates across concurrent `hq` processes. Without this, a
+ * machine running several HQ agents can fire many `npm install -g` at the same
+ * global prefix at once, and the losers fail with ENOTEMPTY mid-rename — the
+ * exact partial-install state `cleanStalePartialInstall` exists to repair.
+ * A caller that cannot take the lock simply skips its update: another process
+ * is already installing the very version it wanted.
+ *
+ * `mkdir` is the atomic primitive (same approach as version-check's refresh
+ * lock); a lock left behind by a killed process goes stale and is reclaimed.
+ */
+export function acquireUpdateLock(now = Date.now()) {
+    const dir = lockDir();
+    const release = () => {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // best-effort lock cleanup
+        }
+    };
+    try {
+        fs.mkdirSync(path.dirname(dir), { recursive: true });
+        fs.mkdirSync(dir);
+        return release;
+    }
+    catch {
+        try {
+            const stat = fs.statSync(dir);
+            if (now - stat.mtimeMs > UPDATE_LOCK_STALE_MS) {
+                fs.rmSync(dir, { recursive: true, force: true });
+                fs.mkdirSync(dir);
+                return release;
+            }
+        }
+        catch {
+            // lock vanished or is unreadable — treat as held and skip
+        }
+        return null;
+    }
+}
+/**
+ * Re-run `hq <argv…>` from PATH so the freshly-installed version handles the
+ * command. Returns the child's exit status, or null when the child could not be
+ * started at all (e.g. `hq` not on PATH in a minimal-PATH parent).
+ */
+function reexecHq(argv, env) {
+    const plan = buildSpawnPlan("hq", argv);
+    const result = spawnSync(plan.cmd, plan.args, {
+        stdio: "inherit",
+        shell: plan.shell,
+        env,
+    });
+    if (result.error)
+        return null;
+    // A signal-killed child has status null; surface it as a failure exit rather
+    // than pretending the command completed.
+    return result.status ?? 1;
+}
+async function updateAndReexec(argv, flavor, known, deps) {
+    const env = deps.env ?? process.env;
+    if (env[REEXEC_GUARD_ENV] === "1" || env.HQ_NO_UPDATE_CHECK === "1") {
+        return { action: "skipped" };
+    }
+    const latest = known ?? (await (deps.fetchLatest ?? fetchLatestVersion)());
+    if (!latest)
+        return { action: "skipped" };
+    const current = semver.valid(deps.currentVersion ?? CLI_VERSION);
+    const latestValid = semver.valid(latest);
+    if (!current || !latestValid)
+        return { action: "skipped" };
+    if (!semver.gt(latestValid, current))
+        return { action: "current", latest };
+    const releaseLock = flavor.lock ? (deps.acquireLock ?? acquireUpdateLock)() : () => { };
+    if (!releaseLock)
+        return { action: "skipped", latest };
+    let result;
+    const install = (deps.resolveInstall ?? resolveRunningInstall)();
+    const plan = buildSelfUpdatePlan(install);
+    try {
+        console.error(chalk.dim(`Updating hq-cli ${current} → ${latest}…`));
+        const defaultRunner = flavor.verbose ? runUpdateCommand : runUpdateQuiet;
+        result = (deps.runner ?? defaultRunner)(plan.cmd, plan.args);
+    }
+    finally {
+        releaseLock();
+    }
+    if (!result.ok) {
+        // The one case that still warrants the old yellow banner: we could not get
+        // the user onto the new version, so they need to know it exists and how to
+        // install it by hand.
+        console.error(chalk.yellow(`⚠ hq-cli ${latest} is available but the update failed` +
+            `${result.detail ? `: ${result.detail}` : ""}`));
+        console.error(chalk.dim(`  Try manually: ${plan.cmd} ${plan.args.join(" ")}`));
+        console.error(chalk.dim(`  Continuing the ${flavor.noun} on ${current}.`));
+        return { action: "update-failed", latest };
+    }
+    const childEnv = { ...env, [REEXEC_GUARD_ENV]: "1" };
+    const status = (deps.reexec ?? reexecHq)([...argv.slice(2)], childEnv);
+    if (status === null) {
+        console.error(chalk.yellow(`⚠ Updated hq-cli to ${latest}, but couldn't re-launch \`hq\` from PATH; ` +
+            `continuing the ${flavor.noun} on ${current}.`));
+        return { action: "updated-no-reexec", latest };
+    }
+    console.error(chalk.dim(`✓ hq-cli updated to ${latest}.`));
+    return { action: "reexec", reexecStatus: status, latest };
+}
+/**
+ * Startup path: the running CLI is behind npm `latest`, so update in place and
+ * re-run the user's command on the new version. `latest` is normally the cached
+ * value from `version-check.ts` (no fetch on the hot path); pass null to let
+ * this resolve it from the registry.
+ */
+export async function autoUpdateAndReexec(argv, latest, deps = {}) {
+    return updateAndReexec(argv, { noun: "command", verbose: false, lock: true }, latest, deps);
+}
+/**
+ * Rescue path: update to npm latest and re-exec the rescue on the new version.
+ * `argv` is the full process argv (`process.argv`); the re-exec re-runs
+ * `argv.slice(2)` verbatim so flags like `--staging` / `--yes` / `--hq-root`
+ * are preserved.
+ */
+export async function selfUpdateAndReexec(argv, deps = {}) {
+    return updateAndReexec(argv, { noun: "rescue", verbose: true, lock: true }, null, deps);
+}
+//# sourceMappingURL=self-update.js.map

package/dist/utils/version-check.d.ts

@@ -1,5 +1,15 @@
 declare function isKnownNoninteractiveStatusProbe(argv?: readonly string[]): boolean;
-export declare function maybeWarnNewVersion(): void;
+/**
+ * The cached npm `latest` when it is newer than the running version, else null.
+ *
+ * This replaced `maybeWarnNewVersion`, which printed a yellow "a new version is
+ * available" banner on EVERY command. The signal is the same (a fresh cache
+ * entry written by `refreshVersionCache` on a previous run, so the hot path
+ * stays a single file read); what changed is what the CLI does with it — see
+ * `utils/self-update.ts`, which installs the new version and re-runs the
+ * command, and warns only if that fails.
+ */
+export declare function staleAgainstCachedLatest(now?: number): string | null;
 export declare function refreshVersionCache(): Promise<void>;
 export declare const __test__: {
     CACHE_TTL_MS: number;

package/dist/utils/version-check.js

@@ -2,7 +2,6 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import semver from "semver";
-import chalk from "chalk";
 import { CLI_VERSION } from "../cli-version.js";
 const PACKAGE_NAME = "@indigoai-us/hq-cli";
 const REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
@@ -96,22 +95,31 @@ function acquireRefreshLock(now = Date.now()) {
         return null;
     }
 }
-export function maybeWarnNewVersion() {
+/**
+ * The cached npm `latest` when it is newer than the running version, else null.
+ *
+ * This replaced `maybeWarnNewVersion`, which printed a yellow "a new version is
+ * available" banner on EVERY command. The signal is the same (a fresh cache
+ * entry written by `refreshVersionCache` on a previous run, so the hot path
+ * stays a single file read); what changed is what the CLI does with it — see
+ * `utils/self-update.ts`, which installs the new version and re-runs the
+ * command, and warns only if that fails.
+ */
+export function staleAgainstCachedLatest(now = Date.now()) {
     if (isOptedOut())
-        return;
+        return null;
     const entry = readCache();
     if (!entry)
-        return;
-    if (Date.now() - entry.fetchedAt > CACHE_TTL_MS)
-        return;
+        return null;
+    if (now - entry.fetchedAt > CACHE_TTL_MS)
+        return null;
     const current = semver.valid(CLI_VERSION);
     const latest = semver.valid(entry.latest);
     if (!current || !latest)
-        return;
+        return null;
     if (!semver.gt(latest, current))
-        return;
-    const msg = chalk.yellow(`⚠ A new version of hq is available: ${entry.latest} (current: ${CLI_VERSION}). It's recommended to update.`);
-    console.error(msg);
+        return null;
+    return entry.latest;
 }
 export async function refreshVersionCache() {
     if (isOptedOut())

package/dist/utils/version-gate.d.ts

@@ -29,7 +29,7 @@
  */
 /** Which package manager owns the running global install. */
 export type InstallManager = "npm" | "pnpm";
-interface VersionCheckResponse {
+export interface VersionCheckResponse {
     clientId: string;
     currentVersion: string;
     minVersion: string;
@@ -140,7 +140,7 @@ export declare function cleanStalePartialInstall(prefix: string, fs?: StaleInsta
  * forcing a re-invocation would run twice on the same process and feel
  * janky; instead we print a clear "rerun your command" message and exit.
  */
-type UpdateResult = {
+export type UpdateResult = {
     ok: boolean;
     detail?: string;
     code?: string;
@@ -166,7 +166,7 @@ export declare function buildSpawnPlan(cmd: string, args: readonly string[], pla
     args: string[];
     shell: boolean;
 };
-declare function runUpdateCommand(cmd: string, args: string[]): UpdateResult;
+export declare function runUpdateCommand(cmd: string, args: string[]): UpdateResult;
 declare function performUpdateCommand(cmd: string, args: string[], runner?: UpdateRunner): UpdateResult;
 declare function performUpdate(command: string, runner?: UpdateRunner): UpdateResult;
 /**
@@ -176,6 +176,11 @@ declare function performUpdate(command: string, runner?: UpdateRunner): UpdateRe
  * This path fires for EVERY version below latest (the hard gate only fires
  * below `minVersion`), so it is the far more frequently seen of the two and
  * must be manager-aware for the same reason the gate is.
+ *
+ * It is now only the FALLBACK: `enforceVersionGate` prefers the
+ * `onUpdateRecommended` handler that main.ts wires to the self-updater, which
+ * installs the new version and re-runs the command instead of nagging. This
+ * remains for callers that pass no handler.
  */
 declare function nudgeUpdateRecommended(decision: VersionCheckResponse, install?: RunningInstall): void;
 /**
@@ -203,8 +208,15 @@ declare function enforceUpdateRequired(decision: VersionCheckResponse, deps?: {
  * `--version` / `-v` callers MUST skip the gate (the user is debugging a
  * broken install and shouldn't be force-upgraded mid-investigation). Caller
  * is responsible for checking argv before invoking us — see index.ts.
+ *
+ * `onUpdateRecommended` takes over the soft (below-latest, above-minimum)
+ * case. main.ts passes the self-updater there so the CLI updates and re-runs
+ * the command rather than printing a banner on every invocation; if that
+ * handler reports it re-exec'd, the gate returns `"reexec"` and the caller
+ * must exit rather than running the command a second time.
  */
-export declare function enforceVersionGate(): Promise<void>;
+export type VersionGateOutcome = "continue" | "reexec";
+export declare function enforceVersionGate(onUpdateRecommended?: (decision: VersionCheckResponse, install: RunningInstall) => Promise<boolean>): Promise<VersionGateOutcome>;
 /**
  * Cheap argv pre-check: skip the gate for `--version` / `-V` so users
  * inspecting a broken install can still see what they have without being

package/dist/utils/version-gate.js

@@ -306,7 +306,7 @@ export function buildSpawnPlan(cmd, args, platform = process.platform) {
         return { cmd, args: [...args], shell: false };
     return { cmd, args: args.map(quoteForWindowsShell), shell: true };
 }
-function runUpdateCommand(cmd, args) {
+export function runUpdateCommand(cmd, args) {
     try {
         const plan = buildSpawnPlan(cmd, args);
         const result = spawnSync(plan.cmd, plan.args, {
@@ -368,6 +368,11 @@ function manualUpdateCommand(install, decision) {
  * This path fires for EVERY version below latest (the hard gate only fires
  * below `minVersion`), so it is the far more frequently seen of the two and
  * must be manager-aware for the same reason the gate is.
+ *
+ * It is now only the FALLBACK: `enforceVersionGate` prefers the
+ * `onUpdateRecommended` handler that main.ts wires to the self-updater, which
+ * installs the new version and re-runs the command instead of nagging. This
+ * remains for callers that pass no handler.
  */
 function nudgeUpdateRecommended(decision, install = resolveRunningInstall()) {
     const msg = chalk.yellow(`⚠ A new version of hq-cli is available: ${decision.latestVersion} (current: ${decision.currentVersion}).`);
@@ -500,24 +505,14 @@ function enforceUpdateRequired(decision, deps = {}) {
     console.error(chalk.green(`✓ Updated to hq-cli ${decision.latestVersion}. Rerun your command.`));
     process.exit(0);
 }
-/**
- * Public entry point. Call before commander parses argv. Blocks the CLI on
- * network IO for up to FETCH_TIMEOUT_MS — acceptable because the alternative
- * (a fire-and-forget background check) gives the user no chance to bail out
- * of a known-bad version before it does damage.
- *
- * `--version` / `-v` callers MUST skip the gate (the user is debugging a
- * broken install and shouldn't be force-upgraded mid-investigation). Caller
- * is responsible for checking argv before invoking us — see index.ts.
- */
-export async function enforceVersionGate() {
+export async function enforceVersionGate(onUpdateRecommended) {
     if (isOptedOut())
-        return;
+        return "continue";
     const decision = await fetchVersionDecision();
     if (!decision)
-        return; // best-effort: silent on any failure
+        return "continue"; // best-effort: silent on any failure
     if (!decision.updateRequired && !decision.updateRecommended)
-        return;
+        return "continue";
     // Resolved once, here, so the up-to-date case never pays for the walk and
     // neither downstream path repeats it.
     const install = resolveRunningInstall();
@@ -525,8 +520,16 @@ export async function enforceVersionGate() {
         enforceUpdateRequired(decision, { resolveInstall: () => install }); // exits process
     }
     if (decision.updateRecommended) {
+        if (onUpdateRecommended) {
+            // The handler owns its own failure messaging (it warns only when the
+            // update it attempted did not land), so there is no nudge fallback here.
+            if (await onUpdateRecommended(decision, install))
+                return "reexec";
+            return "continue";
+        }
         nudgeUpdateRecommended(decision, install);
     }
+    return "continue";
 }
 /**
  * Cheap argv pre-check: skip the gate for `--version` / `-V` so users

package/package.json

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