@unbrained/pm-cli 2026.6.5 → 2026.6.6

package/dist/cli-bundle/main.js

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
+import {
+  deriveTelemetryCommandResolution,
+  deriveTelemetryCommandTaxonomy,
+  emitTelemetryErrorEvent,
+  finishTelemetryCommand,
+  startTelemetryCommand
+} from "./chunks/chunk-SKJWX3QB.js";
 import {
   migrateItemFilesToFormat
-} from "./chunks/chunk-BNL6S7QH.js";
+} from "./chunks/chunk-KJ33AOCY.js";
 import {
   applyDefaultOutputFormat,
   clearResolvedGlobalOptions,
@@ -11,38 +18,35 @@ import {
   getGlobalOptions,
   invalidateSearchCachesForMutation,
   setResolvedGlobalOptions
-} from "./chunks/chunk-TK633IVD.js";
+} from "./chunks/chunk-PDDFYW4X.js";
 import {
   PM_CORE_COMMAND_NAMES,
   resolveSubcommandFlagContractsForCommand
-} from "./chunks/chunk-ZQ4F6EC4.js";
-import "./chunks/chunk-5IRA6IYD.js";
+} from "./chunks/chunk-PROOHX4K.js";
+import "./chunks/chunk-3FI4SEFT.js";
 import {
   printError,
   printResult,
   writeStdout
-} from "./chunks/chunk-HZOS2UG5.js";
+} from "./chunks/chunk-LCM63IXU.js";
 import {
   levenshteinDistanceWithinLimit
 } from "./chunks/chunk-EAOG77HM.js";
-import "./chunks/chunk-XG7RJYHV.js";
-import "./chunks/chunk-KA24HME7.js";
-import "./chunks/chunk-HPH6X4ZZ.js";
+import "./chunks/chunk-XTGLRY2Y.js";
+import "./chunks/chunk-T3LC5LKB.js";
+import "./chunks/chunk-AO442XLN.js";
 import {
   commandOptionFlagLabel,
   resolveCommandOptionPolicyState,
   resolveItemTypeRegistry,
   resolveTypeDefinition
-} from "./chunks/chunk-4PJQSECJ.js";
-import {
-  nowIso
-} from "./chunks/chunk-RANZIID5.js";
+} from "./chunks/chunk-KJE2FOS4.js";
+import "./chunks/chunk-QO7EBBOM.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
   PmCliError,
   activateExtensions,
-  appendLineAtomic,
   asRecordOrNull,
   clearActiveExtensionHooks,
   consumeAfterCommandAffectedItems,
@@ -53,7 +57,6 @@ import {
   getSettingsPath,
   loadExtensions,
   pathExists,
-  readFileIfExists,
   readSettings,
   readSettingsWithMetadata,
   resolveGlobalPmRoot,
@@ -77,13 +80,12 @@ import {
   setActiveExtensionRenderers,
   setActiveExtensionServices,
   toNonEmptyStringOrUndefined,
-  writeFileAtomic,
   writeSettings
-} from "./chunks/chunk-SRVKTWPR.js";
+} from "./chunks/chunk-U5SXYXSY.js";
 
 // dist/cli/main.js
 import fs2 from "node:fs";
-import path3 from "node:path";
+import path2 from "node:path";
 import { Command } from "commander";
 
 // dist/core/telemetry/consent.js
@@ -168,1429 +170,9 @@ async function maybeRunFirstUseTelemetryPrompt(commandPath, globalOptions) {
   }
 }
 
-// dist/core/telemetry/runtime.js
-import crypto from "node:crypto";
-import { spawn } from "node:child_process";
-import { mkdirSync, rmSync, statSync } from "node:fs";
-import { mkdir, readdir, rm, stat } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-// dist/core/telemetry/observability.js
-!(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] = "ad10a6ab-5a76-55e1-9750-1613c8210700");
-  } catch (e2) {
-  }
-})();
-var SETUP_ROOT_COMMANDS = /* @__PURE__ */ new Set(["init", "config", "completion", "completion-statuses", "completion-tags", "completion-types"]);
-var QUERY_ROOT_COMMANDS = /* @__PURE__ */ new Set([
-  "list",
-  "list-all",
-  "list-open",
-  "list-in-progress",
-  "list-blocked",
-  "list-closed",
-  "list-canceled",
-  "list-draft",
-  "search",
-  "get",
-  "context",
-  "calendar",
-  "history",
-  "activity",
-  "aggregate",
-  "deps",
-  "contracts",
-  "stats",
-  "dedupe-audit"
-]);
-var MUTATION_ROOT_COMMANDS = /* @__PURE__ */ new Set([
-  "create",
-  "update",
-  "update-many",
-  "close-many",
-  "append",
-  "close",
-  "delete",
-  "restore",
-  "claim",
-  "release",
-  "comments",
-  "notes",
-  "learnings",
-  "files",
-  "docs",
-  "start-task",
-  "pause-task",
-  "close-task"
-]);
-var TESTING_ROOT_COMMANDS = /* @__PURE__ */ new Set(["test", "test-all", "test-runs", "test-verify", "trace-test", "test-ping"]);
-var DIAGNOSTICS_ROOT_COMMANDS = /* @__PURE__ */ new Set(["health", "validate", "normalize", "reindex", "gc", "extension-doctor"]);
-function normalizeCommandPath(commandPath) {
-  return commandPath.trim().replaceAll(/\s+/g, " ").toLowerCase();
-}
-function normalizeErrorCode(errorCode2) {
-  const normalized = errorCode2?.trim().toLowerCase();
-  return normalized && normalized.length > 0 ? normalized : void 0;
-}
-function deriveTelemetryCommandTaxonomy(commandPath) {
-  const normalizedPath = normalizeCommandPath(commandPath);
-  const tokens = normalizedPath.length > 0 ? normalizedPath.split(" ") : ["<unknown>"];
-  const root = tokens[0] ?? "<unknown>";
-  const leaf = tokens[tokens.length - 1] ?? root;
-  let family = "other";
-  if (SETUP_ROOT_COMMANDS.has(root)) {
-    family = "setup";
-  } else if (QUERY_ROOT_COMMANDS.has(root)) {
-    family = "query";
-  } else if (MUTATION_ROOT_COMMANDS.has(root)) {
-    family = "mutation";
-  } else if (TESTING_ROOT_COMMANDS.has(root)) {
-    family = "testing";
-  } else if (root === "extension") {
-    family = "extension";
-  } else if (DIAGNOSTICS_ROOT_COMMANDS.has(root)) {
-    family = "diagnostics";
-  }
-  return {
-    command_path: normalizedPath.length > 0 ? normalizedPath : "<unknown>",
-    command_root: root,
-    command_leaf: leaf,
-    command_depth: tokens.length,
-    command_family: family
-  };
-}
-function inferTelemetryErrorCode(params) {
-  if (params.ok) {
-    return void 0;
-  }
-  const explicit = normalizeErrorCode(params.errorCode);
-  if (explicit) {
-    return explicit;
-  }
-  const message = (params.errorMessage ?? "").trim().toLowerCase();
-  if (message.includes("unknown command")) {
-    return "unknown_command";
-  }
-  if (message.includes("unknown option")) {
-    return "unknown_option";
-  }
-  if (message.includes("missing required options") || message.includes("missing required option")) {
-    return "missing_required_option";
-  }
-  if (message.includes("missing required argument")) {
-    return "missing_required_argument";
-  }
-  if (message.includes("no update flags provided")) {
-    return "no_update_fields";
-  }
-  if (message.includes("is assigned to") && message.includes("use --force")) {
-    return "ownership_conflict";
-  }
-  if (message.includes("is locked")) {
-    return "lock_conflict";
-  }
-  if (message.includes("already terminal") && message.includes("use --force")) {
-    return "terminal_state_conflict";
-  }
-  if (message.includes("tracker is not initialized")) {
-    return "tracker_not_initialized";
-  }
-  if (message.includes(" not found")) {
-    return "item_not_found";
-  }
-  if (message.includes('use "pm close <id> <text>" to close an item') || message.includes("invalid --status value") && message.includes('"closed"')) {
-    return "close_through_update";
-  }
-  if (message.startsWith("invalid ") || message.includes(" must be ") || message.includes(" requires ")) {
-    return "invalid_argument_value";
-  }
-  if (message.includes("strict create mode requires concrete values for --")) {
-    return "missing_required_option";
-  }
-  if (message.includes("either as positional") && message.includes("not both")) {
-    return "invalid_command_usage";
-  }
-  const exitCode = Number.isFinite(params.exitCode) ? Math.max(0, Math.trunc(params.exitCode ?? 0)) : void 0;
-  if (exitCode === EXIT_CODE.USAGE) {
-    return "invalid_command_usage";
-  }
-  if (exitCode === EXIT_CODE.NOT_FOUND) {
-    return "item_not_found";
-  }
-  if (exitCode === EXIT_CODE.CONFLICT) {
-    return "lock_conflict";
-  }
-  if (exitCode === EXIT_CODE.DEPENDENCY_FAILED) {
-    return "dependency_failed";
-  }
-  return "command_failed";
-}
-function deriveTelemetryCommandResolution(params) {
-  if (params.ok) {
-    return "success";
-  }
-  const normalizedCode = normalizeErrorCode(params.errorCode);
-  if (normalizedCode === "unknown_command") {
-    return "nonexistent_command";
-  }
-  if (normalizedCode === "unknown_option") {
-    return "invalid_option";
-  }
-  if (normalizedCode === "missing_required_option") {
-    return "missing_required_option";
-  }
-  if (normalizedCode === "missing_required_argument") {
-    return "missing_required_argument";
-  }
-  if (normalizedCode === "health_findings") {
-    return "health_findings";
-  }
-  if (normalizedCode === "validation_findings") {
-    return "validation_findings";
-  }
-  if (params.errorCategory === "usage") {
-    return "invalid_usage";
-  }
-  if (params.errorCategory === "validation") {
-    return "validation_failed";
-  }
-  if (params.errorCategory === "conflict") {
-    return "conflict";
-  }
-  if (params.errorCategory === "runtime") {
-    return "runtime_failed";
-  }
-  return "unknown_failed";
-}
-
-// dist/core/telemetry/runtime.js
-!(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] = "b2cd9110-8de0-5e79-a029-c0902f862999");
-  } catch (e2) {
-  }
-})();
-var TELEMETRY_QUEUE_RELATIVE_PATH = path.join("runtime", "telemetry", "events.jsonl");
-var TELEMETRY_STATE_RELATIVE_PATH = path.join("runtime", "telemetry", "state.json");
-var TELEMETRY_SCHEMA_VERSION = 1;
-var TELEMETRY_FLUSH_BATCH_SIZE = 100;
-var TELEMETRY_MAX_RETRY_DELAY_MS = 36e5;
-var TELEMETRY_RETRY_BASE_DELAY_MS = 3e4;
-var TELEMETRY_HTTP_TIMEOUT_MS = 5e3;
-var MILLISECONDS_PER_DAY = 864e5;
-var TELEMETRY_MAX_EVENT_BYTES = 65536;
-var TELEMETRY_SANITIZE_MAX_DEPTH = 6;
-var TELEMETRY_SANITIZE_MAX_ARRAY_ITEMS = 20;
-var TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS = 15;
-var TELEMETRY_RESULT_PREVIEW_MAX_BYTES = 8192;
-var TELEMETRY_QUEUE_REWRITE_RETRY_DELAYS_MS = [25, 50, 100, 200];
-var TELEMETRY_QUEUE_TMP_ORPHAN_MAX_AGE_MS = 60 * 60 * 1e3;
-var TELEMETRY_FLUSH_LOCK_STALE_MS = 6e4;
-var TELEMETRY_FLUSH_SPAWN_LOCK_STALE_MS = 6e4;
-var OTEL_TRACES_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
-var OTEL_BASE_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_ENDPOINT";
-var OTEL_SERVICE_NAME_ENV = "OTEL_SERVICE_NAME";
-var PM_TELEMETRY_DISABLED_ENV = "PM_TELEMETRY_DISABLED";
-var PM_NO_TELEMETRY_ENV = "PM_NO_TELEMETRY";
-var PM_TELEMETRY_DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
-var PM_TELEMETRY_OTEL_DISABLED_ENV = "PM_TELEMETRY_OTEL_DISABLED";
-var PM_TELEMETRY_OTEL_DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
-var PM_TELEMETRY_INLINE_FLUSH_ENV = "PM_TELEMETRY_INLINE_FLUSH";
-var PM_TELEMETRY_FLUSH_CHILD_ENV = "PM_TELEMETRY_FLUSH_CHILD";
-var PM_TELEMETRY_SOURCE_CONTEXT_ENV = "PM_TELEMETRY_SOURCE_CONTEXT";
-var PM_TELEMETRY_SOURCE_CONTEXT_VALUES = ["user", "automation", "test", "dogfood", "audit_smoke"];
-var _lastFlushPromise = Promise.resolve();
-var _queueMutationPromise = Promise.resolve();
-var PM_TELEMETRY_SOURCE_CONTEXT_SET = new Set(PM_TELEMETRY_SOURCE_CONTEXT_VALUES);
-var BOOLEAN_TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
-var PROCESS_SESSION_ID = crypto.randomUUID();
-var SENSITIVE_KEYWORDS = [
-  "token",
-  "secret",
-  "password",
-  "passwd",
-  "api_key",
-  "apikey",
-  "authorization",
-  "cookie",
-  "session",
-  "credentials",
-  "bearer"
-];
-var SENSITIVE_INLINE_KEY_PATTERN = "(?:token|secret|password|passwd|api[_-]?key|apikey|authorization|cookie|session|credentials|bearer)";
-var INLINE_SENSITIVE_ASSIGNMENT_PATTERN = new RegExp(`\\b(${SENSITIVE_INLINE_KEY_PATTERN})\\s*([:=])\\s*([^\\s,;]+)`, "giu");
-var INLINE_SENSITIVE_FLAG_PATTERN = new RegExp(`(--${SENSITIVE_INLINE_KEY_PATTERN})(=|\\s+)([^\\s,;]+)`, "giu");
-var ABSOLUTE_PATH_TOKEN_PATTERN = /(^|[\s"'`(=])\/(?:[^\s"'`),;]+)/g;
-var EMAIL_PATTERN = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/giu;
-var BEARER_TOKEN_PATTERN = /bearer\s+[a-z0-9._=-]+/giu;
-var PRIVATE_IP_PATTERN = /\b(?:10\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)|172\.(?:1[6-9]|2\d|3[01])\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)|192\.168\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d))\b/g;
-function queuePath(globalPmRoot) {
-  return path.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH);
-}
-function telemetryRuntimeDirectory(globalPmRoot) {
-  return path.dirname(queuePath(globalPmRoot));
-}
-function runtimeStatePath(globalPmRoot) {
-  return path.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH);
-}
-function flushLockPath(globalPmRoot) {
-  return path.join(globalPmRoot, "runtime", "telemetry", "flush.lock");
-}
-function flushSpawnLockPath(globalPmRoot) {
-  return path.join(globalPmRoot, "runtime", "telemetry", "flush.spawn.lock");
-}
-function telemetryFlushRunnerPath() {
-  return path.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "dist", "cli", "telemetry-flush.js");
-}
-function shouldFlushInline() {
-  if (parseBooleanTrueLike(process.env[PM_TELEMETRY_INLINE_FLUSH_ENV])) {
-    return true;
-  }
-  if (parseBooleanTrueLike(process.env[PM_TELEMETRY_FLUSH_CHILD_ENV])) {
-    return true;
-  }
-  const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
-  return typeof process.env.VITEST === "string" || typeof process.env.VITEST_WORKER_ID === "string" || nodeEnv === "test";
-}
-async function readRuntimeState(globalPmRoot) {
-  const raw = await readFileIfExists(runtimeStatePath(globalPmRoot));
-  if (!raw || raw.trim().length === 0) {
-    return {};
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return {};
-    }
-    return parsed;
-  } catch {
-    return {};
-  }
-}
-async function writeRuntimeState(globalPmRoot, patch) {
-  try {
-    const current = await readRuntimeState(globalPmRoot);
-    const next = {
-      ...current,
-      ...patch
-    };
-    const normalized = Object.fromEntries(Object.entries(next).filter(([, value]) => value !== void 0).sort((left, right) => left[0].localeCompare(right[0])));
-    await writeFileAtomic(runtimeStatePath(globalPmRoot), `${JSON.stringify(normalized, null, 2)}
-`);
-  } catch {
-  }
-}
-function isSensitiveKey(key) {
-  const normalized = key.trim().toLowerCase().replaceAll("-", "_").replaceAll(/[^a-z0-9_]+/g, "_");
-  const tokens = normalized.split("_").filter((token) => token.length > 0);
-  return SENSITIVE_KEYWORDS.some((keyword) => normalized === keyword || normalized.endsWith(`_${keyword}`) || tokens.includes(keyword));
-}
-function redactInlineSensitiveAssignments(input2) {
-  const withoutAssignments = input2.replaceAll(INLINE_SENSITIVE_ASSIGNMENT_PATTERN, (_match, key, delimiter) => `${key}${delimiter}[redacted]`);
-  return withoutAssignments.replaceAll(INLINE_SENSITIVE_FLAG_PATTERN, (_match, flag, delimiter) => `${flag}${delimiter}[redacted]`);
-}
-function redactAbsolutePathTokens(input2) {
-  return input2.replaceAll(ABSOLUTE_PATH_TOKEN_PATTERN, (_match, prefix) => `${prefix}[redacted_path]`);
-}
-function sanitizeCommonSensitiveTokens(input2) {
-  const withoutEmails = input2.replaceAll(EMAIL_PATTERN, "[redacted_email]");
-  const withoutBearer = withoutEmails.replaceAll(BEARER_TOKEN_PATTERN, "bearer [redacted_token]");
-  return withoutBearer.replaceAll(PRIVATE_IP_PATTERN, "[redacted_ip]");
-}
-function sanitizeStringRedacted(input2) {
-  const withoutCommonSensitiveTokens = sanitizeCommonSensitiveTokens(input2);
-  const withoutInlineSecrets = redactInlineSensitiveAssignments(withoutCommonSensitiveTokens);
-  const withoutAbsolutePaths = redactAbsolutePathTokens(withoutInlineSecrets);
-  const trimmed = withoutAbsolutePaths.trim();
-  if (trimmed.startsWith("/") && trimmed.length > 1) {
-    return "[redacted_path]";
-  }
-  if (withoutAbsolutePaths.length > 512) {
-    return `${withoutAbsolutePaths.slice(0, 509)}...`;
-  }
-  return withoutAbsolutePaths;
-}
-function sanitizeStringMax(input2) {
-  const withoutCommonSensitiveTokens = sanitizeCommonSensitiveTokens(input2);
-  const withoutInlineSecrets = redactInlineSensitiveAssignments(withoutCommonSensitiveTokens);
-  const withoutAbsolutePaths = redactAbsolutePathTokens(withoutInlineSecrets);
-  const trimmed = withoutAbsolutePaths.trim();
-  if (trimmed.startsWith("/") && trimmed.length > 1) {
-    return "[redacted_path]";
-  }
-  if (withoutAbsolutePaths.length > 2048) {
-    return `${withoutAbsolutePaths.slice(0, 2045)}...`;
-  }
-  return withoutAbsolutePaths;
-}
-function sanitizeString(input2, captureLevel = "redacted") {
-  if (captureLevel === "max") {
-    return sanitizeStringMax(input2);
-  }
-  return sanitizeStringRedacted(input2);
-}
-function sanitizeValue(value, keyHint, captureLevel = "redacted", depth = 0) {
-  if (keyHint && isSensitiveKey(keyHint)) {
-    return "[redacted]";
-  }
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return sanitizeString(value, captureLevel);
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (depth >= TELEMETRY_SANITIZE_MAX_DEPTH) {
-    return "[depth_truncated]";
-  }
-  if (Array.isArray(value)) {
-    return value.slice(0, TELEMETRY_SANITIZE_MAX_ARRAY_ITEMS).map((entry) => sanitizeValue(entry, void 0, captureLevel, depth + 1));
-  }
-  if (typeof value === "object") {
-    const record = value;
-    const sanitized = {};
-    for (const [key, nested] of Object.entries(record)) {
-      sanitized[key] = sanitizeValue(nested, key, captureLevel, depth + 1);
-    }
-    return sanitized;
-  }
-  return String(value);
-}
-function sanitizeCommandArgs(args, captureLevel = "redacted") {
-  const sanitized = [];
-  let nextIsSensitiveValue = false;
-  for (const rawArg of args) {
-    const arg = sanitizeString(rawArg, captureLevel);
-    if (nextIsSensitiveValue) {
-      sanitized.push("[redacted]");
-      nextIsSensitiveValue = false;
-      continue;
-    }
-    if (arg.startsWith("--")) {
-      const withoutPrefix = arg.slice(2);
-      const delimiterIndex = withoutPrefix.indexOf("=");
-      if (delimiterIndex >= 0) {
-        const key = withoutPrefix.slice(0, delimiterIndex);
-        const value = withoutPrefix.slice(delimiterIndex + 1);
-        if (isSensitiveKey(key)) {
-          sanitized.push(`--${key}=[redacted]`);
-        } else {
-          sanitized.push(`--${key}=${sanitizeString(value, captureLevel)}`);
-        }
-        continue;
-      }
-      if (isSensitiveKey(withoutPrefix)) {
-        sanitized.push(`--${withoutPrefix}`);
-        nextIsSensitiveValue = true;
-        continue;
-      }
-    }
-    sanitized.push(arg);
-  }
-  return sanitized;
-}
-function normalizeCaptureLevel(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (normalized === "minimal" || normalized === "redacted" || normalized === "max") {
-    return normalized;
-  }
-  return "redacted";
-}
-function parseBooleanTrueLike(value) {
-  return BOOLEAN_TRUE_VALUES.has((value ?? "").trim().toLowerCase());
-}
-function normalizePmVersion(value) {
-  const trimmed = value?.trim() ?? "";
-  return trimmed.length > 0 ? trimmed : "0.0.0";
-}
-function normalizeTelemetryErrorCode(value) {
-  const normalized = value?.trim();
-  return normalized && normalized.length > 0 ? normalized : void 0;
-}
-function normalizeTelemetryExitCode(exitCode, ok) {
-  if (Number.isFinite(exitCode)) {
-    return Math.max(0, Math.trunc(exitCode ?? 0));
-  }
-  return ok ? 0 : 1;
-}
-function normalizeTelemetryErrorCategory(params) {
-  if (params.ok) {
-    return void 0;
-  }
-  if (typeof params.errorCategory === "string" && params.errorCategory.trim().length > 0) {
-    return params.errorCategory;
-  }
-  if (typeof params.errorCode === "string" && params.errorCode.trim().length > 0) {
-    return resolveTelemetryErrorCategory(params.errorCode);
-  }
-  return "unknown";
-}
-function resolveTelemetrySourceContext(globalOptions) {
-  const override = (process.env[PM_TELEMETRY_SOURCE_CONTEXT_ENV] ?? "").trim().toLowerCase();
-  if (PM_TELEMETRY_SOURCE_CONTEXT_SET.has(override)) {
-    return {
-      source_context: override,
-      source_context_source: "env_override"
-    };
-  }
-  const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
-  if (typeof process.env.VITEST === "string" || typeof process.env.VITEST_WORKER_ID === "string" || nodeEnv === "test") {
-    return {
-      source_context: "test",
-      source_context_source: "inferred"
-    };
-  }
-  const nonTty = process.stdin.isTTY !== true || process.stdout.isTTY !== true;
-  const ci = parseBooleanTrueLike(process.env.CI);
-  const scriptLikeMode = globalOptions.json === true || globalOptions.quiet === true;
-  if (nonTty || ci || scriptLikeMode) {
-    return {
-      source_context: "automation",
-      source_context_source: "inferred"
-    };
-  }
-  return {
-    source_context: "user",
-    source_context_source: "inferred"
-  };
-}
-function hashWithInstallationId(installationId, value) {
-  return crypto.createHash("sha256").update(`${installationId}:${value}`).digest("hex");
-}
-function normalizeForHash(value, depth = 0) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (depth >= TELEMETRY_SANITIZE_MAX_DEPTH) {
-    return "[depth_truncated]";
-  }
-  if (Array.isArray(value)) {
-    return value.slice(0, TELEMETRY_SANITIZE_MAX_ARRAY_ITEMS).map((entry) => normalizeForHash(entry, depth + 1));
-  }
-  if (typeof value === "object") {
-    const record = value;
-    const normalized = {};
-    const sortedKeys = Object.keys(record).sort((left, right) => left.localeCompare(right));
-    for (const key of sortedKeys) {
-      normalized[key] = normalizeForHash(record[key], depth + 1);
-    }
-    return normalized;
-  }
-  return String(value);
-}
-function hashTelemetryValue(installationId, value) {
-  return hashWithInstallationId(installationId, JSON.stringify(normalizeForHash(value)));
-}
-function hashCommandArgs(installationId, args) {
-  return {
-    hashes: args.map((arg) => hashWithInstallationId(installationId, arg)),
-    digest: hashWithInstallationId(installationId, args.join("\0"))
-  };
-}
-function hashTelemetryErrorFingerprint(installationId, command, errorCode2, errorMessage) {
-  const normalizedMessage = sanitizeString(errorMessage ?? "", "redacted");
-  const fingerprintSource = `${command}\0${errorCode2 ?? "unknown_error"}\0${normalizedMessage}`;
-  return hashWithInstallationId(installationId, fingerprintSource);
-}
-function telemetryDisabledByEnvironment() {
-  return PM_TELEMETRY_DISABLED_VALUES.has((process.env[PM_TELEMETRY_DISABLED_ENV] ?? "").trim().toLowerCase()) || PM_TELEMETRY_DISABLED_VALUES.has((process.env[PM_NO_TELEMETRY_ENV] ?? "").trim().toLowerCase());
-}
-function resolveOtelTracesEndpoint() {
-  if (PM_TELEMETRY_OTEL_DISABLED_VALUES.has((process.env[PM_TELEMETRY_OTEL_DISABLED_ENV] ?? "").trim().toLowerCase())) {
-    return null;
-  }
-  const directEndpoint = (process.env[OTEL_TRACES_ENDPOINT_ENV] ?? "").trim();
-  if (directEndpoint.length > 0) {
-    try {
-      return new URL(directEndpoint).toString();
-    } catch {
-      return null;
-    }
-  }
-  const baseEndpoint = (process.env[OTEL_BASE_ENDPOINT_ENV] ?? "").trim();
-  if (baseEndpoint.length === 0) {
-    return null;
-  }
-  try {
-    const url = new URL(baseEndpoint);
-    const normalizedPath = url.pathname.replace(/\/+$/, "");
-    if (!normalizedPath.endsWith("/v1/traces")) {
-      url.pathname = `${normalizedPath.length === 0 ? "" : normalizedPath}/v1/traces`;
-    }
-    return url.toString();
-  } catch {
-    return null;
-  }
-}
-function isoToUnixNano(iso) {
-  const parsedMs = Date.parse(iso);
-  const epochMs = Number.isNaN(parsedMs) ? Date.now() : parsedMs;
-  return `${BigInt(epochMs) * 1000000n}`;
-}
-function otlpStringAttribute(key, value) {
-  return {
-    key,
-    value: { stringValue: value }
-  };
-}
-function otlpBoolAttribute(key, value) {
-  return {
-    key,
-    value: { boolValue: value }
-  };
-}
-function otlpIntAttribute(key, value) {
-  return {
-    key,
-    value: { intValue: String(Math.max(0, Math.trunc(value))) }
-  };
-}
-async function exportLocalOtelSpan(activeCommand, outcome, finishedAtIso, durationMs) {
-  if (typeof activeCommand.otel_traces_endpoint !== "string" || activeCommand.otel_traces_endpoint.trim().length === 0 || typeof activeCommand.otel_trace_id !== "string" || activeCommand.otel_trace_id.length === 0 || typeof activeCommand.otel_span_id !== "string" || activeCommand.otel_span_id.length === 0) {
-    return;
-  }
-  const serviceNameCandidate = sanitizeString((process.env[OTEL_SERVICE_NAME_ENV] ?? "").trim());
-  const serviceName = serviceNameCandidate.length > 0 ? serviceNameCandidate : "pm-cli";
-  const normalizedExitCode = normalizeTelemetryExitCode(outcome.exit_code, outcome.ok);
-  const normalizedErrorCode = normalizeTelemetryErrorCode(outcome.error_code);
-  const normalizedErrorCategory = normalizeTelemetryErrorCategory({
-    ok: outcome.ok,
-    errorCode: normalizedErrorCode,
-    errorCategory: outcome.error_category
-  });
-  const attributes = [
-    otlpStringAttribute("pm.command", sanitizeString(activeCommand.command)),
-    otlpStringAttribute("pm.version", activeCommand.pm_version),
-    otlpStringAttribute("pm.source_context", activeCommand.source_context),
-    otlpStringAttribute("pm.source_context_source", activeCommand.source_context_source),
-    otlpStringAttribute("pm.installation_id", activeCommand.installation_id),
-    otlpStringAttribute("pm.session_id", PROCESS_SESSION_ID),
-    otlpStringAttribute("pm.pm_root_hash", activeCommand.pm_root_hash),
-    otlpStringAttribute("pm.cwd_hash", activeCommand.cwd_hash),
-    otlpBoolAttribute("pm.ok", outcome.ok),
-    otlpIntAttribute("pm.exit_code", normalizedExitCode),
-    otlpIntAttribute("pm.duration_ms", durationMs)
-  ];
-  if (typeof normalizedErrorCode === "string") {
-    attributes.push(otlpStringAttribute("pm.error_code", normalizedErrorCode));
-  }
-  if (typeof normalizedErrorCategory === "string") {
-    attributes.push(otlpStringAttribute("pm.error_category", normalizedErrorCategory));
-  }
-  if (typeof outcome.error === "string" && outcome.error.trim().length > 0) {
-    attributes.push(otlpStringAttribute("pm.error", sanitizeString(outcome.error)));
-  }
-  const payload = {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: [otlpStringAttribute("service.name", serviceName)]
-        },
-        scopeSpans: [
-          {
-            scope: {
-              name: "pm-cli.telemetry",
-              version: "1"
-            },
-            spans: [
-              {
-                traceId: activeCommand.otel_trace_id,
-                spanId: activeCommand.otel_span_id,
-                name: `pm.command.${sanitizeString(activeCommand.command)}`,
-                kind: 1,
-                startTimeUnixNano: isoToUnixNano(activeCommand.started_at),
-                endTimeUnixNano: isoToUnixNano(finishedAtIso),
-                attributes,
-                status: {
-                  code: outcome.ok ? 1 : 2,
-                  message: outcome.ok ? "" : sanitizeString(outcome.error ?? "command_failed")
-                }
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  };
-  const response = await fetch(activeCommand.otel_traces_endpoint, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json"
-    },
-    body: JSON.stringify(payload),
-    signal: AbortSignal.timeout(TELEMETRY_HTTP_TIMEOUT_MS)
-  });
-  if (!response.ok) {
-    throw new Error(`local_otel_export_http_${response.status}`);
-  }
-}
-function summarizeResult(result, captureLevel = "redacted") {
-  if (result === null || result === void 0) {
-    return { type: "nullish" };
-  }
-  if (typeof result === "string") {
-    return { type: "string", value: sanitizeString(result, captureLevel) };
-  }
-  if (typeof result === "number" || typeof result === "boolean") {
-    return { type: typeof result, value: result };
-  }
-  if (Array.isArray(result)) {
-    return {
-      type: "array",
-      length: result.length,
-      sample: result.slice(0, 5).map((entry) => sanitizeValue(entry, void 0, captureLevel))
-    };
-  }
-  if (typeof result === "object") {
-    const record = result;
-    const keys = Object.keys(record).sort((left, right) => left.localeCompare(right));
-    const sanitized = {};
-    let previewBytes = 0;
-    for (const key of keys.slice(0, 25)) {
-      const sanitizedValue = sanitizeValue(record[key], key, captureLevel);
-      const entrySize = JSON.stringify(sanitizedValue)?.length ?? 0;
-      if (previewBytes + entrySize > TELEMETRY_RESULT_PREVIEW_MAX_BYTES) {
-        sanitized[key] = "[preview_truncated]";
-        break;
-      }
-      previewBytes += entrySize;
-      sanitized[key] = sanitizedValue;
-    }
-    return {
-      type: "object",
-      key_count: keys.length,
-      keys_preview: keys.slice(0, 50),
-      preview: sanitized
-    };
-  }
-  return { type: typeof result, value: String(result) };
-}
-function buildCommandStartPayload(params) {
-  const { captureLevel, context, pmVersion, sourceContext, pmRootHash, cwdHash, installationId } = params;
-  const commandTaxonomy = deriveTelemetryCommandTaxonomy(context.command);
-  const hashedArgs = hashCommandArgs(installationId, context.args);
-  const commandInvocationDigest = hashWithInstallationId(installationId, `${context.command}\0${context.args.join("\0")}`);
-  const commandOptionsDigest = hashTelemetryValue(installationId, context.options);
-  const globalOptionsDigest = hashTelemetryValue(installationId, context.global);
-  if (captureLevel === "minimal") {
-    return {
-      capture_level: captureLevel,
-      pm_version: pmVersion,
-      source_context: sourceContext.source_context,
-      source_context_source: sourceContext.source_context_source,
-      command_taxonomy: commandTaxonomy,
-      command_args_digest: hashedArgs.digest,
-      command_invocation_digest: commandInvocationDigest,
-      command_options_digest: commandOptionsDigest,
-      global_options_digest: globalOptionsDigest
-    };
-  }
-  return {
-    pm_version: pmVersion,
-    source_context: sourceContext.source_context,
-    source_context_source: sourceContext.source_context_source,
-    command_taxonomy: commandTaxonomy,
-    command_args: sanitizeCommandArgs(context.args, captureLevel),
-    command_args_hashes: hashedArgs.hashes,
-    command_args_digest: hashedArgs.digest,
-    command_invocation_digest: commandInvocationDigest,
-    command_options: sanitizeValue(context.options, void 0, captureLevel),
-    command_options_digest: commandOptionsDigest,
-    global_options: sanitizeValue(context.global, void 0, captureLevel),
-    global_options_digest: globalOptionsDigest,
-    pm_root_hash: pmRootHash,
-    cwd_hash: cwdHash,
-    capture_level: captureLevel,
-    runtime: {
-      node: process.version,
-      platform: process.platform,
-      arch: process.arch,
-      hostname_hash: hashWithInstallationId(installationId, os.hostname()),
-      stdin_tty: process.stdin.isTTY === true,
-      stdout_tty: process.stdout.isTTY === true
-    }
-  };
-}
-function buildCommandFinishPayload(params) {
-  const { captureLevel, pmVersion, sourceContext, outcome, durationMs, startedAt, command, installationId, commandTaxonomy, exitCode, errorCode: errorCode2, errorCategory, commandResolution, resolutionStage } = params;
-  const errorFingerprint = outcome.ok === false ? hashTelemetryErrorFingerprint(installationId, command, errorCode2, outcome.error) : void 0;
-  if (captureLevel === "minimal") {
-    return {
-      capture_level: captureLevel,
-      pm_version: pmVersion,
-      source_context: sourceContext.source_context,
-      source_context_source: sourceContext.source_context_source,
-      command_taxonomy: commandTaxonomy,
-      command_resolution: commandResolution,
-      resolution_stage: resolutionStage,
-      ok: outcome.ok,
-      exit_code: exitCode,
-      error_code: errorCode2,
-      error_category: errorCategory,
-      error: outcome.error ? sanitizeString(outcome.error, "redacted") : void 0,
-      error_fingerprint: errorFingerprint,
-      duration_ms: durationMs
-    };
-  }
-  return {
-    capture_level: captureLevel,
-    pm_version: pmVersion,
-    source_context: sourceContext.source_context,
-    source_context_source: sourceContext.source_context_source,
-    command_taxonomy: commandTaxonomy,
-    command_resolution: commandResolution,
-    resolution_stage: resolutionStage,
-    ok: outcome.ok,
-    exit_code: exitCode,
-    error_code: errorCode2,
-    error_category: errorCategory,
-    error: outcome.error ? sanitizeString(outcome.error, captureLevel) : void 0,
-    error_fingerprint: errorFingerprint,
-    duration_ms: durationMs,
-    started_at: startedAt,
-    result_summary: summarizeResult(outcome.result, captureLevel)
-  };
-}
-function buildCommandErrorPayload(params) {
-  const { captureLevel, pmVersion, sourceContext, command, commandTaxonomy, commandResolution, resolutionStage, args, options, pmRootHash, cwdHash, installationId, errorCode: errorCode2, errorMessage, errorCategory, exitCode } = params;
-  const attemptedArgHashes = hashCommandArgs(installationId, args);
-  const attemptedCommandDigest = hashWithInstallationId(installationId, command);
-  const attemptedOptionsDigest = hashTelemetryValue(installationId, options);
-  const errorFingerprint = hashTelemetryErrorFingerprint(installationId, command, errorCode2, errorMessage);
-  if (captureLevel === "minimal") {
-    return {
-      capture_level: captureLevel,
-      pm_version: pmVersion,
-      source_context: sourceContext.source_context,
-      source_context_source: sourceContext.source_context_source,
-      command_taxonomy: commandTaxonomy,
-      command_resolution: commandResolution,
-      resolution_stage: resolutionStage,
-      attempted_command_digest: attemptedCommandDigest,
-      attempted_args_digest: attemptedArgHashes.digest,
-      attempted_options_digest: attemptedOptionsDigest,
-      error_code: errorCode2,
-      error_category: errorCategory,
-      exit_code: exitCode,
-      error: sanitizeString(errorMessage, "redacted"),
-      error_fingerprint: errorFingerprint
-    };
-  }
-  return {
-    capture_level: captureLevel,
-    pm_version: pmVersion,
-    source_context: sourceContext.source_context,
-    source_context_source: sourceContext.source_context_source,
-    command_taxonomy: commandTaxonomy,
-    command_resolution: commandResolution,
-    resolution_stage: resolutionStage,
-    attempted_command: sanitizeString(command, captureLevel),
-    attempted_command_digest: attemptedCommandDigest,
-    attempted_args: sanitizeCommandArgs(args, captureLevel),
-    attempted_args_hashes: attemptedArgHashes.hashes,
-    attempted_args_digest: attemptedArgHashes.digest,
-    attempted_options: sanitizeValue(options, void 0, captureLevel),
-    attempted_options_digest: attemptedOptionsDigest,
-    error_code: errorCode2,
-    error_category: errorCategory,
-    exit_code: exitCode,
-    error: sanitizeString(errorMessage, captureLevel),
-    error_fingerprint: errorFingerprint,
-    pm_root_hash: pmRootHash,
-    cwd_hash: cwdHash,
-    runtime: {
-      node: process.version,
-      platform: process.platform,
-      arch: process.arch,
-      hostname_hash: hashWithInstallationId(installationId, os.hostname()),
-      stdin_tty: process.stdin.isTTY === true,
-      stdout_tty: process.stdout.isTTY === true
-    }
-  };
-}
-async function ensureInstallationId(globalPmRoot) {
-  const settings = await readSettings(globalPmRoot);
-  let changed = false;
-  if (settings.telemetry.installation_id.trim().length === 0) {
-    settings.telemetry.installation_id = crypto.randomUUID();
-    changed = true;
-  }
-  if (changed) {
-    await writeSettings(globalPmRoot, settings, "telemetry:install_id");
-  }
-  return {
-    installationId: settings.telemetry.installation_id,
-    endpoint: settings.telemetry.endpoint,
-    retentionDays: Math.max(1, Math.trunc(settings.telemetry.retention_days))
-  };
-}
-async function enqueueTelemetryEvent(globalPmRoot, event) {
-  const queued = {
-    event,
-    attempts: 0
-  };
-  let serialized = JSON.stringify(queued);
-  if (serialized.length > TELEMETRY_MAX_EVENT_BYTES) {
-    const trimmed = { ...event, payload: { ...event.payload, result_summary: { truncated: true, reason: "payload_size_exceeded", original_bytes: serialized.length } } };
-    const trimmedQueued = { event: trimmed, attempts: 0 };
-    serialized = JSON.stringify(trimmedQueued);
-  }
-  await withQueueMutation(async () => {
-    await appendLineAtomic(queuePath(globalPmRoot), serialized);
-  });
-}
-function parseQueueLines(raw) {
-  const entries = [];
-  for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed && typeof parsed === "object" && parsed.event && typeof parsed.event === "object" && typeof parsed.attempts === "number") {
-        entries.push(parsed);
-      }
-    } catch {
-    }
-  }
-  return entries;
-}
-function nextRetryIso(attempts) {
-  const delay = Math.min(TELEMETRY_RETRY_BASE_DELAY_MS * 2 ** Math.max(attempts - 1, 0), TELEMETRY_MAX_RETRY_DELAY_MS);
-  return new Date(Date.now() + delay).toISOString();
-}
-function isDueForRetry(entry) {
-  if (typeof entry.next_attempt_after !== "string" || entry.next_attempt_after.trim().length === 0) {
-    return true;
-  }
-  const dueAtMs = Date.parse(entry.next_attempt_after);
-  if (Number.isNaN(dueAtMs)) {
-    return true;
-  }
-  return dueAtMs <= Date.now();
-}
-function retentionCutoffMs(retentionDays) {
-  const normalizedDays = Number.isFinite(retentionDays) ? Math.max(1, Math.trunc(retentionDays)) : 1;
-  return Date.now() - normalizedDays * MILLISECONDS_PER_DAY;
-}
-function isExpiredQueueEntry(entry, cutoffMs) {
-  const occurredAt = entry.event?.occurred_at;
-  if (typeof occurredAt !== "string" || occurredAt.trim().length === 0) {
-    return false;
-  }
-  const occurredAtMs = Date.parse(occurredAt);
-  if (Number.isNaN(occurredAtMs)) {
-    return false;
-  }
-  return occurredAtMs < cutoffMs;
-}
-function pruneExpiredQueueEntries(entries, retentionDays) {
-  const cutoffMs = retentionCutoffMs(retentionDays);
-  const retained = [];
-  let prunedCount = 0;
-  for (const entry of entries) {
-    const serializedSize = JSON.stringify(entry).length;
-    const oversized = serializedSize > TELEMETRY_MAX_EVENT_BYTES;
-    if (oversized || isExpiredQueueEntry(entry, cutoffMs) || entry.attempts >= TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS) {
-      prunedCount += 1;
-      continue;
-    }
-    retained.push(entry);
-  }
-  return { entries: retained, prunedCount };
-}
-async function rewriteQueue(globalPmRoot, entries) {
-  const serialized = entries.map((entry) => JSON.stringify(entry)).join("\n");
-  const contents = serialized.length > 0 ? `${serialized}
-` : "";
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      await writeFileAtomic(queuePath(globalPmRoot), contents);
-      return;
-    } catch (error) {
-      const retryDelay = TELEMETRY_QUEUE_REWRITE_RETRY_DELAYS_MS[attempt];
-      if (retryDelay === void 0 || !isRetryableQueueRewriteError(error)) {
-        throw error;
-      }
-      await sleep(retryDelay);
-    }
-  }
-}
-function isRetryableQueueRewriteError(error) {
-  if (typeof error !== "object" || error === null || !("code" in error)) {
-    return false;
-  }
-  const code = error.code;
-  return code === "EACCES" || code === "EBUSY" || code === "EPERM";
-}
-function sleep(milliseconds) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, milliseconds);
-  });
-}
-async function cleanupTelemetryQueueTempOrphans(globalPmRoot, maxAgeMs = TELEMETRY_QUEUE_TMP_ORPHAN_MAX_AGE_MS) {
-  try {
-    const dirPath = telemetryRuntimeDirectory(globalPmRoot);
-    const entries = await readdir(dirPath, { withFileTypes: true });
-    const cutoffMs = Date.now() - Math.max(0, maxAgeMs);
-    await Promise.all(entries.filter((entry) => entry.isFile() && /^\.events\.jsonl\.\d+\.\d+\.[a-f0-9]+\.tmp$/.test(entry.name)).map(async (entry) => {
-      const candidate = path.join(dirPath, entry.name);
-      const candidateStats = await stat(candidate);
-      if (candidateStats.mtimeMs < cutoffMs) {
-        await rm(candidate, { force: true });
-      }
-    }));
-  } catch {
-  }
-}
-async function withQueueMutation(operation) {
-  const run = _queueMutationPromise.catch(() => {
-  }).then(operation);
-  _queueMutationPromise = run.catch(() => {
-  });
-  return run;
-}
-async function readCurrentQueueEntries(globalPmRoot) {
-  const raw = await readFileIfExists(queuePath(globalPmRoot));
-  if (raw === null || raw.trim().length === 0) {
-    return [];
-  }
-  return parseQueueLines(raw);
-}
-async function removeFlushedEntriesFromCurrentQueue(globalPmRoot, flushedIds, retentionDays) {
-  return withQueueMutation(async () => {
-    const currentEntries = await readCurrentQueueEntries(globalPmRoot);
-    const { entries: retainedEntries } = pruneExpiredQueueEntries(currentEntries, retentionDays);
-    const remaining = retainedEntries.filter((entry) => !flushedIds.has(entry.event.event_id));
-    await rewriteQueue(globalPmRoot, remaining);
-    return remaining;
-  });
-}
-async function markFailedEntriesInCurrentQueue(globalPmRoot, failedIds, attemptTime, retentionDays) {
-  return withQueueMutation(async () => {
-    const currentEntries = await readCurrentQueueEntries(globalPmRoot);
-    const { entries: retainedEntries } = pruneExpiredQueueEntries(currentEntries, retentionDays);
-    const retried = retainedEntries.map((entry) => {
-      if (!failedIds.has(entry.event.event_id)) {
-        return entry;
-      }
-      const attempts = entry.attempts + 1;
-      return {
-        ...entry,
-        attempts,
-        last_attempt_at: attemptTime,
-        next_attempt_after: nextRetryIso(attempts)
-      };
-    });
-    await rewriteQueue(globalPmRoot, retried);
-    return retried;
-  });
-}
-async function flushQueue(globalPmRoot, endpoint, retentionDays) {
-  await cleanupTelemetryQueueTempOrphans(globalPmRoot);
-  const normalizedEndpoint = endpoint.trim();
-  if (normalizedEndpoint.length === 0) {
-    return;
-  }
-  const raw = await readFileIfExists(queuePath(globalPmRoot));
-  if (raw === null || raw.trim().length === 0) {
-    await writeRuntimeState(globalPmRoot, {
-      endpoint: normalizedEndpoint,
-      queue_entries: 0
-    });
-    return;
-  }
-  const queueEntries = parseQueueLines(raw);
-  if (queueEntries.length === 0) {
-    await writeRuntimeState(globalPmRoot, {
-      endpoint: normalizedEndpoint,
-      queue_entries: 0
-    });
-    return;
-  }
-  const { entries: retainedEntries, prunedCount } = pruneExpiredQueueEntries(queueEntries, retentionDays);
-  if (retainedEntries.length === 0) {
-    if (prunedCount > 0) {
-      await rewriteQueue(globalPmRoot, []);
-    }
-    await writeRuntimeState(globalPmRoot, {
-      endpoint: normalizedEndpoint,
-      queue_entries: 0
-    });
-    return;
-  }
-  const dueEntries = retainedEntries.filter((entry) => isDueForRetry(entry)).slice(0, TELEMETRY_FLUSH_BATCH_SIZE);
-  if (dueEntries.length === 0) {
-    if (prunedCount > 0) {
-      await rewriteQueue(globalPmRoot, retainedEntries);
-    }
-    await writeRuntimeState(globalPmRoot, {
-      endpoint: normalizedEndpoint,
-      queue_entries: retainedEntries.length
-    });
-    return;
-  }
-  const dueIds = new Set(dueEntries.map((entry) => entry.event.event_id));
-  const attemptTime = nowIso();
-  const requestHeaders = {
-    "content-type": "application/json"
-  };
-  const ingestKey = process.env.PM_TELEMETRY_INGEST_KEY?.trim();
-  if (ingestKey) {
-    requestHeaders["x-pm-telemetry-key"] = ingestKey;
-  }
-  try {
-    const response = await fetch(normalizedEndpoint, {
-      method: "POST",
-      headers: requestHeaders,
-      body: JSON.stringify({
-        schema_version: TELEMETRY_SCHEMA_VERSION,
-        events: dueEntries.map((entry) => entry.event)
-      }),
-      signal: AbortSignal.timeout(TELEMETRY_HTTP_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      throw new Error(`telemetry_flush_http_${response.status}`);
-    }
-  } catch (error) {
-    const retried = await markFailedEntriesInCurrentQueue(globalPmRoot, dueIds, attemptTime, retentionDays);
-    const errorMessage = (() => {
-      if (error instanceof Error) {
-        return sanitizeString(error.message, "redacted");
-      }
-      return "telemetry_flush_failed";
-    })();
-    await writeRuntimeState(globalPmRoot, {
-      endpoint: normalizedEndpoint,
-      queue_entries: retried.length,
-      last_attempted_flush_at: attemptTime,
-      last_failed_flush_at: attemptTime,
-      last_failed_flush_error: errorMessage
-    });
-    return;
-  }
-  try {
-    const remaining = await removeFlushedEntriesFromCurrentQueue(globalPmRoot, dueIds, retentionDays);
-    await writeRuntimeState(globalPmRoot, {
-      endpoint: normalizedEndpoint,
-      queue_entries: remaining.length,
-      last_attempted_flush_at: attemptTime,
-      last_successful_flush_at: attemptTime,
-      last_failed_flush_at: void 0,
-      last_failed_flush_error: void 0
-    });
-  } catch (error) {
-    const errorMessage = (() => {
-      if (error instanceof Error) {
-        return sanitizeString(error.message, "redacted");
-      }
-      return "telemetry_flush_failed";
-    })();
-    const currentEntries = await readCurrentQueueEntries(globalPmRoot).catch(() => retainedEntries);
-    await writeRuntimeState(globalPmRoot, {
-      endpoint: normalizedEndpoint,
-      queue_entries: currentEntries.length,
-      last_attempted_flush_at: attemptTime,
-      last_failed_flush_at: attemptTime,
-      last_failed_flush_error: errorMessage
-    });
-  }
-}
-function isFreshDirectoryLock(lockPath, staleMs) {
-  try {
-    return Date.now() - statSync(lockPath).mtimeMs < staleMs;
-  } catch {
-    return false;
-  }
-}
-function removeDirectoryLockBestEffort(lockPath) {
-  try {
-    rmSync(lockPath, { recursive: true, force: true });
-  } catch {
-  }
-}
-function errorCode(error) {
-  if (typeof error !== "object" || error === null || !("code" in error)) {
-    return void 0;
-  }
-  const code = error.code;
-  return typeof code === "string" ? code : void 0;
-}
-function createDirectoryLock(lockPath) {
-  try {
-    mkdirSync(lockPath);
-    return true;
-  } catch (error) {
-    const code = errorCode(error);
-    if (code === "EEXIST") {
-      return false;
-    }
-    if (code !== "ENOENT") {
-      return false;
-    }
-  }
-  try {
-    mkdirSync(path.dirname(lockPath), { recursive: true });
-    mkdirSync(lockPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function acquireTelemetryFlushSpawnGate(globalPmRoot) {
-  if (isFreshDirectoryLock(flushLockPath(globalPmRoot), TELEMETRY_FLUSH_LOCK_STALE_MS)) {
-    return false;
-  }
-  const lockPath = flushSpawnLockPath(globalPmRoot);
-  try {
-    if (Date.now() - statSync(lockPath).mtimeMs < TELEMETRY_FLUSH_SPAWN_LOCK_STALE_MS) {
-      return false;
-    }
-    removeDirectoryLockBestEffort(lockPath);
-  } catch (error) {
-    if (errorCode(error) !== "ENOENT") {
-      return false;
-    }
-  }
-  return createDirectoryLock(lockPath);
-}
-function releaseTelemetryFlushSpawnGate(globalPmRoot) {
-  removeDirectoryLockBestEffort(flushSpawnLockPath(globalPmRoot));
-}
-function scheduleTelemetryFlush(globalPmRoot, endpoint, retentionDays) {
-  if (shouldFlushInline()) {
-    const previousFlush = _lastFlushPromise;
-    const nextFlush = flushQueue(globalPmRoot, endpoint, retentionDays).catch(() => {
-    });
-    _lastFlushPromise = Promise.allSettled([previousFlush, nextFlush]).then(() => {
-    });
-    return;
-  }
-  try {
-    const acquiredSpawnGate = acquireTelemetryFlushSpawnGate(globalPmRoot);
-    if (!acquiredSpawnGate) {
-      return;
-    }
-    const child = spawn(process.execPath, [telemetryFlushRunnerPath()], {
-      detached: true,
-      stdio: "ignore",
-      env: {
-        ...process.env,
-        PM_GLOBAL_PATH: globalPmRoot,
-        [PM_TELEMETRY_FLUSH_CHILD_ENV]: "1"
-      }
-    });
-    child.unref();
-  } catch {
-    releaseTelemetryFlushSpawnGate(globalPmRoot);
-  }
-}
-async function startTelemetryCommand(context) {
-  if (telemetryDisabledByEnvironment()) {
-    return null;
-  }
-  try {
-    const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-    const settings = await readSettings(globalPmRoot);
-    if (!settings.telemetry.enabled) {
-      return null;
-    }
-    const captureLevel = normalizeCaptureLevel(settings.telemetry.capture_level);
-    const { installationId, endpoint, retentionDays } = await ensureInstallationId(globalPmRoot);
-    const pmVersion = normalizePmVersion(context.pm_version);
-    const sourceContext = resolveTelemetrySourceContext(context.global);
-    const pmRootHash = hashWithInstallationId(installationId, context.pm_root);
-    const cwdHash = hashWithInstallationId(installationId, process.cwd());
-    const otelTracesEndpoint = resolveOtelTracesEndpoint();
-    const occurredAt = nowIso();
-    const event = {
-      schema_version: TELEMETRY_SCHEMA_VERSION,
-      event_id: crypto.randomUUID(),
-      event_type: "command_start",
-      occurred_at: occurredAt,
-      installation_id: installationId,
-      session_id: PROCESS_SESSION_ID,
-      command: context.command,
-      payload: buildCommandStartPayload({
-        captureLevel,
-        context,
-        pmVersion,
-        sourceContext,
-        pmRootHash,
-        cwdHash,
-        installationId
-      })
-    };
-    await enqueueTelemetryEvent(globalPmRoot, event);
-    scheduleTelemetryFlush(globalPmRoot, endpoint, retentionDays);
-    const commandTaxonomy = deriveTelemetryCommandTaxonomy(context.command);
-    return {
-      started_at: occurredAt,
-      started_at_ms: Date.now(),
-      command: context.command,
-      command_taxonomy: commandTaxonomy,
-      pm_version: pmVersion,
-      source_context: sourceContext.source_context,
-      source_context_source: sourceContext.source_context_source,
-      installation_id: installationId,
-      pm_root_hash: pmRootHash,
-      cwd_hash: cwdHash,
-      endpoint,
-      retention_days: retentionDays,
-      global_pm_root: globalPmRoot,
-      capture_level: captureLevel,
-      otel_traces_endpoint: otelTracesEndpoint ?? void 0,
-      otel_trace_id: otelTracesEndpoint ? crypto.randomBytes(16).toString("hex") : void 0,
-      otel_span_id: otelTracesEndpoint ? crypto.randomBytes(8).toString("hex") : void 0
-    };
-  } catch {
-    return null;
-  }
-}
-async function finishTelemetryCommand(activeCommand, outcome) {
-  if (!activeCommand) {
-    return;
-  }
-  try {
-    const finishedAt = nowIso();
-    const durationMs = Math.max(0, Date.now() - activeCommand.started_at_ms);
-    const normalizedErrorCode = normalizeTelemetryErrorCode(inferTelemetryErrorCode({
-      ok: outcome.ok,
-      errorCode: outcome.error_code,
-      errorMessage: outcome.error,
-      exitCode: outcome.exit_code
-    }));
-    const normalizedErrorCategory = normalizeTelemetryErrorCategory({
-      ok: outcome.ok,
-      errorCode: normalizedErrorCode,
-      errorCategory: outcome.error_category
-    });
-    const normalizedExitCode = normalizeTelemetryExitCode(outcome.exit_code, outcome.ok);
-    const commandResolution = outcome.command_resolution ?? deriveTelemetryCommandResolution({
-      ok: outcome.ok,
-      errorCode: normalizedErrorCode,
-      errorCategory: normalizedErrorCategory
-    });
-    const resolutionStage = outcome.resolution_stage ?? "execute";
-    const event = {
-      schema_version: TELEMETRY_SCHEMA_VERSION,
-      event_id: crypto.randomUUID(),
-      event_type: "command_finish",
-      occurred_at: finishedAt,
-      installation_id: activeCommand.installation_id,
-      session_id: PROCESS_SESSION_ID,
-      command: activeCommand.command,
-      payload: buildCommandFinishPayload({
-        captureLevel: activeCommand.capture_level,
-        pmVersion: activeCommand.pm_version,
-        sourceContext: {
-          source_context: activeCommand.source_context,
-          source_context_source: activeCommand.source_context_source
-        },
-        outcome,
-        durationMs,
-        startedAt: activeCommand.started_at,
-        command: activeCommand.command,
-        installationId: activeCommand.installation_id,
-        commandTaxonomy: activeCommand.command_taxonomy,
-        exitCode: normalizedExitCode,
-        errorCode: normalizedErrorCode,
-        errorCategory: normalizedErrorCategory,
-        commandResolution,
-        resolutionStage
-      })
-    };
-    await enqueueTelemetryEvent(activeCommand.global_pm_root, event);
-    scheduleTelemetryFlush(activeCommand.global_pm_root, activeCommand.endpoint, activeCommand.retention_days);
-    void exportLocalOtelSpan(activeCommand, {
-      ...outcome,
-      exit_code: normalizedExitCode,
-      error_code: normalizedErrorCode,
-      error_category: normalizedErrorCategory
-    }, finishedAt, durationMs).catch(() => {
-    });
-  } catch {
-  }
-}
-async function emitTelemetryErrorEvent(context) {
-  if (telemetryDisabledByEnvironment()) {
-    return;
-  }
-  try {
-    const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-    const settings = await readSettings(globalPmRoot);
-    if (!settings.telemetry.enabled) {
-      return;
-    }
-    const captureLevel = normalizeCaptureLevel(settings.telemetry.capture_level);
-    const { installationId, endpoint, retentionDays } = await ensureInstallationId(globalPmRoot);
-    const pmVersion = normalizePmVersion(context.pm_version);
-    const sourceContext = resolveTelemetrySourceContext(context.global);
-    const pmRootHash = hashWithInstallationId(installationId, context.pm_root);
-    const cwdHash = hashWithInstallationId(installationId, process.cwd());
-    const occurredAt = nowIso();
-    const normalizedErrorCode = normalizeTelemetryErrorCode(inferTelemetryErrorCode({
-      ok: false,
-      errorCode: context.error_code,
-      errorMessage: context.error_message,
-      exitCode: context.exit_code
-    })) ?? "unknown_error";
-    const normalizedErrorCategory = context.error_category ?? resolveTelemetryErrorCategory(normalizedErrorCode);
-    const normalizedExitCode = normalizeTelemetryExitCode(context.exit_code, false);
-    const normalizedCommand = context.command.trim().length > 0 ? context.command : "<unknown>";
-    const commandTaxonomy = deriveTelemetryCommandTaxonomy(normalizedCommand);
-    const commandResolution = context.command_resolution ?? deriveTelemetryCommandResolution({
-      ok: false,
-      errorCode: normalizedErrorCode,
-      errorCategory: normalizedErrorCategory
-    });
-    const resolutionStage = context.resolution_stage ?? "unknown";
-    const event = {
-      schema_version: TELEMETRY_SCHEMA_VERSION,
-      event_id: crypto.randomUUID(),
-      event_type: "command_error",
-      occurred_at: occurredAt,
-      installation_id: installationId,
-      session_id: PROCESS_SESSION_ID,
-      command: sanitizeString(normalizedCommand, "redacted"),
-      payload: buildCommandErrorPayload({
-        captureLevel,
-        pmVersion,
-        sourceContext,
-        command: normalizedCommand,
-        commandTaxonomy,
-        commandResolution,
-        resolutionStage,
-        args: context.args,
-        options: context.options,
-        pmRootHash,
-        cwdHash,
-        installationId,
-        errorCode: normalizedErrorCode,
-        errorCategory: normalizedErrorCategory,
-        exitCode: normalizedExitCode,
-        errorMessage: context.error_message
-      })
-    };
-    await enqueueTelemetryEvent(globalPmRoot, event);
-    scheduleTelemetryFlush(globalPmRoot, endpoint, retentionDays);
-  } catch {
-  }
-}
-
 // dist/core/sentry/instrument.js
 import fs from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 !(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;
@@ -1737,7 +319,7 @@ function isKnownNoisyConsoleBreadcrumb(breadcrumb) {
 }
 function resolveCliVersion() {
   try {
-    const candidate = path2.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "package.json");
+    const candidate = path.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "package.json");
     if (fs.existsSync(candidate)) {
       const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
       if (typeof parsed.version === "string")
@@ -2345,7 +927,7 @@ function parseLooseCommandOptions(args) {
 !(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] = "ed65d7db-f9b0-5c53-ba96-b13eb4d6cd35");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "74a0432a-8374-53db-8e95-5ebd38cf8557");
   } catch (e2) {
   }
 })();
@@ -2937,6 +1519,15 @@ var HELP_BY_COMMAND_PATH = {
     why: "Reports tracker-level totals and distribution by type/status.",
     examples: ["pm stats", "pm stats --json"]
   },
+  telemetry: {
+    why: "Inspects and manages local telemetry queue/runtime state for observability diagnostics.",
+    examples: [
+      "pm telemetry status",
+      "pm telemetry stats --limit 10",
+      "pm telemetry flush",
+      "pm telemetry clear"
+    ]
+  },
   health: {
     why: "Validates tracker/runtime health including extension triage, migration, and integrity diagnostics.",
     examples: [
@@ -5126,7 +3717,7 @@ function buildUnknownCommandGuidanceFromRuntime(rawMessage, root, extensionDescr
   const fallbackTopLevel = [...new Set(commandPaths.map((commandPath) => commandPath.split(" ")[0]).filter((segment) => segment.length > 0))];
   fallbackTopLevel.sort((left, right) => left.localeCompare(right));
   const suggestedPaths = (combinedCandidates.length > 0 ? combinedCandidates : fallbackTopLevel).slice(0, 3);
-  const examples = [.../* @__PURE__ */ new Set(["pm --help", ...suggestedPaths.map((path4) => `pm ${path4} --help`)])];
+  const examples = [.../* @__PURE__ */ new Set(["pm --help", ...suggestedPaths.map((path3) => `pm ${path3} --help`)])];
   const optionalPackageHint = resolveOptionalPackageInstallHint(normalizedUnknown);
   const didYouMean = combinedCandidates.length > 0 ? `Did you mean: ${combinedCandidates.slice(0, 3).join(", ")}?` : null;
   return {
@@ -5580,10 +4171,10 @@ var EXPECTED_HANDLED_ERROR_EXIT_CODES = /* @__PURE__ */ new Set([
   EXIT_CODE.CONFLICT
 ]);
 var TRUE_LIKE_ENV_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
-var loadSetupRegistrationModule = createLazyModule(() => import("./chunks/register-setup-YJKIQRKA.js"));
-var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-AG3XKXWL.js"));
-var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-RSMT6DPK.js"));
-var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-Q54JQZUN.js"));
+var loadSetupRegistrationModule = createLazyModule(() => import("./chunks/register-setup-ZHJI2DI3.js"));
+var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-WST76HSQ.js"));
+var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-OA675SOU.js"));
+var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-N3PMHXH5.js"));
 function describeUnknownError(error) {
   if (error instanceof PmCliError) {
     return error.message;
@@ -5722,7 +4313,7 @@ function normalizeTelemetryResolutionStage(value) {
   }
   return normalized;
 }
-function normalizeTelemetryErrorCategory2(value) {
+function normalizeTelemetryErrorCategory(value) {
   if (!value) {
     return void 0;
   }
@@ -5788,12 +4379,12 @@ function buildPostActionTelemetryOutcome() {
   const resultExitCode = readRecordNumber(result, "exit_code", "exitCode");
   const exitCode = processExitCode ?? resultExitCode ?? EXIT_CODE.SUCCESS;
   const ok = exitCode === EXIT_CODE.SUCCESS;
-  const errorCode2 = readRecordString(result, "error_code", "errorCode") ?? inferPostActionErrorCode(ok, exitCode);
-  const errorCategory = normalizeTelemetryErrorCategory2(readRecordString(result, "error_category", "errorCategory")) ?? (!ok ? resolveTelemetryErrorCategory(errorCode2) : void 0);
+  const errorCode = readRecordString(result, "error_code", "errorCode") ?? inferPostActionErrorCode(ok, exitCode);
+  const errorCategory = normalizeTelemetryErrorCategory(readRecordString(result, "error_category", "errorCategory")) ?? (!ok ? resolveTelemetryErrorCategory(errorCode) : void 0);
   const errorMessage = !ok ? inferPostActionFailureMessage(result) ?? `command_exit_${exitCode}` : void 0;
   const commandResolution = normalizeTelemetryCommandResolution(readRecordString(result, "command_resolution", "commandResolution")) ?? deriveTelemetryCommandResolution({
     ok,
-    errorCode: errorCode2,
+    errorCode,
     errorCategory
   });
   const resolutionStage = normalizeTelemetryResolutionStage(readRecordString(result, "resolution_stage", "resolutionStage")) ?? "execute";
@@ -5801,7 +4392,7 @@ function buildPostActionTelemetryOutcome() {
     ok,
     error: errorMessage,
     exit_code: exitCode,
-    error_code: errorCode2,
+    error_code: errorCode,
     error_category: errorCategory,
     command_resolution: commandResolution,
     resolution_stage: resolutionStage
@@ -6665,7 +5256,7 @@ async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv)
 }
 function resolveCliVersion2() {
   try {
-    const packageJsonPath = path3.join(resolvePmPackageRoot(), "package.json");
+    const packageJsonPath = path2.join(resolvePmPackageRoot(), "package.json");
     const raw = fs2.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : "0.0.0";