@indigoai-us/hq-cli 5.305.0 → 5.307.0

package/dist/lib/daemon/catalog.js

@@ -283,7 +283,9 @@ function planService(service, ctx) {
                 base(service, {
                     command: {
                         type: "hq",
-                        args: ["daemon", "service", "codex-remote-control", "--script", script ?? "", "--codex", ctx.codexPath ?? ""],
+                        // No codex path: the host finds codex itself, so a reinstall that
+                        // briefly moves the link cannot change the plan and restart it.
+                        args: ["daemon", "service", "codex-remote-control", "--script", script ?? ""],
                     },
                     // Restarting the host ends the tmux session people are using.
                     keepAcrossCliUpdates: true,
@@ -303,7 +305,9 @@ function planService(service, ctx) {
             // Outposts keep the runner's session name and permission mode.
             const outpost = ctx.machineType === "outpost";
             const name = ctx.remoteControlName ?? (outpost ? "outpost-1" : ctx.hostName);
-            const args = ["daemon", "service", "remote-control", "--claude", ctx.claudePath ?? "", "--name", name];
+            // No claude path: the host finds claude itself, so a reinstall that
+            // briefly moves the link cannot change the plan and restart the session.
+            const args = ["daemon", "service", "remote-control", "--name", name];
             if (outpost)
                 args.push("--permission-mode", "bypassPermissions");
             return [

package/dist/lib/daemon/remote-control.d.ts

@@ -10,10 +10,12 @@
  * - the session ends -> the host exits 1 and the daemon restarts it with
  *   backoff (replacing the runner's `while true` loop and its watchdogs);
  * - the daemon stops the host -> the host kills the session and exits 0;
- * - the tool's binary changes on disk (the updater installed a new version) ->
- *   once the session has been quiet for 10 minutes, or after 2 hours at the
- *   latest, the host kills the session and exits 0, and the daemon starts it
- *   again on the new version.
+ * - a new version of the tool is installed (the updater, or the tool's own
+ *   auto-updater) -> once the session has been quiet for 10 minutes, or after
+ *   2 hours at the latest, the host kills the session and exits 0, and the
+ *   daemon starts it again on the new version. Reinstalling the same version
+ *   (a long-running Claude session's auto-updater does that every few
+ *   minutes) and hq-cli releases leave the session alone.
  *
  * The tmux server is a private socket (`-L hq-daemon`), so it never touches a
  * user's own tmux sessions.
@@ -32,11 +34,20 @@ export declare function remoteControlArgs(opts: {
  */
 export declare function runnerSessionName(script: string): string | null;
 /**
- * Fingerprint of what a host runs: the tool first, then other installs it
- * depends on (the hq-cli package). Null while the tool cannot be read; an
- * unreadable extra install is left out rather than hiding a tool update.
+ * Which version of a tool is installed: the npm package that installs the
+ * binary (`name@version`), else the binary's real path and size. A native
+ * install's link points at a versioned file, so its real path is the version.
+ * The mtime is left out on purpose: reinstalling the same version rewrites
+ * the file, and that must not restart the session. Null while the tool
+ * cannot be read.
  */
-export declare function installFingerprint(paths: readonly string[], fingerprint: (file: string) => string | null): string | null;
+export declare function toolFingerprint(bin: string): string | null;
+/**
+ * The tool a host runs: the path it was given, else the one found now. The
+ * daemon's plan leaves the path out, so a reinstall that briefly removes the
+ * tool's link cannot change the plan and restart the session.
+ */
+export declare function serviceTool(name: string, given: string | undefined, find: (name: string) => string | null): string;
 /** A tool updated on disk restarts its session once quiet this long... */
 export declare const IDLE_BEFORE_RESTART_MS: number;
 /** ...or after this long, however busy the session is. */

package/dist/lib/daemon/remote-control.js

@@ -10,14 +10,18 @@
  * - the session ends -> the host exits 1 and the daemon restarts it with
  *   backoff (replacing the runner's `while true` loop and its watchdogs);
  * - the daemon stops the host -> the host kills the session and exits 0;
- * - the tool's binary changes on disk (the updater installed a new version) ->
- *   once the session has been quiet for 10 minutes, or after 2 hours at the
- *   latest, the host kills the session and exits 0, and the daemon starts it
- *   again on the new version.
+ * - a new version of the tool is installed (the updater, or the tool's own
+ *   auto-updater) -> once the session has been quiet for 10 minutes, or after
+ *   2 hours at the latest, the host kills the session and exits 0, and the
+ *   daemon starts it again on the new version. Reinstalling the same version
+ *   (a long-running Claude session's auto-updater does that every few
+ *   minutes) and hq-cli releases leave the session alone.
  *
  * The tmux server is a private socket (`-L hq-daemon`), so it never touches a
  * user's own tmux sessions.
  */
+import * as fs from "node:fs";
+import * as path from "node:path";
 export const TMUX_SOCKET = "hq-daemon";
 export const TMUX_SESSION = "remote-control";
 export const CODEX_TMUX_SESSION = "codex-remote-control";
@@ -35,17 +39,63 @@ export function runnerSessionName(script) {
     const m = /remote-control\b[^\n]*?--name[= ]+"?([^\s"]+)"?/.exec(script);
     return m ? m[1] : null;
 }
+/** How far above the binary to look for the package that installs it (bin/claude.exe sits one level down). */
+const PACKAGE_SEARCH_DEPTH = 3;
 /**
- * Fingerprint of what a host runs: the tool first, then other installs it
- * depends on (the hq-cli package). Null while the tool cannot be read; an
- * unreadable extra install is left out rather than hiding a tool update.
+ * Which version of a tool is installed: the npm package that installs the
+ * binary (`name@version`), else the binary's real path and size. A native
+ * install's link points at a versioned file, so its real path is the version.
+ * The mtime is left out on purpose: reinstalling the same version rewrites
+ * the file, and that must not restart the session. Null while the tool
+ * cannot be read.
  */
-export function installFingerprint(paths, fingerprint) {
-    const [tool, ...rest] = paths;
-    const toolFp = tool === undefined ? null : fingerprint(tool);
-    if (toolFp === null)
+export function toolFingerprint(bin) {
+    let real;
+    let size;
+    try {
+        real = fs.realpathSync(bin);
+        size = fs.statSync(real).size;
+    }
+    catch {
+        return null;
+    }
+    let dir = path.dirname(real);
+    for (let i = 0; i < PACKAGE_SEARCH_DEPTH; i++) {
+        const version = packageVersionFor(dir, real);
+        if (version)
+            return version;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return `${real}:${size}`;
+}
+/** `name@version` when `<dir>/package.json` declares `real` as one of its bins. */
+function packageVersionFor(dir, real) {
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+    }
+    catch {
         return null;
-    return [toolFp, ...rest.map(fingerprint).filter((fp) => fp !== null)].join("|");
+    }
+    if (typeof pkg.name !== "string" || typeof pkg.version !== "string")
+        return null;
+    const bins = typeof pkg.bin === "string" ? [pkg.bin] : pkg.bin && typeof pkg.bin === "object" ? Object.values(pkg.bin) : [];
+    const installs = bins.some((b) => typeof b === "string" && path.resolve(dir, b) === real);
+    return installs ? `${pkg.name}@${pkg.version}` : null;
+}
+/**
+ * The tool a host runs: the path it was given, else the one found now. The
+ * daemon's plan leaves the path out, so a reinstall that briefly removes the
+ * tool's link cannot change the plan and restart the session.
+ */
+export function serviceTool(name, given, find) {
+    const tool = given?.trim() || find(name);
+    if (!tool)
+        throw new Error(`the ${name} CLI is not installed`);
+    return tool;
 }
 /** A tool updated on disk restarts its session once quiet this long... */
 export const IDLE_BEFORE_RESTART_MS = 10 * 60_000;

package/dist/lib/daemon/supervisor.d.ts

@@ -123,6 +123,8 @@ export interface Supervisor {
     /** Stop supervising without signalling any child; returns the long-running units left running. */
     release(): ReleasedUnit[];
 }
+/** Plan reads in a row that must find a running remote-control host blocked before it is paused. */
+export declare const BLOCKED_READS_BEFORE_PAUSE = 2;
 export declare function backoffMs(attempt: number): number;
 /**
  * What a unit's process was started from; a unit whose key changes is

package/dist/lib/daemon/supervisor.js

@@ -33,6 +33,8 @@ const MESH_OWNER_LOG_INTERVAL_MS = 10 * 60_000;
 export const HANDOFF_STAGGER_MS = 15_000;
 /** How long a draining unit may take to finish its work before it gets SIGTERM. */
 export const HANDOFF_DRAIN_MAX_MS = 15 * 60_000;
+/** Plan reads in a row that must find a running remote-control host blocked before it is paused. */
+export const BLOCKED_READS_BEFORE_PAUSE = 2;
 export function backoffMs(attempt) {
     return Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** Math.max(0, attempt));
 }
@@ -505,6 +507,15 @@ export function createSupervisor(deps) {
                 continue;
             }
             next.set(plan.id, existing);
+            // A remote-control host is what people's sessions run in. Its tool can
+            // look missing for one plan read while it is being reinstalled, so it is
+            // only paused once the tool is missing on two reads in a row.
+            if (plan.blocked && existing.plan.blocked === undefined && existing.child && plan.keepAcrossCliUpdates) {
+                existing.blockedReads = (existing.blockedReads ?? 0) + 1;
+                if (existing.blockedReads < BLOCKED_READS_BEFORE_PAUSE)
+                    continue;
+            }
+            existing.blockedReads = 0;
             const adopted = existing.adopted === true;
             existing.adopted = false;
             const key = planKey(plan, deps.cliVersion);

package/dist/lib/db/control-plane.js

@@ -1,4 +1,8 @@
 import { planGateErrorFromPayload } from "../../utils/plan-gate-error.js";
+// Provision may allocate remote resources, so allow two minutes and never retry.
+const DB_PROVISION_TIMEOUT_MS = 120_000;
+// Status is a read-only probe; 15 seconds is longer than its normal response time.
+const DB_STATUS_TIMEOUT_MS = 15_000;
 function assertNoPostgresUrl(label, text) {
     if (/postgres:\/\//i.test(text) || /postgresql:\/\//i.test(text)) {
         throw new Error(`${label}: control plane returned a connection string (refusing to surface)`);
@@ -22,6 +26,7 @@ export class ControlPlaneDbClient {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify(input),
+            signal: AbortSignal.timeout(DB_PROVISION_TIMEOUT_MS),
         });
         const text = await res.text();
         assertNoPostgresUrl("provision", text);
@@ -53,6 +58,7 @@ export class ControlPlaneDbClient {
         const res = await this.fetchImpl(url, {
             method: "GET",
             headers: { Authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(DB_STATUS_TIMEOUT_MS),
         });
         const text = await res.text();
         assertNoPostgresUrl("status", text);

package/dist/lib/deploy-apps.js

@@ -7,6 +7,7 @@ export const MAX_DEPLOY_APPS_PAGES = 100;
  */
 export async function listDeployApps(fetchPage) {
     const apps = [];
+    const seenCursors = new Set();
     let cursor;
     for (let page = 0; page < MAX_DEPLOY_APPS_PAGES; page += 1) {
         const result = await fetchPage(cursor);
@@ -17,6 +18,10 @@ export async function listDeployApps(fetchPage) {
         if (typeof result.nextCursor !== "string" || result.nextCursor.length === 0) {
             throw new Error("hq-deploy returned an invalid apps-list cursor.");
         }
+        if (seenCursors.has(result.nextCursor)) {
+            throw new Error("hq-deploy returned a repeated apps list cursor.");
+        }
+        seenCursors.add(result.nextCursor);
         cursor = result.nextCursor;
     }
     throw new Error(`hq-deploy apps list exceeded the ${MAX_DEPLOY_APPS_PAGES}-page safety cap.`);

package/dist/startup-registration.js

@@ -150,9 +150,15 @@ export async function registerCommandsWithRecovery(args) {
                 // writer held the shared lock past its own ceiling — report 'lock-held'
                 // (its remedy tells the user to let the update finish, never to reinstall
                 // over it). Otherwise the tree genuinely never settled with no writer
-                // visible. The settle probe only uses `stale_tree` when it could observe
-                // an unchanged tree with no active writer or retired sibling.
-                outcome: result.lockHeldAtEnd ? "lock-held" : result.staleTree ? "stale_tree" : "unsettled",
+                // visible. A partial retired-sibling scan gets its own outcome so we do
+                // not claim that an updater is absent when part of its tree was unreadable.
+                outcome: result.lockHeldAtEnd
+                    ? "lock-held"
+                    : result.retiredSiblingUnverified
+                        ? "retired_unverified"
+                        : result.staleTree
+                            ? "stale_tree"
+                            : "unsettled",
                 treeState,
                 attempt: 1,
                 waitedMs: result.waitedMs,

package/dist/utils/install-tree-torn.d.ts

@@ -274,6 +274,8 @@ export interface WaitForInstallTreeSettledResult {
     staleTree?: boolean;
     /** Presence on the final poll; null means the sibling directory was unreadable. */
     retiredSiblingPresent?: boolean | null;
+    /** A stable partial retired-sibling scan ended the wait without claiming the tree is stale. */
+    retiredSiblingUnverified?: boolean;
 }
 export declare const DEFAULT_INSTALL_TREE_STALE_PROBE_MS = 1500;
 /**
@@ -288,11 +290,14 @@ export declare const DEFAULT_INSTALL_TREE_STALE_PROBE_MS = 1500;
  * app, the box's update timer, another `hq`) cannot make a legitimately-in-progress
  * reinstall look stale:
  *   - UNLOCKED time — wall time observed with no fresh foreign lock — is bounded
- *     by `deadlineMs`. If the target is still missing and the observed tree,
- *     including retired sibling names and mtimes, stays unchanged for
- *     `staleProbeMs`, the wait returns `staleTree` early. Any observed tree
- *     change keeps the ordinary settle deadline in force. `deadlineMs === 0`
- *     evaluates readiness once.
+ *     by `deadlineMs`. If the target is still missing and the observable tree
+ *     signature stays unchanged for `staleProbeMs`, the wait returns `staleTree`
+ *     early. When only a named retired npm sibling's deep scan is incomplete,
+ *     a stable partial signature ends the wait early as `retiredSiblingUnverified`
+ *     instead. That outcome preserves uncertainty and tells the user to wait for
+ *     any installer before attempting a repair. Any observed signature change
+ *     keeps the ordinary settle deadline in force. `deadlineMs === 0` evaluates
+ *     readiness once.
  *   - LOCKED time — wall time observed under a fresh foreign lock held by a live
  *     pid — is bounded SEPARATELY by `lockWaitMs` (default the lock contract's own
  *     10-minute staleness window) and does NOT consume the settle budget. When
@@ -331,7 +336,7 @@ export interface InstallRewriteSignalArgs {
  */
 export declare function installRewriteInProgress(args: InstallRewriteSignalArgs): boolean;
 /** The recovery OUTCOME, which — not the dialect — decides capture. */
-export type InstallTreeTornOutcome = "guarded" | "unsettled" | "reexec-failed" | "lock-held" | "stale_tree";
+export type InstallTreeTornOutcome = "guarded" | "unsettled" | "reexec-failed" | "lock-held" | "stale_tree" | "retired_unverified";
 export type InstallTreeState = "in_flight" | "stale";
 export type InstallTreeTornDiagnostics = {
     dialect: ModuleErrorDialect;
@@ -408,6 +413,8 @@ export declare function scrubHomeDirectoryPrefix(value: string, homeDirectory?:
 export declare const INSTALL_TREE_TORN_REMEDY: string;
 /** Fixed repair guidance for an unchanged tree with no active updater signal. */
 export declare const INSTALL_TREE_STALE_REMEDY: string;
+/** Guidance when a retired package sibling's activity could not be verified. */
+export declare const INSTALL_TREE_RETIRED_UNVERIFIED_REMEDY: string;
 /**
  * The fixed, input-free remedy for the 'lock-held' outcome: a cooperating writer
  * held the shared update lock past its own staleness ceiling. Telling the user to

package/dist/utils/install-tree-torn.js

@@ -700,7 +700,7 @@ function retiredSiblingActivitySignature(packageRoot, fs) {
     for (const sibling of siblings) {
         visit(path.join(parent, sibling), sibling, 0);
     }
-    return { value: JSON.stringify(snapshots), observed };
+    return { value: JSON.stringify(snapshots), observed, present: siblings.length > 0 };
 }
 /** Whether packageRoot's own manifest is healthy (`name === CLI_NAME`). */
 function packageRootHealthy(packageRoot, fs) {
@@ -787,6 +787,8 @@ function installTreeActivitySignature(target, packageRoot, fs) {
     const activity = installTreeActivityPaths(target, packageRoot);
     const snapshots = [];
     let observed = true;
+    let nonRetiredObserved = true;
+    let retiredSiblingPresent = null;
     const errorCode = (err) => {
         if (err !== null && typeof err === "object" && "code" in err && typeof err.code === "string") {
             return err.code;
@@ -809,6 +811,7 @@ function installTreeActivitySignature(target, packageRoot, fs) {
         }
         catch (err) {
             observed = false;
+            nonRetiredObserved = false;
             snapshots.push([candidate, `unreadable:${errorCode(err)}`]);
         }
     }
@@ -820,6 +823,7 @@ function installTreeActivitySignature(target, packageRoot, fs) {
         }
         catch (err) {
             observed = false;
+            nonRetiredObserved = false;
             snapshots.push([directory, `entries-unreadable:${errorCode(err)}`]);
         }
     }
@@ -827,6 +831,7 @@ function installTreeActivitySignature(target, packageRoot, fs) {
         try {
             const retired = retiredSiblingActivitySignature(packageRoot, fs);
             snapshots.push(["retired-siblings", retired.value]);
+            retiredSiblingPresent = retired.present;
             if (!retired.observed)
                 observed = false;
         }
@@ -835,7 +840,16 @@ function installTreeActivitySignature(target, packageRoot, fs) {
             snapshots.push(["retired-siblings-unreadable", errorCode(err)]);
         }
     }
-    return { value: JSON.stringify(snapshots), observed };
+    return { value: JSON.stringify(snapshots), observed, nonRetiredObserved, retiredSiblingPresent };
+}
+function canProbeUnsettledRetiredSibling(snapshot) {
+    // A very large or unreadable retired npm tree can exceed the bounded recursive
+    // activity scan. Its stable partial signature is still useful when the live
+    // install paths are observable and npm's named retired sibling is present.
+    // This only selects the existing stale-tree repair outcome; it never removes
+    // files, and any observed signature change still suppresses stale classification.
+    return snapshot.observed ||
+        (snapshot.nonRetiredObserved && snapshot.retiredSiblingPresent === true);
 }
 export const DEFAULT_INSTALL_TREE_STALE_PROBE_MS = 1_500;
 /**
@@ -850,11 +864,14 @@ export const DEFAULT_INSTALL_TREE_STALE_PROBE_MS = 1_500;
  * app, the box's update timer, another `hq`) cannot make a legitimately-in-progress
  * reinstall look stale:
  *   - UNLOCKED time — wall time observed with no fresh foreign lock — is bounded
- *     by `deadlineMs`. If the target is still missing and the observed tree,
- *     including retired sibling names and mtimes, stays unchanged for
- *     `staleProbeMs`, the wait returns `staleTree` early. Any observed tree
- *     change keeps the ordinary settle deadline in force. `deadlineMs === 0`
- *     evaluates readiness once.
+ *     by `deadlineMs`. If the target is still missing and the observable tree
+ *     signature stays unchanged for `staleProbeMs`, the wait returns `staleTree`
+ *     early. When only a named retired npm sibling's deep scan is incomplete,
+ *     a stable partial signature ends the wait early as `retiredSiblingUnverified`
+ *     instead. That outcome preserves uncertainty and tells the user to wait for
+ *     any installer before attempting a repair. Any observed signature change
+ *     keeps the ordinary settle deadline in force. `deadlineMs === 0` evaluates
+ *     readiness once.
  *   - LOCKED time — wall time observed under a fresh foreign lock held by a live
  *     pid — is bounded SEPARATELY by `lockWaitMs` (default the lock contract's own
  *     10-minute staleness window) and does NOT consume the settle budget. When
@@ -882,7 +899,7 @@ export async function waitForInstallTreeSettled(args) {
     const staleProbeMs = Math.max(0, args.staleProbeMs ?? DEFAULT_INSTALL_TREE_STALE_PROBE_MS);
     const start = now();
     let lastActivitySnapshot = installTreeActivitySignature(args.target, args.packageRoot, fs);
-    let staleObservationStartedAt = lastActivitySnapshot.observed ? start : null;
+    let staleObservationStartedAt = canProbeUnsettledRetiredSibling(lastActivitySnapshot) ? start : null;
     let sawTreeChange = false;
     let readySince = null;
     let sawLock = false;
@@ -909,16 +926,18 @@ export async function waitForInstallTreeSettled(args) {
         }
         if (!sawTreeChange) {
             const activitySnapshot = installTreeActivitySignature(args.target, args.packageRoot, fs);
-            if (!activitySnapshot.observed) {
+            const previousCanProbe = canProbeUnsettledRetiredSibling(lastActivitySnapshot);
+            const currentCanProbe = canProbeUnsettledRetiredSibling(activitySnapshot);
+            if (previousCanProbe && currentCanProbe && activitySnapshot.value !== lastActivitySnapshot.value) {
+                sawTreeChange = true;
                 staleObservationStartedAt = null;
             }
-            else if (!lastActivitySnapshot.observed) {
-                staleObservationStartedAt = t;
-            }
-            else if (activitySnapshot.value !== lastActivitySnapshot.value) {
-                sawTreeChange = true;
+            else if (!currentCanProbe) {
                 staleObservationStartedAt = null;
             }
+            else if (!previousCanProbe) {
+                staleObservationStartedAt = t;
+            }
             lastActivitySnapshot = activitySnapshot;
         }
         let retiredPresent = null;
@@ -985,8 +1004,9 @@ export async function waitForInstallTreeSettled(args) {
                 lockedMs,
                 lockTool,
                 sawTreeChange,
-                staleTree: true,
+                staleTree: lastActivitySnapshot.observed,
                 retiredSiblingPresent: retiredPresent,
+                retiredSiblingUnverified: !lastActivitySnapshot.observed && lastActivitySnapshot.retiredSiblingPresent === true,
             };
         }
         // Give up when the TREE has had a full unlocked budget with no writer visible,
@@ -1176,6 +1196,10 @@ export const INSTALL_TREE_STALE_REMEDY = "hq-cli's install tree is incomplete an
     "Reinstall with `npm install -g @indigoai-us/hq-cli@latest` " +
     "(or `pnpm add -g @indigoai-us/hq-cli@latest` / `bun add -g @indigoai-us/hq-cli@latest` " +
     "when that manager owns your install), then run the command again.";
+/** Guidance when a retired package sibling's activity could not be verified. */
+export const INSTALL_TREE_RETIRED_UNVERIFIED_REMEDY = "hq-cli found a retired install sibling but could not verify whether an installer is still using it. Wait for any npm or desktop CLI update to finish, then run the command again. If no install is running, repair with `npm install -g @indigoai-us/hq-cli@latest` " +
+    "(or `pnpm add -g @indigoai-us/hq-cli@latest` / `bun add -g @indigoai-us/hq-cli@latest` " +
+    "when that manager owns your install).";
 /**
  * The fixed, input-free remedy for the 'lock-held' outcome: a cooperating writer
  * held the shared update lock past its own staleness ceiling. Telling the user to
@@ -1198,7 +1222,9 @@ export function installTreeTornStderrLine(err) {
         ? INSTALL_TREE_LOCK_HELD_REMEDY
         : err.diagnostics.outcome === "stale_tree"
             ? INSTALL_TREE_STALE_REMEDY
-            : INSTALL_TREE_TORN_REMEDY;
+            : err.diagnostics.outcome === "retired_unverified"
+                ? INSTALL_TREE_RETIRED_UNVERIFIED_REMEDY
+                : INSTALL_TREE_TORN_REMEDY;
     const specifier = err.diagnostics.specifier;
     return specifier ? `${remedy} (missing: ${specifier})` : remedy;
 }

package/dist/utils/sentry-fingerprint.js

@@ -189,6 +189,7 @@ const KNOWN_INSTALL_TREE_OUTCOMES = new Set([
     "reexec-failed",
     "lock-held",
     "stale_tree",
+    "retired_unverified",
 ]);
 function installTreeRecoveryOutcomeTag(value) {
     return typeof value === "string" && KNOWN_INSTALL_TREE_OUTCOMES.has(value)

package/package.json

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