@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/sentry.js

@@ -5,10 +5,9 @@ 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";
-import { companySkillWrapperSentryTagsFor } from "./lib/company-skill-wrapper.js";
 import { environmentalFsErrorMessage } from "./utils/environmental-error.js";
 import { incompleteInstallCaptureContext, incompleteInstallMessage, } from "./utils/incomplete-install-error.js";
-import { installTreeTornSentryTagsFor, sentryFingerprintFor, sentryMcpCollisionContextFor, } from "./utils/sentry-fingerprint.js";
+import { sentryFingerprintFor } from "./utils/sentry-fingerprint.js";
 /**
  * Drop broken-pipe (EPIPE) crashes before scrubbing/send. A closed downstream
  * reader (`hq … | head`, `source <(hq …)`, a parent that exited) is normal
@@ -20,17 +19,7 @@ import { installTreeTornSentryTagsFor, sentryFingerprintFor, sentryMcpCollisionC
  * Consistent with the swallow-EPIPE posture established in #138.
  */
 export function epipeAwareBeforeSend(event, hint) {
-    const flagRegistryWorkerEvent = isFlagRegistryWorkerEvent(event);
-    if (flagRegistryWorkerEvent) {
-        if (isExpectedFlagRegistryWorkerStartupFailure(hint?.originalException))
-            return null;
-        event.level = "warning";
-        event.tags = { ...event.tags, worker: "flag-registry" };
-        const missingFile = flagRegistryWorkerMissingFileTags(hint?.originalException, event);
-        if (missingFile)
-            event.tags = { ...event.tags, ...missingFile };
-    }
-    if (!flagRegistryWorkerEvent && isEpipe(hint?.originalException))
+    if (isEpipe(hint?.originalException))
         return null;
     // Path-independent belt for environmental filesystem failures (ENOSPC /
     // EDQUOT / EROFS — a full disk, exhausted quota, or read-only mount, e.g.
@@ -41,16 +30,14 @@ export function epipeAwareBeforeSend(event, hint) {
     // either. handleTopLevelError already prints an actionable message for the
     // boundary route; dropping the event here suppresses the fatal regardless of
     // route, while the CLI still exits non-zero. HQ-CLI-R (Sentry 7671416365).
-    if (!flagRegistryWorkerEvent && environmentalFsErrorMessage(hint?.originalException))
+    if (environmentalFsErrorMessage(hint?.originalException))
         return null;
     // Path-independent belt for an IN-PROCESS incomplete-install module-load
     // failure — hq-cli's own globally installed tree is not intact at load time
     // (HQ-CLI-1N, a CJS relative-sibling MODULE_NOT_FOUND under its bundled
     // node_modules; HQ-CLI-1Q, a CJS BARE-specifier MODULE_NOT_FOUND the requiring
     // third-party package's own manifest declares; HQ-CLI-1M, an esm-loader ENOENT
-    // for a file present at resolve and gone at read; HQ-CLI-20, its CJS loader-read
-    // twin — a bundled CJS dep gone between resolve and the loader's source read).
-    // handleTopLevelError already
+    // for a file present at resolve and gone at read). handleTopLevelError already
     // prints the reinstall remedy for the top-level route; dropping the event here
     // suppresses the fatal regardless of route — the unhandled-rejection boundary,
     // the command-level captureException sites, and bin/hq-auth-refresh —
@@ -60,10 +47,10 @@ export function epipeAwareBeforeSend(event, hint) {
     // node_modules, so an hq-cli packaging fault (a dist/ miss, or a bare miss the
     // requirer does NOT declare — a possible undeclared/peer dependency) and the
     // path-less unattributable shape are NOT dropped here and stay captured.
-    if (!flagRegistryWorkerEvent && incompleteInstallMessage(hint?.originalException))
+    if (incompleteInstallMessage(hint?.originalException))
         return null;
     // An incomplete-install shape that is NOT suppressed (a bare miss the requirer
-    // does not declare, or a path-less loader/resolver ENOENT) should still arrive
+    // does not declare, or a path-less esm-loader ENOENT) should still arrive
     // ATTRIBUTABLE on every capture route, not only the top-level boundary:
     // handleTopLevelError in main.ts is the ONLY caller of
     // incompleteInstallCaptureContext, so events reaching this hook directly — the
@@ -81,103 +68,20 @@ export function epipeAwareBeforeSend(event, hint) {
     // before the fleet scrubber — so it covers EVERY capture route (the top-level
     // boundary, the command-level captureException sites, bin/hq-auth-refresh,
     // any uncaughtException), mirroring the EPIPE and environmental-fs drops
-    // above. The typed error classifiers use closed allowlists. The Codex
-    // collision branch uses one fixed bucket and adds the validated server name
-    // only as a tag; it sends no config values or paths. Unclassifiable
-    // events retain Sentry's default grouping.
-    const mcpCollision = sentryMcpCollisionContextFor(hint?.originalException);
-    if (mcpCollision) {
-        event.tags = { ...event.tags, ...mcpCollision.tags };
-        event.fingerprint = mcpCollision.fingerprint;
-    }
-    else {
-        const fingerprint = sentryFingerprintFor(hint?.originalException);
-        if (fingerprint)
-            event.fingerprint = fingerprint;
-    }
-    const skillWrapperTags = companySkillWrapperSentryTagsFor(hint?.originalException);
-    if (skillWrapperTags) {
-        event.tags = { ...event.tags, ...skillWrapperTags };
-    }
-    const installTreeTags = installTreeTornSentryTagsFor(hint?.originalException);
-    if (installTreeTags) {
-        event.tags = { ...event.tags, ...installTreeTags };
-    }
+    // above. The classifier reads only a closed allowlist (never message/argv),
+    // and returns null for anything it cannot bound, in which case Sentry's
+    // default grouping is left untouched.
+    const fingerprint = sentryFingerprintFor(hint?.originalException);
+    if (fingerprint)
+        event.fingerprint = fingerprint;
     return beforeSend(event, hint);
 }
-function isFlagRegistryWorkerEvent(event) {
-    return event.tags?.worker === "flag-registry" && Boolean(event.exception?.values?.some((value) => value.mechanism?.type === "auto.child_process.worker_thread"));
-}
-function isExpectedFlagRegistryWorkerStartupFailure(error) {
-    if (typeof error !== "object" || error === null)
-        return false;
-    const details = error;
-    if (details.code === "ENOENT" && details.syscall === "uv_cwd") {
-        const stack = typeof details.stack === "string" ? details.stack : "";
-        return stack.includes("node:internal/main/worker_thread") && /\bat process\.cwd \(/.test(stack);
-    }
-    if (details.code !== "MODULE_NOT_FOUND" && details.code !== "ERR_MODULE_NOT_FOUND") {
-        return false;
-    }
-    const message = typeof details.message === "string" ? details.message : "";
-    const missingModule = /Cannot find module\s+['"]([^'"]+)['"]/.exec(message)?.[1];
-    if (!missingModule)
-        return false;
-    return missingModule.replaceAll("\\", "/").endsWith("/flag-registry-worker.js") ||
-        missingModule === "flag-registry-worker.js";
-}
-function flagRegistryWorkerMissingFileTags(error, event) {
-    if (typeof error !== "object" || error === null)
-        return null;
-    const details = error;
-    if (details.code !== "ENOENT" || !["open", "lstat"].includes(String(details.syscall))) {
-        return null;
-    }
-    let missingPath = typeof details.path === "string" ? details.path : "";
-    if (!missingPath && typeof details.message === "string") {
-        missingPath = /\b(?:open|lstat)\s+['"]([^'"]+)['"]/.exec(details.message)?.[1] ?? "";
-    }
-    const basename = missingPath.replaceAll("\\", "/").split("/").at(-1) ?? "";
-    if (!basename)
-        return null;
-    const normalizedPath = missingPath.replaceAll("\\", "/");
-    const role = basename === "flag-registry-worker.js"
-        ? "worker_entry"
-        : normalizedPath.includes("/node_modules/")
-            ? "dependency"
-            : "other";
-    const eventText = [
-        event.message,
-        ...(event.exception?.values?.map((value) => value.value) ?? []),
-    ].filter((value) => typeof value === "string").join("\n");
-    const pathVisibility = eventText.includes(missingPath)
-        ? "full_path"
-        : eventText.includes(basename)
-            ? "basename_only"
-            : "omitted";
-    return {
-        flag_worker_load_failure: "1",
-        flag_worker_missing_basename: basename,
-        flag_worker_missing_file_role: role,
-        flag_worker_path_in_event: pathVisibility,
-        // The HQ beforeSend scrubber redacts credentials but does not strip paths.
-        flag_worker_path_scrubbed_by_hq_cli: "no",
-    };
-}
-/**
- * Tests substitute only the transport so the real SDK lifecycle can be
- * exercised without an ingest request. Production callers pass nothing.
- */
-export function initSentry(overrides = {}) {
+export function initSentry() {
     const dsn = BUNDLED_DSN || process.env.SENTRY_DSN;
     if (!dsn)
         return;
     Sentry.init({
         dsn,
-        // import-in-the-middle's async ESM loader makes every later CLI import
-        // substantially slower. Keep HQ's explicit breadcrumbs, but give up
-        // automatic ESM third-party instrumentation (its spans/breadcrumbs).
-        registerEsmLoaderHooks: false,
         // CLI_VERSION reads package.json at runtime; npm_package_version is only
         // set under `npm run`, so an installed `hq` binary would always report
         // 0.0.0 and never match the uploaded source maps.
@@ -188,10 +92,6 @@ export function initSentry(overrides = {}) {
         },
         beforeSend: epipeAwareBeforeSend,
         beforeBreadcrumb,
-        // HQ owns this short-lived CLI session explicitly below and closes it from
-        // main.ts. Leaving the SDK default enabled starts a competing session.
-        integrations: (defaults) => defaults.filter((integration) => integration.name !== "ProcessSession"),
-        ...overrides,
     });
     // Attribute events to the logged-in HQ identity (best-effort; null when not
     // logged in). A CLI process is one user, so global setUser is correct here.
@@ -203,9 +103,5 @@ export function initSentry(overrides = {}) {
     // "errored", so crash-free numbers per release stay accurate.
     Sentry.startSession();
 }
-/** Finish HQ's one per-invocation release-health session. */
-export function finishSentrySession() {
-    Sentry.endSession();
-}
 export { Sentry };
 //# sourceMappingURL=sentry.js.map

package/dist/startup-registration.d.ts

@@ -16,15 +16,13 @@
  * style of handleTopLevelError so the whole seam is unit-testable without real
  * spawns, waits, or a real install tree.
  */
-import { type InstallRewriteSignalArgs, type WaitForInstallTreeSettledArgs, type WaitForInstallTreeSettledResult } from "./utils/install-tree-torn.js";
+import { type WaitForInstallTreeSettledArgs, type WaitForInstallTreeSettledResult } from "./utils/install-tree-torn.js";
 /**
  * Set on the re-exec'd child so it can NEVER wait or re-exec again — distinct
  * from self-update's HQ_RESCUE_SELF_UPDATED so the two recovery paths cannot
  * shadow each other.
  */
 export declare const INSTALL_TREE_RECOVERY_GUARD_ENV = "HQ_INSTALL_TREE_RECOVERED";
-/** Carries the writer-state observed by the parent into the guarded re-exec. */
-export declare const INSTALL_TREE_RECOVERY_TREE_STATE_ENV = "HQ_INSTALL_TREE_RECOVERY_TREE_STATE";
 /** Operator override for the settle wait's deadline. */
 export declare const INSTALL_SETTLE_TIMEOUT_ENV = "HQ_INSTALL_SETTLE_TIMEOUT_MS";
 /** Default settle deadline (ms). Overridable by {@link INSTALL_SETTLE_TIMEOUT_ENV}. */
@@ -34,27 +32,9 @@ export declare const DEFAULT_INSTALL_SETTLE_TIMEOUT_MS = 90000;
  * actually happens. It tells a human why the command paused and is the e2e's
  * synchronization point; it is never a remedy and never sets an error exit code.
  */
-export declare const INSTALL_TREE_WAIT_NOTICE = "hq: checking whether the hq-cli install tree is still changing before retrying\u2026";
+export declare const INSTALL_TREE_WAIT_NOTICE = "hq: the hq-cli install is being updated underneath this command; waiting for it to finish\u2026";
 /** Resolve the settle deadline from the environment (0 = evaluate once; default on invalid). */
 export declare function resolveSettleTimeoutMs(env: NodeJS.ProcessEnv): number;
-/** Operator override for the settle wait's LOCK ceiling (time under a live writer). */
-export declare const INSTALL_SETTLE_LOCK_TIMEOUT_ENV = "HQ_INSTALL_SETTLE_LOCK_TIMEOUT_MS";
-/**
- * Default ceiling (ms) on the time the settle wait spends under a fresh foreign
- * lock held by a live cooperating writer — the update-lock contract's own
- * staleness window. Overridable by {@link INSTALL_SETTLE_LOCK_TIMEOUT_ENV}.
- */
-export declare const DEFAULT_INSTALL_SETTLE_LOCK_TIMEOUT_MS: number;
-/**
- * The single dim line emitted once when the wait continues PAST the settle
- * deadline because a live updater still holds the shared install lock — so a human
- * knows the pause is a running update, not a hang. Never a remedy, never an exit
- * code; worded distinctly from {@link INSTALL_TREE_WAIT_NOTICE} so the e2e can
- * synchronize on it.
- */
-export declare const INSTALL_TREE_LOCK_WAIT_NOTICE = "hq: another hq updater is still installing hq-cli; waiting for it to finish\u2026";
-/** Resolve the lock ceiling from the environment (0 = do not extend; default on invalid). */
-export declare function resolveSettleLockTimeoutMs(env: NodeJS.ProcessEnv): number;
 /** Minimal view of a `spawnSync` result the seam relies on. */
 export interface RecoverySpawnResult {
     status: number | null;
@@ -68,12 +48,8 @@ export interface RegisterRecoveryDeps {
     resolveInstall?: () => {
         packageRoot: string | null;
     };
-    /** Filesystem-free fallback root for the torn window (defaults to stringDerivedPackageRoot). */
-    deriveInstallRoot?: () => string | null;
     lockPath?: () => string;
     waitForSettled?: (args: WaitForInstallTreeSettledArgs) => Promise<WaitForInstallTreeSettledResult>;
-    /** Positive writer-signal probe for the eval-throw gate (defaults to installRewriteInProgress). */
-    rewriteInProgress?: (args: InstallRewriteSignalArgs) => boolean;
     /** node flags to forward to the re-exec child (defaults to process.execArgv). */
     execArgv?: readonly string[];
 }

package/dist/startup-registration.js

@@ -17,18 +17,15 @@
  * spawns, waits, or a real install tree.
  */
 import { spawnSync } from "node:child_process";
-import { getVersionGatePhase, resolveRunningInstall } from "./utils/version-gate.js";
-import { stringDerivedPackageRoot } from "./utils/hq-roots.js";
-import { updateLockPath, UPDATE_LOCK_STALE_MS } from "./utils/update-lock.js";
-import { classifyEvalThrow, classifyModuleNotFound, installRewriteInProgress, InstallTreeTornError, waitForInstallTreeSettled, } from "./utils/install-tree-torn.js";
+import { resolveRunningInstall } from "./utils/version-gate.js";
+import { updateLockPath } from "./utils/update-lock.js";
+import { classifyModuleNotFound, InstallTreeTornError, waitForInstallTreeSettled, } from "./utils/install-tree-torn.js";
 /**
  * Set on the re-exec'd child so it can NEVER wait or re-exec again — distinct
  * from self-update's HQ_RESCUE_SELF_UPDATED so the two recovery paths cannot
  * shadow each other.
  */
 export const INSTALL_TREE_RECOVERY_GUARD_ENV = "HQ_INSTALL_TREE_RECOVERED";
-/** Carries the writer-state observed by the parent into the guarded re-exec. */
-export const INSTALL_TREE_RECOVERY_TREE_STATE_ENV = "HQ_INSTALL_TREE_RECOVERY_TREE_STATE";
 /** Operator override for the settle wait's deadline. */
 export const INSTALL_SETTLE_TIMEOUT_ENV = "HQ_INSTALL_SETTLE_TIMEOUT_MS";
 /** Default settle deadline (ms). Overridable by {@link INSTALL_SETTLE_TIMEOUT_ENV}. */
@@ -38,7 +35,7 @@ export const DEFAULT_INSTALL_SETTLE_TIMEOUT_MS = 90_000;
  * actually happens. It tells a human why the command paused and is the e2e's
  * synchronization point; it is never a remedy and never sets an error exit code.
  */
-export const INSTALL_TREE_WAIT_NOTICE = "hq: checking whether the hq-cli install tree is still changing before retrying…";
+export const INSTALL_TREE_WAIT_NOTICE = "hq: the hq-cli install is being updated underneath this command; waiting for it to finish…";
 /** Resolve the settle deadline from the environment (0 = evaluate once; default on invalid). */
 export function resolveSettleTimeoutMs(env) {
     const raw = env[INSTALL_SETTLE_TIMEOUT_ENV];
@@ -48,31 +45,6 @@ export function resolveSettleTimeoutMs(env) {
         return DEFAULT_INSTALL_SETTLE_TIMEOUT_MS;
     return Number.parseInt(raw.trim(), 10);
 }
-/** Operator override for the settle wait's LOCK ceiling (time under a live writer). */
-export const INSTALL_SETTLE_LOCK_TIMEOUT_ENV = "HQ_INSTALL_SETTLE_LOCK_TIMEOUT_MS";
-/**
- * Default ceiling (ms) on the time the settle wait spends under a fresh foreign
- * lock held by a live cooperating writer — the update-lock contract's own
- * staleness window. Overridable by {@link INSTALL_SETTLE_LOCK_TIMEOUT_ENV}.
- */
-export const DEFAULT_INSTALL_SETTLE_LOCK_TIMEOUT_MS = UPDATE_LOCK_STALE_MS;
-/**
- * The single dim line emitted once when the wait continues PAST the settle
- * deadline because a live updater still holds the shared install lock — so a human
- * knows the pause is a running update, not a hang. Never a remedy, never an exit
- * code; worded distinctly from {@link INSTALL_TREE_WAIT_NOTICE} so the e2e can
- * synchronize on it.
- */
-export const INSTALL_TREE_LOCK_WAIT_NOTICE = "hq: another hq updater is still installing hq-cli; waiting for it to finish…";
-/** Resolve the lock ceiling from the environment (0 = do not extend; default on invalid). */
-export function resolveSettleLockTimeoutMs(env) {
-    const raw = env[INSTALL_SETTLE_LOCK_TIMEOUT_ENV];
-    if (typeof raw !== "string" || raw.trim() === "")
-        return DEFAULT_INSTALL_SETTLE_LOCK_TIMEOUT_MS;
-    if (!/^\d+$/.test(raw.trim()))
-        return DEFAULT_INSTALL_SETTLE_LOCK_TIMEOUT_MS;
-    return Number.parseInt(raw.trim(), 10);
-}
 /**
  * Register commands, recovering once from a torn-install module-resolution
  * failure. On a clean registration this returns `{}` and touches nothing else.
@@ -89,32 +61,12 @@ export async function registerCommandsWithRecovery(args) {
         return {};
     }
     catch (err) {
-        // The packageRoot bounds the eval-throw classifier's throw site and feeds the
-        // settle wait's manifest-health / retired-sibling guards; resolved once here.
-        const packageRoot = resolvePackageRoot(deps);
-        // Classify the loader failure. classifyModuleNotFound covers the resolve/load
-        // dialects (incl. HQ-CLI-1S resolve-enoent); classifyEvalThrow covers a
-        // module-EVALUATION throw (HQ-CLI-1T). Anything unclassified is rethrown as the
-        // SAME object to the existing boundary, preserving today's behaviour exactly.
-        const classified = classifyModuleNotFound(err) ?? classifyEvalThrow(err, packageRoot);
+        const classified = classifyModuleNotFound(err);
+        // Not a module-resolution failure — rethrow the SAME object to the existing
+        // boundary, preserving today's behaviour exactly.
         if (!classified)
             throw err;
-        const lockPath = (deps.lockPath ?? updateLockPath)();
-        const waitFor = deps.waitForSettled ?? waitForInstallTreeSettled;
-        // Writer-signal gate for the eval-throw dialect ONLY. A module-evaluation
-        // throw is indistinguishable from a persistent third-party load-time defect
-        // unless a global reinstall is provably in progress, so require a POSITIVE
-        // writer signal — a fresh foreign lock, an absent/name-mismatched manifest, or
-        // a retired `.hq-cli-<hash>` sibling — before entering recovery. With no such
-        // signal the SAME error is rethrown raw (today's immediate capture) and never
-        // pays a settle wait; a benign fs error (an unreadable manifest or unlistable
-        // parent) is deliberately NOT read as a signal, so a real defect never waits.
-        // The loader-race dialects need no such gate. Injected for a hermetic seam.
-        if (classified.dialect === "eval-throw") {
-            const rewriteInProgress = deps.rewriteInProgress ?? installRewriteInProgress;
-            if (!rewriteInProgress({ packageRoot, lockPath }))
-                throw err;
-        }
+        const packageRoot = resolvePackageRoot(deps);
         // A child that already recovered must never wait or re-exec again: report
         // once and let the boundary capture it.
         if (env[INSTALL_TREE_RECOVERY_GUARD_ENV] === "1") {
@@ -122,90 +74,47 @@ export async function registerCommandsWithRecovery(args) {
                 cause: err,
                 classified,
                 packageRoot,
-                versionGatePhase: getVersionGatePhase(),
                 outcome: "guarded",
-                treeState: env[INSTALL_TREE_RECOVERY_TREE_STATE_ENV] === "stale" ? "stale" : "in_flight",
                 attempt: 2,
                 waitedMs: 0,
                 sawLock: false,
                 sawRetired: false,
-                sawTreeChange: false,
             });
         }
         stderr.write(`${INSTALL_TREE_WAIT_NOTICE}\n`);
+        const lockPath = (deps.lockPath ?? updateLockPath)();
+        const waitFor = deps.waitForSettled ?? waitForInstallTreeSettled;
         const result = await waitFor({
             target: classified.target,
             packageRoot,
             lockPath,
             deadlineMs: resolveSettleTimeoutMs(env),
-            lockWaitMs: resolveSettleLockTimeoutMs(env),
-            onLockExtended: () => stderr.write(`${INSTALL_TREE_LOCK_WAIT_NOTICE}\n`),
         });
         if (!result.settled) {
-            const treeState = result.staleTree === true ? "stale" : "in_flight";
             throw new InstallTreeTornError({
                 cause: err,
                 classified,
                 packageRoot,
-                // A fresh foreign lock still held at the end means a live cooperating
-                // 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. 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,
+                outcome: "unsettled",
                 attempt: 1,
                 waitedMs: result.waitedMs,
                 sawLock: result.sawLock,
                 sawRetired: result.sawRetired,
-                retiredSiblingPresent: result.retiredSiblingPresent,
-                retiredSiblingKind: result.retiredSiblingKind,
-                installTargetState: result.installTargetState,
-                updaterPidAlive: result.updaterPidAlive,
-                sawTreeChange: result.sawTreeChange,
-                lockHeldAtEnd: result.lockHeldAtEnd,
-                lockedMs: result.lockedMs,
-                lockTool: result.lockTool,
             });
         }
         const spawn = deps.spawn ?? spawnSync;
         const execArgv = deps.execArgv ?? process.execArgv;
-        const treeState = result.sawLock || result.sawRetired || result.sawTreeChange
-            ? "in_flight"
-            : "stale";
-        const child = spawn(process.execPath, [...execArgv, entryPath, ...argv.slice(2)], {
-            stdio: "inherit",
-            env: {
-                ...env,
-                [INSTALL_TREE_RECOVERY_GUARD_ENV]: "1",
-                [INSTALL_TREE_RECOVERY_TREE_STATE_ENV]: treeState,
-            },
-        });
+        const child = spawn(process.execPath, [...execArgv, entryPath, ...argv.slice(2)], { stdio: "inherit", env: { ...env, [INSTALL_TREE_RECOVERY_GUARD_ENV]: "1" } });
         if (child.error) {
             throw new InstallTreeTornError({
                 cause: err,
                 classified,
                 packageRoot,
-                versionGatePhase: getVersionGatePhase(),
                 outcome: "reexec-failed",
-                treeState,
                 attempt: 1,
                 waitedMs: result.waitedMs,
                 sawLock: result.sawLock,
                 sawRetired: result.sawRetired,
-                retiredSiblingPresent: result.retiredSiblingPresent,
-                retiredSiblingKind: result.retiredSiblingKind,
-                installTargetState: result.installTargetState,
-                updaterPidAlive: result.updaterPidAlive,
-                sawTreeChange: result.sawTreeChange,
-                lockTool: result.lockTool,
             });
         }
         // A signal-killed child has status null; surface it as a failure exit rather
@@ -213,23 +122,13 @@ export async function registerCommandsWithRecovery(args) {
         return { reexecStatus: child.status ?? 1 };
     }
 }
-/**
- * Resolve the running install's package dir for the settle wait's manifest-health
- * and retired-sibling guards. The on-disk resolver returns null in exactly the
- * window this recovery targets — the package directory has been renamed aside, so
- * it cannot be found by reading disk — which would leave readiness keyed on the
- * single missing file alone and let a premature re-exec run against a still-
- * incomplete tree. Fall back to the filesystem-free derived root so those guards
- * stay active while npm is mid-extraction. Tolerates any resolver failure.
- */
+/** Resolve the running install's package dir, tolerating any resolver failure. */
 function resolvePackageRoot(deps) {
-    let root;
     try {
-        root = (deps.resolveInstall ?? resolveRunningInstall)().packageRoot;
+        return (deps.resolveInstall ?? resolveRunningInstall)().packageRoot;
     }
     catch {
-        root = null;
+        return null;
     }
-    return root ?? (deps.deriveInstallRoot ?? stringDerivedPackageRoot)();
 }
 //# sourceMappingURL=startup-registration.js.map

package/dist/utils/cli-telemetry.d.ts

@@ -1,79 +1,6 @@
-import { type FirstSyncStepOutcome } from "../lib/first-sync-next-step.js";
-export { CLI_FIRST_SYNC_NEXT_STEP_FLAG, FIRST_SYNC_CONFIRMATION_COPY, FIRST_SYNC_NEXT_STEP_COPY, claimFirstSyncStepMarker, firstSyncStepMarkerPaths, firstSyncStepTelemetryProperties, isFirstSyncNextStepEnabled, isHumanInteractiveCliSession, isWorkBearingSyncResult, maybeShowFirstSyncNextStep, recordFirstWorkBearingSync, shouldConfirmFirstWorkBearingSync, shouldShowFirstSyncNextStep, takeFirstSyncStepOutcomes, type FirstSyncStepOutcome, } from "../lib/first-sync-next-step.js";
-export declare const TELEMETRY_TIMEOUT_MS = 1200;
-/**
- * Exact stderr line printed once on the first signed-in TTY run that is not
- * `--json`. Keep this notice and its marker stable for session telemetry;
- * first-sync and feature-used fields have separate opt-in disclosures below.
- */
-export declare const TELEMETRY_DISCLOSURE_LINE = "HQ sends a usage event when you run a signed-in command (CLI version and a timestamp, never command names, file contents, or secrets) to improve the CLI. Set HQ_TELEMETRY=0 to turn this off.";
-export declare const FIRST_SYNC_TELEMETRY_DISCLOSURE_LINE = "HQ sends a usage event when you run a signed-in command (CLI version and a timestamp; when enabled, first-sync guidance shown or followed and the flag key cli.first-sync-next-step; never command names, file contents, or secrets) to improve the CLI. Set HQ_TELEMETRY=0 to turn this off.";
-export declare const CLI_FEATURE_USED_TELEMETRY_FLAG = "cli.feature-used-telemetry-v1";
-export declare const CLI_FEATURE_USED_TELEMETRY_DISCLOSURE_LINE = "HQ sends a feature-use event when you run a supported CLI feature (feature kind and outcome, plus your company UID when available; never command names, file contents, or secrets). The hq-flags key cli.feature-used-telemetry-v1 controls these events. Set HQ_TELEMETRY=0 to turn this off.";
-export declare const CLI_LIMIT_AT_ACTION_PROMPT_FLAG = "billing.limit-at-action-prompt";
-export type CliLimitResourceKind = "users" | "integrations" | "secrets" | "agents" | "deployments" | "storageBytes";
-export type CliLimitPresentationKind = "advisory" | "refusal";
-export interface CliLimitNoticeExposure {
-    companyUid: string;
-    resourceKind: CliLimitResourceKind;
-    presentationKind: CliLimitPresentationKind;
-    exposureId: string;
-}
-export interface CliLimitNoticeEngagement extends CliLimitNoticeExposure {
-    action: "upgrade_clicked";
-}
-/** Capture an exposure only after its notice has been written to the terminal. */
-export declare function queueCliLimitNoticeExposure(resourceKind: CliLimitResourceKind, presentationKind: CliLimitPresentationKind, resolvedCompanyUid?: string): CliLimitNoticeExposure | null;
-/** Only an explicit, confirmed browser open is an upgrade engagement. */
-export declare function queueCliLimitNoticeEngagement(exposure: CliLimitNoticeExposure | null): void;
-export declare function takeCliLimitNoticeExposures(): CliLimitNoticeExposure[];
-export declare function takeCliLimitNoticeEngagements(): CliLimitNoticeEngagement[];
-/** Queue one exposure after the CLI has printed the invite suggestion. */
-export declare function queuePlanLimitInviteTeammateExposure(companyUid: string): void;
-/** Drain invite-suggestion exposures for the bounded command-finalization flush. */
-export declare function takePlanLimitInviteTeammateExposures(): string[];
-export type CliFeatureKind = "secret_read" | "lane_create" | "lane_resume";
-export type CliFeatureOutcome = "success" | "failure";
-export interface CliFeatureUsage {
-    kind: CliFeatureKind;
-    outcome: CliFeatureOutcome;
-    /** Only company UIDs are accepted; names and slugs are never telemetry fields. */
-    companyUid?: string;
-}
-export declare function isCliLimitResourceKind(value: string): value is CliLimitResourceKind;
-/**
- * Emit one bounded, privacy-limited feature-use event with a cached identity.
- * It never refreshes credentials or turns telemetry failure into command failure.
- */
-export declare function emitCliFeatureUsed(usage: CliFeatureUsage, timeoutMs?: number): Promise<void>;
-/** Run one action and emit exactly one success/failure event without masking errors. */
-export declare function withCliFeatureUsed<T>(kind: CliFeatureKind, action: () => Promise<T>, companyUid?: string): Promise<T>;
-/**
- * `HQ_TELEMETRY=0` (also `false` and `off`, case-insensitive) disables every
- * CLI POST to `/v1/telemetry/events`. `HQ_TELEMETRY_TIMEOUT_MS` is unchanged.
- */
-export declare function isCliTelemetryDisabled(env?: NodeJS.ProcessEnv): boolean;
-/** Feature-use collection stays off until the HQ flag is explicitly enabled. */
-export declare function isCliFeatureUsedTelemetryEnabled(): boolean;
-export declare function telemetryDisclosureMarkerPath(): string;
-/**
- * Print the one-line disclosure at most once per machine. Returns whether
- * the notice has been shown (this run or a previous one). `--json` and
- * non-TTY stdout skip the print and do not record the marker.
- */
-export declare function maybeDiscloseCliTelemetry(stderr?: {
-    write: (chunk: string) => unknown;
-}, stdout?: {
-    isTTY?: boolean;
-}, argv?: readonly string[]): boolean;
 /**
  * Emit the authenticated CLI session signal using an already-cached token.
  * This deliberately never refreshes a session or opens a browser.
  */
-export declare function emitCliSessionStarted(timeoutMs?: number): Promise<void>;
-/** Emit one authenticated measurement for a first-sync prompt outcome. */
-export declare function emitCliFirstSyncNextStepOutcome(outcome: FirstSyncStepOutcome, timeoutMs?: number): Promise<void>;
-export declare function emitPlanLimitInviteTeammateExposure(companyUid: string, timeoutMs?: number): Promise<void>;
-export declare function emitCliLimitNoticeExposure(exposure: CliLimitNoticeExposure, timeoutMs?: number): Promise<void>;
-export declare function emitCliLimitNoticeEngagement(engagement: CliLimitNoticeEngagement, timeoutMs?: number): Promise<void>;
+export declare function emitCliSessionStarted(): Promise<void>;
 //# sourceMappingURL=cli-telemetry.d.ts.map