@indigoai-us/hq-cli 5.202.1 → 5.203.0

package/dist/main.js

@@ -53,6 +53,7 @@ import { registerCommandsWithRecovery } from "./startup-registration.js";
 import { installTreeTornCaptureContext, installTreeTornStderrLine, isInstallTreeTornError, } from "./utils/install-tree-torn.js";
 import { isVaultAccessDeniedError, vaultAccessDeniedMessage, } from "./utils/vault-access-denied-error.js";
 import { fallbackOperatorMessage, unexpectedCliErrorMessage } from "./utils/unexpected-cli-error.js";
+import { runGlobalNetworkLifecycle } from "./utils/cli-network-lifecycle.js";
 /**
  * Total time one CLI invocation may await foreground network work. This spans
  * the hard version decision, pre-action observability, and release-health
@@ -152,7 +153,7 @@ export function handleStreamError(err, deps = defaultStreamErrorDependencies) {
 }
 process.stdout.on("error", (err) => handleStreamError(err));
 process.stderr.on("error", (err) => handleStreamError(err));
-initSentry();
+runGlobalNetworkLifecycle(process.argv, () => initSentry());
 const program = new Command();
 program
     .name("hq")
@@ -166,13 +167,15 @@ program.hook("preAction", async () => {
     // regardless, because the timer cannot be serviced while the event loop is
     // blocked. Keep anything added here asynchronous, or separately cheap: this
     // hook is on the path of EVERY hq command.
-    const budget = activeForegroundNetworkBudget;
-    if (!budget)
-        return;
-    await budget.waitFor(OBSERVABILITY_FOREGROUND_WAIT_MS, FINALIZATION_FOREGROUND_WAIT_MS, (timeoutMs) => Promise.all([
-        emitCliSessionStarted(timeoutMs),
-        reportCliClientHealthInvocation({ timeoutMs }),
-    ]));
+    await runGlobalNetworkLifecycle(process.argv, async () => {
+        const budget = activeForegroundNetworkBudget;
+        if (!budget)
+            return;
+        await budget.waitFor(OBSERVABILITY_FOREGROUND_WAIT_MS, FINALIZATION_FOREGROUND_WAIT_MS, (timeoutMs) => Promise.all([
+            emitCliSessionStarted(timeoutMs),
+            reportCliClientHealthInvocation({ timeoutMs }),
+        ]));
+    });
 });
 export async function runCli() {
     const foregroundNetworkBudget = new ForegroundNetworkBudget();
@@ -180,17 +183,19 @@ export async function runCli() {
     // Begin one registry refresh without awaiting it. Every command gate reads
     // only the client's held snapshot and falls back locally, so an offline or
     // slow registry cannot delay command parsing or alter a command failure.
-    void kickFlagRegistryReadiness();
+    runGlobalNetworkLifecycle(process.argv, () => {
+        void kickFlagRegistryReadiness();
+    });
     // 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({
+        runGlobalNetworkLifecycle(process.argv, () => Sentry.addBreadcrumb({
             category: "command",
             message: sanitizeArgv(process.argv.slice(2)).join(" "),
             level: "info",
-        });
+        }));
         // 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
@@ -204,7 +209,9 @@ export async function runCli() {
         //    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)) {
+        const versionAction = await runGlobalNetworkLifecycle(process.argv, async () => {
+            if (shouldSkipGate(process.argv))
+                return "continue";
             const gate = (await foregroundNetworkBudget.waitFor(VERSION_GATE_FOREGROUND_WAIT_MS, FINALIZATION_FOREGROUND_WAIT_MS, (timeoutMs) => enforceVersionGate(async (decision) => {
                 const outcome = await autoUpdateAndReexec(process.argv, decision.latestVersion);
                 if (outcome.action === "reexec")
@@ -212,16 +219,19 @@ export async function runCli() {
                 return outcome.action === "reexec";
             }, { timeoutMs }))) ?? "continue";
             if (gate === "reexec")
-                return;
+                return "reexec";
             const cachedLatest = staleAgainstCachedLatest();
             if (cachedLatest) {
                 const outcome = await autoUpdateAndReexec(process.argv, cachedLatest);
                 if (outcome.action === "reexec") {
                     reexecStatus = outcome.reexecStatus ?? 0;
-                    return;
+                    return "reexec";
                 }
             }
-        }
+            return "continue";
+        });
+        if (versionAction === "reexec")
+            return;
         // Register every contributor for the selected root only. Root help and
         // unknown-command recovery use generated metadata, so they keep the full
         // Commander surface without evaluating every command implementation.
@@ -256,19 +266,21 @@ export async function runCli() {
     finally {
         // Plan-limit nag (US-016): stderr-only, never throws, never touches
         // process.exitCode — safe to run after exit codes have been set.
-        emitPlanLimitNag();
-        // Release health: finalize the per-run session before the flush.
-        finishSentrySession();
-        // Neither task may turn a successful command into Node's
-        // `unsettled top-level await` exit. They are observability-only after the
-        // command has completed, so a bounded best-effort wait is the terminal
-        // lifecycle boundary for this invocation. The budget reserves this 500 ms
-        // slice even when the command itself was long-running.
-        const releaseHealthTimeoutMs = foregroundNetworkBudget.timeoutFor(FINALIZATION_FOREGROUND_WAIT_MS);
-        await settleWithin([
-            refreshVersionCache({ timeoutMs: releaseHealthTimeoutMs }),
-            Sentry.flush(releaseHealthTimeoutMs),
-        ], releaseHealthTimeoutMs);
+        await runGlobalNetworkLifecycle(process.argv, async () => {
+            emitPlanLimitNag();
+            // Release health: finalize the per-run session before the flush.
+            finishSentrySession();
+            // Neither task may turn a successful command into Node's
+            // `unsettled top-level await` exit. They are observability-only after the
+            // command has completed, so a bounded best-effort wait is the terminal
+            // lifecycle boundary for this invocation. The budget reserves this 500 ms
+            // slice even when the command itself was long-running.
+            const releaseHealthTimeoutMs = foregroundNetworkBudget.timeoutFor(FINALIZATION_FOREGROUND_WAIT_MS);
+            await settleWithin([
+                refreshVersionCache({ timeoutMs: releaseHealthTimeoutMs }),
+                Sentry.flush(releaseHealthTimeoutMs),
+            ], releaseHealthTimeoutMs);
+        });
         // 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)

package/dist/utils/cli-network-lifecycle.d.ts

@@ -0,0 +1,4 @@
+export declare function isMonitorFastPathCommand(argv: readonly string[]): boolean;
+/** Skip process-wide network lifecycle work for hooks and detached monitor supervisors. */
+export declare function runGlobalNetworkLifecycle<T>(argv: readonly string[], operation: () => T): T | undefined;
+//# sourceMappingURL=cli-network-lifecycle.d.ts.map

package/dist/utils/cli-network-lifecycle.js

@@ -0,0 +1,11 @@
+const MONITOR_HIDDEN_NETWORK_BYPASS = new Set(["drain", "wait", "enabled", "_run"]);
+export function isMonitorFastPathCommand(argv) {
+    return argv[2] === "monitor" && MONITOR_HIDDEN_NETWORK_BYPASS.has(argv[3] ?? "");
+}
+/** Skip process-wide network lifecycle work for hooks and detached monitor supervisors. */
+export function runGlobalNetworkLifecycle(argv, operation) {
+    if (isMonitorFastPathCommand(argv))
+        return undefined;
+    return operation();
+}
+//# sourceMappingURL=cli-network-lifecycle.js.map

package/package.json

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