@indigoai-us/hq-cli 5.50.1 → 5.51.0

package/dist/commands/secrets.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3049e431-c5db-5430-90fe-82866c35e95b")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="96461f1a-6d5b-5dc0-b00a-0a9fa30a0dad")}catch(e){}}();
 import chalk from "chalk";
 import * as readline from "node:readline";
 import { spawn } from "node:child_process";
@@ -8,6 +8,7 @@ import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { DEFAULT_SECRETS_CACHE_TTL_MS, readCache, writeCache, removeCacheEntry, clearAllCache, } from "../utils/secrets-cache.js";
 import { computeSha256 } from "../utils/integrity.js";
 import { SECRET_NAME_PATTERN, GROUP_ID_PATTERN } from "./_patterns.js";
+import { describeSecretsScope, formatSecretSaved, formatSecretsListEmpty, formatSecretsListHeader, } from "./secrets-scope.js";
 import { vaultApiFetch, getCompanyUid, getEntityUid, } from "../utils/vault-api.js";
 export { vaultApiFetch, getCompanyUid, getEntityUid };
 function scopeOpts(opts) {
@@ -344,7 +345,13 @@ export function registerSecretsCommand(program) {
                 process.exit(1);
             }
             const token = await ensureCognitoToken();
-            const companyUid = await getEntityUid(token, scopeOpts(secrets.opts()));
+            const scope = scopeOpts(secrets.opts());
+            const companyUid = await getEntityUid(token, scope);
+            const scopeLabel = describeSecretsScope({
+                personal: scope.personal,
+                companySlug: scope.companySlug,
+                companyUid,
+            });
             const res = await vaultApiFetch({
                 token,
                 path: `/secrets/${encodeURIComponent(companyUid)}`,
@@ -357,7 +364,7 @@ export function registerSecretsCommand(program) {
                 process.exit(1);
             }
             removeCacheEntry(companyUid, name);
-            console.log(chalk.green(`Secret '${name}' saved.`));
+            console.log(chalk.green(formatSecretSaved(name, scopeLabel)));
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
@@ -487,7 +494,13 @@ export function registerSecretsCommand(program) {
                 normalizedPrefix = normalized;
             }
             const token = await ensureCognitoToken();
-            const companyUid = await getEntityUid(token, scopeOpts(secrets.opts()));
+            const scope = scopeOpts(secrets.opts());
+            const companyUid = await getEntityUid(token, scope);
+            const scopeLabel = describeSecretsScope({
+                personal: scope.personal,
+                companySlug: scope.companySlug,
+                companyUid,
+            });
             const query = {};
             if (normalizedPrefix) {
                 query.prefix = normalizedPrefix;
@@ -504,7 +517,7 @@ export function registerSecretsCommand(program) {
             }
             const data = (await res.json());
             if (data.secrets.length === 0) {
-                console.log(chalk.dim("No secrets found."));
+                console.log(chalk.dim(formatSecretsListEmpty(scopeLabel)));
                 return;
             }
             const nameWidth = Math.max(4, ...data.secrets.map((s) => s.name.length));
@@ -514,6 +527,7 @@ export function registerSecretsCommand(program) {
             if (hasPermission) {
                 const accessWidth = Math.max(6, ...data.secrets.map((s) => (s.permission ?? "-").length));
                 const header = `${"NAME".padEnd(nameWidth)}  ${"ACCESS".padEnd(accessWidth)}  ${"TIER".padEnd(tierWidth)}  ${"SCRIPT LOCK".padEnd(scriptLockWidth)}  LAST MODIFIED`;
+                console.log(chalk.dim(formatSecretsListHeader(scopeLabel)));
                 console.log(chalk.bold(header));
                 for (const s of data.secrets) {
                     const access = s.permission ?? "-";
@@ -525,6 +539,7 @@ export function registerSecretsCommand(program) {
             }
             else {
                 const header = `${"NAME".padEnd(nameWidth)}  ${"TIER".padEnd(tierWidth)}  ${"SCRIPT LOCK".padEnd(scriptLockWidth)}  LAST MODIFIED`;
+                console.log(chalk.dim(formatSecretsListHeader(scopeLabel)));
                 console.log(chalk.bold(header));
                 for (const s of data.secrets) {
                     const tier = normalizeSecretTier(s.tier);
@@ -1148,4 +1163,4 @@ export function registerSecretsCommand(program) {
     });
 }
 //# sourceMappingURL=secrets.js.map
-//# debugId=3049e431-c5db-5430-90fe-82866c35e95b
+//# debugId=96461f1a-6d5b-5dc0-b00a-0a9fa30a0dad

package/dist/index.d.ts

@@ -2,5 +2,5 @@
 /**
  * HQ CLI - Module management, package management, and cloud sync for HQ
  */
-export {};
+import "./node-preflight.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,8 +2,11 @@
 /**
  * HQ CLI - Module management, package management, and cloud sync for HQ
  */
+// MUST be first: guard the Node version before any dependency that needs a
+// Node 20+ API (e.g. util.styleText) or a newer native ABI is evaluated.
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="34e9e978-4c0a-5113-82af-9a33e30686c6")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="82c44c14-a953-5644-9bf2-dd2c6d487d63")}catch(e){}}();
+import "./node-preflight.js";
 import { Command } from "commander";
 import { initSentry, Sentry } from "./sentry.js";
 import { registerAddCommand } from "./commands/add.js";
@@ -47,12 +50,18 @@ import { registerRescueCommand } from "./commands/rescue.js";
 import { registerMcpCommand } from "./commands/mcp-status.js";
 import { sanitizeArgv } from "./utils/feedback-diagnostics.js";
 import { environmentalFsErrorMessage } from "./utils/environmental-error.js";
+import { isEpipe } from "./utils/epipe.js";
+import { isInterceptedProcessExit } from "./utils/intercepted-process-exit.js";
 import { maybeWarnNewVersion, refreshVersionCache, } from "./utils/version-check.js";
 import { enforceVersionGate, shouldSkipGate, } from "./utils/version-gate.js";
 import { CLI_VERSION } from "./cli-version.js";
-// Swallow EPIPE when a downstream reader (e.g. `source <(…)`, `| head`) closes the pipe early.
+// Swallow EPIPE when a downstream reader (e.g. `source <(…)`, `| head`) closes
+// the pipe early. This covers the ASYNC path — an 'error' event emitted on the
+// stream. The SYNCHRONOUS path (a `write EPIPE` thrown straight out of
+// console.log inside a command) is handled in the top-level catch below; both
+// share `isEpipe` (HQ-6B).
 const onPipeError = (err) => {
-    if (err.code === "EPIPE") {
+    if (isEpipe(err)) {
         process.exit(0);
     }
     throw err;
@@ -182,19 +191,40 @@ registerMcpCommand(program);
         await program.parseAsync();
     }
     catch (err) {
-        // A full disk / exhausted quota / read-only filesystem is the user's
-        // machine, not an HQ code defect. Surface a clear, actionable message and
-        // skip Sentry capture so one full disk doesn't flood the tracker with
-        // identical, unfixable crash reports (HQ-CLI-2). Genuine errors still go
-        // to Sentry and still exit 1.
-        const envMsg = environmentalFsErrorMessage(err);
-        if (envMsg) {
-            process.stderr.write(`hq: ${envMsg}\n`);
+        // A broken pipe (EPIPE) means the reader of `hq`'s output closed it early
+        // (`hq … | head`, `source <(hq …)`, a parent that exited). That is normal
+        // Unix behavior with no user-facing degradation — exit cleanly (0) and
+        // skip Sentry capture instead of shipping a fatal (HQ-6B). A synchronous
+        // `write EPIPE` thrown out of console.log lands here rather than on the
+        // stream 'error' listener above.
+        if (isEpipe(err)) {
+            process.exitCode = 0;
+        }
+        else if (isInterceptedProcessExit(err)) {
+            // A security/audit FUZZ harness replaced `process.exit` with a throw so it
+            // can keep exercising the binary. Commander calling `process.exit` for
+            // normal CLI control flow (e.g. an unknown command → exit 1) then surfaces
+            // here as that synthetic marker. It is a test-harness artifact, NOT an
+            // hq-cli defect — a real user's `process.exit` just exits, so nothing is
+            // thrown or captured. Skip Sentry capture (no signal, no user-facing
+            // degradation) and preserve the intended non-zero exit (HQ-CLI-3).
+            process.exitCode = 1;
         }
         else {
-            Sentry.captureException(err);
+            // A full disk / exhausted quota / read-only filesystem is the user's
+            // machine, not an HQ code defect. Surface a clear, actionable message and
+            // skip Sentry capture so one full disk doesn't flood the tracker with
+            // identical, unfixable crash reports (HQ-CLI-2). Genuine errors still go
+            // to Sentry and still exit 1.
+            const envMsg = environmentalFsErrorMessage(err);
+            if (envMsg) {
+                process.stderr.write(`hq: ${envMsg}\n`);
+            }
+            else {
+                Sentry.captureException(err);
+            }
+            process.exitCode = 1;
         }
-        process.exitCode = 1;
     }
     finally {
         // Release health: finalize the per-run session before the flush.
@@ -203,4 +233,4 @@ registerMcpCommand(program);
     }
 })();
 //# sourceMappingURL=index.js.map
-//# debugId=34e9e978-4c0a-5113-82af-9a33e30686c6
+//# debugId=82c44c14-a953-5644-9bf2-dd2c6d487d63

package/dist/node-preflight.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Runtime Node.js version guard for the hq CLI.
+ *
+ * HQ tooling requires Node.js 20 or newer. On older runtimes (notably Node 18)
+ * the CLI dies with cryptic failures long before reaching any of its own code:
+ * a native-module ABI mismatch from a prebuilt dependency, and a missing
+ * `util.styleText` (added in Node 20). Those errors give the user no hint that
+ * the real problem is just an old Node.
+ *
+ * This module exists to fail fast with an actionable message instead. It is
+ * imported FIRST by every CLI entry point (`index.ts`, `bin/hq-auth-refresh.ts`)
+ * so the check runs before commander, Sentry, or any dependency that needs a
+ * Node 20+ API or a newer native ABI is evaluated. ES modules evaluate their
+ * imports in source order, so as long as this is the first import in the entry
+ * module, the guard short-circuits an unsupported runtime cleanly.
+ *
+ * Keep this file dependency-free — it must not import anything that could itself
+ * fail to load on the very runtime it is trying to detect.
+ */
+export declare const MIN_NODE_MAJOR = 20;
+export interface NodeVersionCheck {
+    ok: boolean;
+    major: number;
+    message?: string;
+}
+/**
+ * Pure check: is the given Node version string (e.g. "18.19.0") supported?
+ * Defaults to the running runtime's version. An unparseable version is treated
+ * as supported so we never block a user on a version string we can't read.
+ */
+export declare function checkNodeVersion(versionString?: string): NodeVersionCheck;
+/**
+ * Side-effecting guard run on import: prints the upgrade message to stderr and
+ * exits 1 on an unsupported runtime. A no-op on Node 20+. Set
+ * `HQ_SKIP_NODE_PREFLIGHT=1` to bypass (used by the test runner, which already
+ * runs on a supported Node).
+ */
+export declare function enforceNodeVersion(): void;
+//# sourceMappingURL=node-preflight.d.ts.map

package/dist/node-preflight.js

@@ -0,0 +1,55 @@
+/**
+ * Runtime Node.js version guard for the hq CLI.
+ *
+ * HQ tooling requires Node.js 20 or newer. On older runtimes (notably Node 18)
+ * the CLI dies with cryptic failures long before reaching any of its own code:
+ * a native-module ABI mismatch from a prebuilt dependency, and a missing
+ * `util.styleText` (added in Node 20). Those errors give the user no hint that
+ * the real problem is just an old Node.
+ *
+ * This module exists to fail fast with an actionable message instead. It is
+ * imported FIRST by every CLI entry point (`index.ts`, `bin/hq-auth-refresh.ts`)
+ * so the check runs before commander, Sentry, or any dependency that needs a
+ * Node 20+ API or a newer native ABI is evaluated. ES modules evaluate their
+ * imports in source order, so as long as this is the first import in the entry
+ * module, the guard short-circuits an unsupported runtime cleanly.
+ *
+ * Keep this file dependency-free — it must not import anything that could itself
+ * fail to load on the very runtime it is trying to detect.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7d63229d-ff96-5511-9601-53c556487763")}catch(e){}}();
+export const MIN_NODE_MAJOR = 20;
+/**
+ * Pure check: is the given Node version string (e.g. "18.19.0") supported?
+ * Defaults to the running runtime's version. An unparseable version is treated
+ * as supported so we never block a user on a version string we can't read.
+ */
+export function checkNodeVersion(versionString = process.versions.node) {
+    const major = Number.parseInt(String(versionString).split(".")[0] ?? "", 10);
+    if (!Number.isFinite(major) || major >= MIN_NODE_MAJOR) {
+        return { ok: true, major };
+    }
+    const message = `hq requires Node.js ${MIN_NODE_MAJOR} or newer — you are running Node ${versionString}.\n` +
+        `Older versions fail with native-module ABI mismatches and missing APIs.\n` +
+        `Please upgrade to Node ${MIN_NODE_MAJOR}+ (https://nodejs.org/) and run hq again.`;
+    return { ok: false, major, message };
+}
+/**
+ * Side-effecting guard run on import: prints the upgrade message to stderr and
+ * exits 1 on an unsupported runtime. A no-op on Node 20+. Set
+ * `HQ_SKIP_NODE_PREFLIGHT=1` to bypass (used by the test runner, which already
+ * runs on a supported Node).
+ */
+export function enforceNodeVersion() {
+    if (process.env.HQ_SKIP_NODE_PREFLIGHT)
+        return;
+    const result = checkNodeVersion();
+    if (!result.ok && result.message) {
+        process.stderr.write(`${result.message}\n`);
+        process.exit(1);
+    }
+}
+enforceNodeVersion();
+//# sourceMappingURL=node-preflight.js.map
+//# debugId=7d63229d-ff96-5511-9601-53c556487763

package/dist/sentry.d.ts

@@ -1,4 +1,16 @@
 import * as Sentry from "@sentry/node";
+import type { ErrorEvent, EventHint } from "@sentry/node";
+/**
+ * Drop broken-pipe (EPIPE) crashes before scrubbing/send. A closed downstream
+ * reader (`hq … | head`, `source <(hq …)`, a parent that exited) is normal
+ * Unix behavior with no user-facing degradation — never a defect to report.
+ * This is the path-independent catch-all for HQ-6B: whichever way an EPIPE
+ * surfaces (a synchronous throw into the command catch, an async stream
+ * 'error', or a write outside the top-level try), it never ships a fatal. The
+ * clean-exit handlers in index.ts still keep exit code 0 for the common paths.
+ * Consistent with the swallow-EPIPE posture established in #138.
+ */
+export declare function epipeAwareBeforeSend(event: ErrorEvent, hint: EventHint): ErrorEvent | null;
 export declare function initSentry(): void;
 export { Sentry };
 //# sourceMappingURL=sentry.d.ts.map

package/dist/sentry.js

@@ -1,11 +1,27 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a260ea42-f6d8-52d0-90c6-6e586de5efd6")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a2ba6d5a-af8a-5512-9ce8-ced925ad5505")}catch(e){}}();
 import * as Sentry from "@sentry/node";
 import { BUNDLED_DSN } from "./sentry-dsn.generated.js";
 import { beforeSend } from "./sentry-before-send.js";
 import { beforeBreadcrumb } from "./utils/breadcrumb-buffer.js";
 import { CLI_VERSION } from "./cli-version.js";
 import { getCachedSentryUser } from "./utils/sentry-identity.js";
+import { isEpipe } from "./utils/epipe.js";
+/**
+ * Drop broken-pipe (EPIPE) crashes before scrubbing/send. A closed downstream
+ * reader (`hq … | head`, `source <(hq …)`, a parent that exited) is normal
+ * Unix behavior with no user-facing degradation — never a defect to report.
+ * This is the path-independent catch-all for HQ-6B: whichever way an EPIPE
+ * surfaces (a synchronous throw into the command catch, an async stream
+ * 'error', or a write outside the top-level try), it never ships a fatal. The
+ * clean-exit handlers in index.ts still keep exit code 0 for the common paths.
+ * Consistent with the swallow-EPIPE posture established in #138.
+ */
+export function epipeAwareBeforeSend(event, hint) {
+    if (isEpipe(hint?.originalException))
+        return null;
+    return beforeSend(event, hint);
+}
 export function initSentry() {
     const dsn = BUNDLED_DSN || process.env.SENTRY_DSN;
     if (!dsn)
@@ -20,7 +36,7 @@ export function initSentry() {
         initialScope: {
             tags: { repo: "hq-cli" },
         },
-        beforeSend,
+        beforeSend: epipeAwareBeforeSend,
         beforeBreadcrumb,
     });
     // Attribute events to the logged-in HQ identity (best-effort; null when not
@@ -35,4 +51,4 @@ export function initSentry() {
 }
 export { Sentry };
 //# sourceMappingURL=sentry.js.map
-//# debugId=a260ea42-f6d8-52d0-90c6-6e586de5efd6
+//# debugId=a2ba6d5a-af8a-5512-9ce8-ced925ad5505

package/dist/types.d.ts

@@ -75,13 +75,31 @@ export interface PackAuthor {
     handle: string;
     displayName: string;
 }
+/**
+ * A pack-to-pack dependency (M0). OPTIONAL and backwards-compatible — packs
+ * published before this field omit `requires.packs` and install unchanged. When
+ * present, each entry names another content pack that MUST already be installed
+ * before this one (enforced at install time by `assertPackDependencies`, which
+ * tracks installed packs by FILESYSTEM PRESENCE — not `modules.yaml`). `version`
+ * is an optional semver RANGE the installed dependency must satisfy.
+ */
+export interface PackDependency {
+    name: string;
+    version?: string;
+}
 export interface PackManifest {
     name: string;
     version: string;
     publisher: string;
     access: 'public' | 'private';
+    /**
+     * Host + pack prerequisites. `hqCore` is a required semver RANGE the host HQ
+     * must satisfy. `packs` (M0) is an OPTIONAL list of other content packs that
+     * must be installed first — see PackDependency.
+     */
     requires: {
         hqCore: string;
+        packs?: PackDependency[];
     };
     contributes: Partial<Record<PackContributeKey, string[]>>;
     description?: string;

package/dist/utils/epipe.d.ts

@@ -0,0 +1,8 @@
+/**
+ * True when `err` is a Node EPIPE error — the pipe `hq` was writing to was
+ * closed by its reader. Callers should treat this as a clean, expected exit
+ * (code 0) and SKIP Sentry capture: there is no defect and no user-facing
+ * degradation to fix.
+ */
+export declare function isEpipe(err: unknown): boolean;
+//# sourceMappingURL=epipe.d.ts.map

package/dist/utils/epipe.js

@@ -0,0 +1,30 @@
+// src/utils/epipe.ts
+//
+// Classify the "broken pipe" (EPIPE) error: a downstream reader closed the
+// pipe before the CLI finished writing to stdout/stderr. This is normal,
+// expected Unix behavior — `hq … | head`, `source <(hq …)`, or a parent
+// process that exits while `hq` is still printing — NOT an HQ code defect.
+//
+// HQ-6B: a synchronous `write EPIPE` thrown from `console.log` (the Sentry
+// console-instrumentation wraps it) propagated out of an awaited command into
+// the CLI's top-level `catch`, which captured it via `Sentry.captureException`
+// and shipped a fatal — even though the only thing that happened is the
+// consumer of `hq`'s output went away. The async path (an emitted stream
+// 'error' event) was already handled by the stdout/stderr listeners in
+// index.ts; this predicate closes the synchronous-throw path too, mirroring
+// the environmental-error carve-out (HQ-CLI-2).
+/**
+ * True when `err` is a Node EPIPE error — the pipe `hq` was writing to was
+ * closed by its reader. Callers should treat this as a clean, expected exit
+ * (code 0) and SKIP Sentry capture: there is no defect and no user-facing
+ * degradation to fix.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3305e402-0237-55ac-a6d4-11143bc69b83")}catch(e){}}();
+export function isEpipe(err) {
+    return (typeof err === "object" &&
+        err !== null &&
+        err.code === "EPIPE");
+}
+//# sourceMappingURL=epipe.js.map
+//# debugId=3305e402-0237-55ac-a6d4-11143bc69b83

package/dist/utils/intercepted-process-exit.d.ts

@@ -0,0 +1,7 @@
+/**
+ * True when `err` is a fuzz/audit harness's intercepted-`process.exit` marker
+ * rather than a genuine fault. Callers should SKIP Sentry capture (no defect, no
+ * user-facing degradation) while preserving the intended exit code.
+ */
+export declare function isInterceptedProcessExit(err: unknown): boolean;
+//# sourceMappingURL=intercepted-process-exit.d.ts.map

package/dist/utils/intercepted-process-exit.js

@@ -0,0 +1,38 @@
+// src/utils/intercepted-process-exit.ts
+//
+// Classify the "intercepted process.exit" synthetic error (HQ-CLI-3).
+//
+// Security/audit FUZZ harnesses (e.g. `/opt/audit/fuzz-exports.js`) monkey-patch
+// `process.exit` to THROW a marker instead of actually terminating, so the
+// fuzzer can keep exercising a binary's entrypoints. When such a harness drives
+// `hq` (e.g. `hq <unknown-command>`), commander legitimately calls
+// `process.exit(1)` — and the patched exit turns that normal CLI control-flow
+// into a thrown `Error: fuzz-intercepted-process-exit` that propagates out of
+// `program.parseAsync()` into the CLI's top-level catch, which then shipped it to
+// Sentry as a fatal.
+//
+// This is a test-harness artifact, NOT an hq-cli defect: a real user's
+// `process.exit` exits the process and nothing is ever thrown or captured.
+// There is no user-facing degradation to fix, so the top-level catch skips
+// Sentry capture for it — the genuine "expected, non-actionable" carve-out,
+// mirroring the EPIPE (HQ-6B) and environmental-FS (HQ-CLI-2) carve-outs.
+/** The marker a fuzz/audit harness throws in place of a real `process.exit`. */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="55c7e3b5-a8bc-50fd-835b-127a19172aa1")}catch(e){}}();
+const INTERCEPTED_PROCESS_EXIT_MARKER = "fuzz-intercepted-process-exit";
+/**
+ * True when `err` is a fuzz/audit harness's intercepted-`process.exit` marker
+ * rather than a genuine fault. Callers should SKIP Sentry capture (no defect, no
+ * user-facing degradation) while preserving the intended exit code.
+ */
+export function isInterceptedProcessExit(err) {
+    if (typeof err === "object" && err !== null) {
+        const message = err.message;
+        if (typeof message === "string" && message.includes(INTERCEPTED_PROCESS_EXIT_MARKER)) {
+            return true;
+        }
+    }
+    return typeof err === "string" && err.includes(INTERCEPTED_PROCESS_EXIT_MARKER);
+}
+//# sourceMappingURL=intercepted-process-exit.js.map
+//# debugId=55c7e3b5-a8bc-50fd-835b-127a19172aa1

package/dist/utils/pack-contributions.d.ts

@@ -100,6 +100,13 @@ export declare function readPackManifest(packDir: string): {
  * of truth for installed content packs.
  */
 export declare function listInstalledPacks(hqRoot: string): InstalledPack[];
+/**
+ * Installed packs that declare `name` in their `requires.packs` (M0). Pure over
+ * the supplied list — the uninstall dependents guard calls this with
+ * `listInstalledPacks(hqRoot)`. Excludes the pack named `name` itself, so a
+ * self-reference never counts as its own dependent.
+ */
+export declare function findDependentPacks(installed: InstalledPack[], name: string): InstalledPack[];
 export interface UnwireResult {
     unlinked: Array<{
         key: PackContributeKey;

package/dist/utils/pack-contributions.js

@@ -37,7 +37,7 @@
  *     `merge` rows -- they never produce a symlink.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6cc0fc56-5a1c-5ce8-96d4-652805e508f8")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="63e778df-65dd-51a4-8a43-3a7d2aa9a451")}catch(e){}}();
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'js-yaml';
@@ -213,6 +213,16 @@ export function listInstalledPacks(hqRoot) {
     }
     return out;
 }
+/**
+ * Installed packs that declare `name` in their `requires.packs` (M0). Pure over
+ * the supplied list — the uninstall dependents guard calls this with
+ * `listInstalledPacks(hqRoot)`. Excludes the pack named `name` itself, so a
+ * self-reference never counts as its own dependent.
+ */
+export function findDependentPacks(installed, name) {
+    return installed.filter((p) => p.name !== name &&
+        (p.manifest?.requires?.packs ?? []).some((d) => d.name === name));
+}
 /**
  * Remove only the host symlinks that resolve into THIS pack's directory
  * (status `live` or `broken`). Foreign links and real files are left in place
@@ -318,4 +328,4 @@ export function readRecommendedPackages(hqRoot) {
     }
 }
 //# sourceMappingURL=pack-contributions.js.map
-//# debugId=6cc0fc56-5a1c-5ce8-96d4-652805e508f8
+//# debugId=63e778df-65dd-51a4-8a43-3a7d2aa9a451

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

@@ -27,16 +27,49 @@
  * Opt-out: `HQ_NO_UPDATE_CHECK=1` (same env as `version-check.ts` — one knob
  * to silence both check + gate).
  */
+interface VersionCheckResponse {
+    clientId: string;
+    currentVersion: string;
+    minVersion: string;
+    latestVersion: string;
+    updateRequired: boolean;
+    updateRecommended: boolean;
+    updateCommand?: string;
+    downloadUrl?: string;
+    message?: string;
+}
+export declare function npmPrefixFromPackageDir(pkgDir: string): string | null;
+export declare function resolveRunningPrefix(): string | null;
+export declare function buildPrefixedInstallArgv(prefix: string): string[];
 /**
  * Run the upgrade command in a blocking subprocess. Inherits stdio so the
  * user sees the npm progress. We do NOT auto-rerun the CLI on completion —
  * 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.
  */
-declare function performUpdate(command: string): {
+type UpdateResult = {
     ok: boolean;
     detail?: string;
 };
+type UpdateRunner = (cmd: string, args: string[]) => UpdateResult;
+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;
+/**
+ * Hard enforcement when the server says we're below `minVersion`. Print a
+ * red banner, attempt the update, then exit so the user reruns against the
+ * fresh binary. Sequence chosen so a user with a broken `npm` global prefix
+ * still gets a clear error rather than an opaque silent failure.
+ *
+ * Exit codes:
+ *   0 — update succeeded; user must rerun their command
+ *   75 — update failed (EX_TEMPFAIL; common for sudo/EACCES on system npm)
+ */
+declare function enforceUpdateRequired(decision: VersionCheckResponse, deps?: {
+    performUpdateString?: (command: string) => UpdateResult;
+    resolvePrefix?: () => string | null;
+    runner?: UpdateRunner;
+}): never;
 /**
  * Public entry point. Call before commander parses argv. Blocks the CLI on
  * network IO for up to FETCH_TIMEOUT_MS — acceptable because the alternative
@@ -58,7 +91,13 @@ export declare const __test__: {
     CLIENT_ID: string;
     ENDPOINT_PATH: string;
     FETCH_TIMEOUT_MS: number;
+    buildPrefixedInstallArgv: typeof buildPrefixedInstallArgv;
+    enforceUpdateRequired: typeof enforceUpdateRequired;
+    npmPrefixFromPackageDir: typeof npmPrefixFromPackageDir;
     performUpdate: typeof performUpdate;
+    performUpdateCommand: typeof performUpdateCommand;
+    runUpdateCommand: typeof runUpdateCommand;
+    resolveRunningPrefix: typeof resolveRunningPrefix;
 };
 export {};
 //# sourceMappingURL=version-gate.d.ts.map