@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/startup-registration.js

@@ -17,15 +17,18 @@
  * spawns, waits, or a real install tree.
  */
 import { spawnSync } from "node:child_process";
-import { resolveRunningInstall } from "./utils/version-gate.js";
-import { updateLockPath } from "./utils/update-lock.js";
-import { classifyModuleNotFound, InstallTreeTornError, waitForInstallTreeSettled, } from "./utils/install-tree-torn.js";
+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";
 /**
  * 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}. */
@@ -35,7 +38,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: the hq-cli install is being updated underneath this command; waiting for it to finish…";
+export const INSTALL_TREE_WAIT_NOTICE = "hq: checking whether the hq-cli install tree is still changing before retrying…";
 /** Resolve the settle deadline from the environment (0 = evaluate once; default on invalid). */
 export function resolveSettleTimeoutMs(env) {
     const raw = env[INSTALL_SETTLE_TIMEOUT_ENV];
@@ -45,6 +48,31 @@ 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.
@@ -61,12 +89,32 @@ export async function registerCommandsWithRecovery(args) {
         return {};
     }
     catch (err) {
-        const classified = classifyModuleNotFound(err);
-        // Not a module-resolution failure — rethrow the SAME object to the existing
-        // boundary, preserving today's behaviour exactly.
+        // 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);
         if (!classified)
             throw err;
-        const packageRoot = resolvePackageRoot(deps);
+        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;
+        }
         // 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") {
@@ -74,47 +122,90 @@ 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,
-                outcome: "unsettled",
+                // 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,
                 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 child = spawn(process.execPath, [...execArgv, entryPath, ...argv.slice(2)], { stdio: "inherit", env: { ...env, [INSTALL_TREE_RECOVERY_GUARD_ENV]: "1" } });
+        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,
+            },
+        });
         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
@@ -122,13 +213,23 @@ export async function registerCommandsWithRecovery(args) {
         return { reexecStatus: child.status ?? 1 };
     }
 }
-/** Resolve the running install's package dir, tolerating any resolver failure. */
+/**
+ * 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.
+ */
 function resolvePackageRoot(deps) {
+    let root;
     try {
-        return (deps.resolveInstall ?? resolveRunningInstall)().packageRoot;
+        root = (deps.resolveInstall ?? resolveRunningInstall)().packageRoot;
     }
     catch {
-        return null;
+        root = null;
     }
+    return root ?? (deps.deriveInstallRoot ?? stringDerivedPackageRoot)();
 }
 //# sourceMappingURL=startup-registration.js.map

package/dist/utils/checkpoint-stamp-write-error.d.ts

@@ -0,0 +1,28 @@
+export type CheckpointStampFsOperation = "open" | "write" | "rename" | "unlink";
+type CheckpointStampErrnoCode = "EBUSY" | "EPERM" | "UNKNOWN";
+type CheckpointStampWriteDiagnostics = {
+    fs_op: CheckpointStampFsOperation;
+    target_kind: "checkpoint_stamp";
+    errno_code: CheckpointStampErrnoCode;
+    platform: "win32";
+};
+export type CheckpointStampWriteCaptureContext = {
+    fingerprint: ["fs-write-failed", "checkpoint_stamp", CheckpointStampErrnoCode];
+    tags: CheckpointStampWriteDiagnostics;
+};
+export declare class CheckpointStampWriteError extends Error {
+    name: string;
+    readonly code: CheckpointStampErrnoCode;
+    readonly syscall: CheckpointStampFsOperation;
+    readonly checkpointStampWriteDiagnostics: CheckpointStampWriteDiagnostics;
+    constructor(diagnostics: CheckpointStampWriteDiagnostics, originalStack?: string);
+}
+/** Wrap only the captured Windows lock/error classes, keeping the original frames and dropping paths. */
+export declare function checkpointStampWriteErrorFor(error: unknown, fallbackOperation: CheckpointStampFsOperation): CheckpointStampWriteError | null;
+export declare function isCheckpointStampWriteError(error: unknown): boolean;
+/** Value-free report context for the Windows checkpoint stamp write boundary. */
+export declare function checkpointStampWriteCaptureContext(error: unknown): CheckpointStampWriteCaptureContext | null;
+/** User-facing text stays actionable without including the HQ or home path. */
+export declare function checkpointStampWriteMessage(error: unknown): string | null;
+export {};
+//# sourceMappingURL=checkpoint-stamp-write-error.d.ts.map

package/dist/utils/checkpoint-stamp-write-error.js

@@ -0,0 +1,99 @@
+const CHECKPOINT_STAMP_ERRNO_CODES = new Set([
+    "EBUSY",
+    "EPERM",
+    "UNKNOWN",
+]);
+const CHECKPOINT_STAMP_FS_OPERATIONS = new Set([
+    "open",
+    "write",
+    "rename",
+    "unlink",
+]);
+function errorLike(value) {
+    return value !== null && typeof value === "object" ? value : null;
+}
+function isCheckpointStampErrnoCode(value) {
+    return typeof value === "string" && CHECKPOINT_STAMP_ERRNO_CODES.has(value);
+}
+function isCheckpointStampFsOperation(value) {
+    return (typeof value === "string" &&
+        CHECKPOINT_STAMP_FS_OPERATIONS.has(value));
+}
+export class CheckpointStampWriteError extends Error {
+    name = "CheckpointStampWriteError";
+    code;
+    syscall;
+    checkpointStampWriteDiagnostics;
+    constructor(diagnostics, originalStack) {
+        super(`checkpoint stamp write failed during ${diagnostics.fs_op} (${diagnostics.errno_code})`);
+        this.code = diagnostics.errno_code;
+        this.syscall = diagnostics.fs_op;
+        this.checkpointStampWriteDiagnostics = diagnostics;
+        if (originalStack) {
+            const frames = originalStack.split("\n").slice(1);
+            if (frames.length > 0)
+                this.stack = `${this.name}: ${this.message}\n${frames.join("\n")}`;
+        }
+    }
+}
+/** Wrap only the captured Windows lock/error classes, keeping the original frames and dropping paths. */
+export function checkpointStampWriteErrorFor(error, fallbackOperation) {
+    const record = errorLike(error);
+    if (!record || !isCheckpointStampErrnoCode(record.code))
+        return null;
+    const fsOperation = isCheckpointStampFsOperation(record.syscall)
+        ? record.syscall
+        : fallbackOperation;
+    const diagnostics = {
+        fs_op: fsOperation,
+        target_kind: "checkpoint_stamp",
+        errno_code: record.code,
+        platform: "win32",
+    };
+    return new CheckpointStampWriteError(diagnostics, error instanceof Error ? error.stack : undefined);
+}
+function diagnosticsFor(error) {
+    const record = errorLike(error);
+    if (!record || record.name !== "CheckpointStampWriteError")
+        return null;
+    const diagnostics = error
+        .checkpointStampWriteDiagnostics;
+    if (diagnostics === null || typeof diagnostics !== "object")
+        return null;
+    const candidate = diagnostics;
+    if (!isCheckpointStampFsOperation(candidate.fs_op) ||
+        candidate.target_kind !== "checkpoint_stamp" ||
+        !isCheckpointStampErrnoCode(candidate.errno_code) ||
+        candidate.platform !== "win32") {
+        return null;
+    }
+    return {
+        fs_op: candidate.fs_op,
+        target_kind: "checkpoint_stamp",
+        errno_code: candidate.errno_code,
+        platform: "win32",
+    };
+}
+export function isCheckpointStampWriteError(error) {
+    return diagnosticsFor(error) !== null;
+}
+/** Value-free report context for the Windows checkpoint stamp write boundary. */
+export function checkpointStampWriteCaptureContext(error) {
+    const tags = diagnosticsFor(error);
+    if (!tags)
+        return null;
+    return {
+        // This is a grouping key. Keep it independent of installation paths.
+        fingerprint: ["fs-write-failed", tags.target_kind, tags.errno_code],
+        tags,
+    };
+}
+/** User-facing text stays actionable without including the HQ or home path. */
+export function checkpointStampWriteMessage(error) {
+    const diagnostics = diagnosticsFor(error);
+    if (!diagnostics)
+        return null;
+    return (`hq could not write a checkpoint state file (${diagnostics.errno_code} during ${diagnostics.fs_op}). ` +
+        "Check the checkpoint state folder and retry.");
+}
+//# sourceMappingURL=checkpoint-stamp-write-error.js.map

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/dist/utils/cli-telemetry.d.ts

@@ -1,6 +1,80 @@
+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, 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 disclosures below; only
+ * feature-used telemetry remains opt-in.
+ */
+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; first-sync guidance shown or followed, with the identifier 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(): Promise<void>;
+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>;
 //# sourceMappingURL=cli-telemetry.d.ts.map