@unbrained/pm-cli 2026.6.5 → 2026.6.7

package/dist/cli-bundle/chunks/chunk-QQL5QSTZ.js

@@ -0,0 +1,1572 @@
+
+!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]="87b64271-e0df-5c0d-991b-f7d1a6401710")}catch(e){}}();
+import {
+  nowIso
+} from "./chunk-B2KZGPM2.js";
+import {
+  EXIT_CODE,
+  appendLineAtomic,
+  readFileIfExists,
+  readSettings,
+  resolveGlobalPmRoot,
+  resolvePmPackageRootFromModule,
+  resolveTelemetryErrorCategory,
+  writeFileAtomic,
+  writeSettings
+} from "./chunk-X4IZKYHP.js";
+
+// dist/core/telemetry/observability.js
+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", "telemetry", "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
+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";
+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_CLIENT_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 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(input) {
+  const withoutAssignments = input.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(input) {
+  return input.replaceAll(ABSOLUTE_PATH_TOKEN_PATTERN, (_match, prefix) => `${prefix}[redacted_path]`);
+}
+function isAsciiLetterOrDigitCode(code) {
+  const isUpper = code >= 65 && code <= 90;
+  const isLower = code >= 97 && code <= 122;
+  const isDigit = code >= 48 && code <= 57;
+  return isUpper || isLower || isDigit;
+}
+function isEmailLocalCharacter(character) {
+  if (!character) {
+    return false;
+  }
+  const code = character.charCodeAt(0);
+  if (isAsciiLetterOrDigitCode(code)) {
+    return true;
+  }
+  return character === "." || character === "_" || character === "%" || character === "+" || character === "-";
+}
+function isEmailDomainCharacter(character) {
+  if (!character) {
+    return false;
+  }
+  const code = character.charCodeAt(0);
+  if (isAsciiLetterOrDigitCode(code)) {
+    return true;
+  }
+  return character === "." || character === "-";
+}
+function looksLikeEmailToken(token) {
+  const atIndex = token.indexOf("@");
+  if (atIndex <= 0 || atIndex !== token.lastIndexOf("@") || atIndex === token.length - 1) {
+    return false;
+  }
+  const localPart = token.slice(0, atIndex);
+  const domainPart = token.slice(atIndex + 1);
+  const lastDot = domainPart.lastIndexOf(".");
+  if (lastDot <= 0 || lastDot === domainPart.length - 1) {
+    return false;
+  }
+  if (domainPart.length - (lastDot + 1) < 2) {
+    return false;
+  }
+  for (const character of localPart) {
+    if (!isEmailLocalCharacter(character)) {
+      return false;
+    }
+  }
+  for (const character of domainPart) {
+    if (!isEmailDomainCharacter(character)) {
+      return false;
+    }
+  }
+  return true;
+}
+function redactEmailTokens(input) {
+  let redacted = "";
+  let cursor = 0;
+  while (cursor < input.length) {
+    const atIndex = input.indexOf("@", cursor);
+    if (atIndex < 0) {
+      redacted += input.slice(cursor);
+      break;
+    }
+    let start = atIndex - 1;
+    while (start >= cursor && isEmailLocalCharacter(input[start])) {
+      start -= 1;
+    }
+    start += 1;
+    let end = atIndex + 1;
+    while (end < input.length && isEmailDomainCharacter(input[end])) {
+      end += 1;
+    }
+    const candidate = input.slice(start, end);
+    if (looksLikeEmailToken(candidate)) {
+      redacted += input.slice(cursor, start);
+      redacted += "[redacted_email]";
+      cursor = end;
+      continue;
+    }
+    redacted += input.slice(cursor, atIndex + 1);
+    cursor = atIndex + 1;
+  }
+  return redacted;
+}
+function sanitizeCommonSensitiveTokens(input) {
+  const withoutEmails = redactEmailTokens(input);
+  const withoutBearer = withoutEmails.replaceAll(BEARER_TOKEN_PATTERN, "bearer [redacted_token]");
+  return withoutBearer.replaceAll(PRIVATE_IP_PATTERN, "[redacted_ip]");
+}
+function sanitizeStringRedacted(input) {
+  const withoutCommonSensitiveTokens = sanitizeCommonSensitiveTokens(input);
+  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(input) {
+  const withoutCommonSensitiveTokens = sanitizeCommonSensitiveTokens(input);
+  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(input, captureLevel = "redacted") {
+  if (captureLevel === "max") {
+    return sanitizeStringMax(input);
+  }
+  return sanitizeStringRedacted(input);
+}
+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 = {
+    client_schema_version: TELEMETRY_CLIENT_SCHEMA_VERSION,
+    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 = {
+      client_schema_version: TELEMETRY_CLIENT_SCHEMA_VERSION,
+      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" && (parsed.client_schema_version === void 0 || typeof parsed.client_schema_version === "number" && Number.isFinite(parsed.client_schema_version))) {
+        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
+    });
+  }
+}
+async function acquireTelemetryFlushLock(globalPmRoot) {
+  const lockPath = flushLockPath(globalPmRoot);
+  await mkdir(path.dirname(lockPath), { recursive: true });
+  try {
+    await mkdir(lockPath);
+    return true;
+  } catch (error) {
+    if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  try {
+    const lockStats = await stat(lockPath);
+    if (Date.now() - lockStats.mtimeMs < TELEMETRY_FLUSH_LOCK_STALE_MS) {
+      return false;
+    }
+    await rm(lockPath, { recursive: true, force: true });
+    await mkdir(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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));
+}
+async function flushQueueWithProcessLock(globalPmRoot, endpoint, retentionDays) {
+  const acquired = await acquireTelemetryFlushLock(globalPmRoot);
+  releaseTelemetryFlushSpawnGate(globalPmRoot);
+  if (!acquired) {
+    return;
+  }
+  try {
+    await flushQueue(globalPmRoot, endpoint, retentionDays);
+  } finally {
+    await rm(flushLockPath(globalPmRoot), { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+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 flushTelemetryQueueNow(globalPmRoot = resolveGlobalPmRoot(process.cwd())) {
+  if (telemetryDisabledByEnvironment()) {
+    return;
+  }
+  try {
+    const settings = await readSettings(globalPmRoot);
+    if (!settings.telemetry.enabled) {
+      return;
+    }
+    const { endpoint, retentionDays } = await ensureInstallationId(globalPmRoot);
+    await flushQueueWithProcessLock(globalPmRoot, endpoint, retentionDays);
+  } catch {
+  }
+}
+async function startTelemetryCommand(context) {
+  if (telemetryDisabledByEnvironment()) {
+    return null;
+  }
+  if (context.command === "telemetry" && context.args.some((token) => token.trim().toLowerCase() === "clear")) {
+    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 {
+  }
+}
+
+export {
+  deriveTelemetryCommandTaxonomy,
+  deriveTelemetryCommandResolution,
+  flushTelemetryQueueNow,
+  startTelemetryCommand,
+  finishTelemetryCommand,
+  emitTelemetryErrorEvent
+};
+//# sourceMappingURL=chunk-QQL5QSTZ.js.map
+
+//# debugId=87b64271-e0df-5c0d-991b-f7d1a6401710