@unbrained/pm-cli 2026.5.31 → 2026.6.6

package/dist/cli-bundle/main.js

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 import {
-  levenshteinDistanceWithinLimit
-} from "./chunks/chunk-EAOG77HM.js";
+  deriveTelemetryCommandResolution,
+  deriveTelemetryCommandTaxonomy,
+  emitTelemetryErrorEvent,
+  finishTelemetryCommand,
+  startTelemetryCommand
+} from "./chunks/chunk-SKJWX3QB.js";
 import {
   migrateItemFilesToFormat
-} from "./chunks/chunk-KBQY3YG5.js";
+} from "./chunks/chunk-KJ33AOCY.js";
 import {
   applyDefaultOutputFormat,
   clearResolvedGlobalOptions,
@@ -14,50 +18,49 @@ import {
   getGlobalOptions,
   invalidateSearchCachesForMutation,
   setResolvedGlobalOptions
-} from "./chunks/chunk-P53TN6IA.js";
+} from "./chunks/chunk-PDDFYW4X.js";
 import {
   PM_CORE_COMMAND_NAMES,
   resolveSubcommandFlagContractsForCommand
-} from "./chunks/chunk-GN7IJPCD.js";
-import "./chunks/chunk-6HT2F4TK.js";
+} from "./chunks/chunk-PROOHX4K.js";
+import "./chunks/chunk-3FI4SEFT.js";
 import {
   printError,
   printResult,
   writeStdout
-} from "./chunks/chunk-5HSEP75M.js";
+} from "./chunks/chunk-LCM63IXU.js";
 import {
-  resolvePmPackageRootFromModule
-} from "./chunks/chunk-EGUGFSNX.js";
-import "./chunks/chunk-BUPWJ3IJ.js";
-import "./chunks/chunk-4AEZR5EJ.js";
-import "./chunks/chunk-CEFIVZPG.js";
-import "./chunks/chunk-MD7K4JYF.js";
+  levenshteinDistanceWithinLimit
+} from "./chunks/chunk-EAOG77HM.js";
+import "./chunks/chunk-XTGLRY2Y.js";
+import "./chunks/chunk-T3LC5LKB.js";
+import "./chunks/chunk-AO442XLN.js";
 import {
   commandOptionFlagLabel,
   resolveCommandOptionPolicyState,
   resolveItemTypeRegistry,
   resolveTypeDefinition
-} from "./chunks/chunk-WDPXDQFG.js";
-import {
-  nowIso
-} from "./chunks/chunk-PVNQLCIS.js";
+} from "./chunks/chunk-KJE2FOS4.js";
+import "./chunks/chunk-QO7EBBOM.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
   PmCliError,
   activateExtensions,
-  appendLineAtomic,
   asRecordOrNull,
   clearActiveExtensionHooks,
+  consumeAfterCommandAffectedItems,
+  createEmptyExtensionRegistrationRegistry,
+  discoverExtensions,
   getActiveCommandResult,
   getActiveExtensionRegistrations,
   getSettingsPath,
   loadExtensions,
   pathExists,
-  readFileIfExists,
   readSettings,
   readSettingsWithMetadata,
   resolveGlobalPmRoot,
+  resolvePmPackageRootFromModule,
   resolvePmRoot,
   resolveRuntimeFieldRegistry,
   resolveTelemetryErrorCategory,
@@ -77,13 +80,12 @@ import {
   setActiveExtensionRenderers,
   setActiveExtensionServices,
   toNonEmptyStringOrUndefined,
-  writeFileAtomic,
   writeSettings
-} from "./chunks/chunk-LSXGH6NE.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
@@ -92,13 +94,13 @@ import { stdin as input, stdout as output } from "node:process";
 !(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] = "6fcbb185-889c-5474-9f02-321a53177803");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "c965da5d-6609-5258-ba49-a57475f7f2ef");
   } catch (e2) {
   }
 })();
 var TELEMETRY_PROMPT_DISABLE_ENV = "PM_TELEMETRY_PROMPT";
 var TELEMETRY_PROMPT_DISABLE_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
-var TELEMETRY_PROMPT_SKIPPED_COMMANDS = /* @__PURE__ */ new Set(["init", "completion", "completion-tags"]);
+var TELEMETRY_PROMPT_SKIPPED_COMMANDS = /* @__PURE__ */ new Set(["init", "completion", "completion-statuses", "completion-tags", "completion-types"]);
 function parseBooleanLike(value) {
   if (typeof value !== "string") {
     return false;
@@ -132,1464 +134,45 @@ function parseTelemetryPromptAnswer(answer) {
   return true;
 }
 async function promptTelemetryConsent(currentDefault) {
-  const defaultLabel = currentDefault ? "Y/n" : "y/N";
-  const prompt = `pm telemetry helps improve reliability and usage diagnostics.
-It is enabled by default and can be changed anytime via:
-pm config global set telemetry-tracking --policy disabled
-Enable telemetry now? [${defaultLabel}] `;
-  const rl = readline.createInterface({ input, output });
-  try {
-    const answer = await rl.question(prompt);
-    if (answer.trim().length === 0) {
-      return currentDefault;
-    }
-    return parseTelemetryPromptAnswer(answer);
-  } finally {
-    rl.close();
-  }
-}
-async function maybeRunFirstUseTelemetryPrompt(commandPath, globalOptions) {
-  if (shouldSkipTelemetryPrompt(commandPath, globalOptions)) {
-    return;
-  }
-  try {
-    const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-    const settings = await readSettings(globalPmRoot);
-    if (settings.telemetry.first_run_prompt_completed) {
-      return;
-    }
-    const enabled = await promptTelemetryConsent(settings.telemetry.enabled);
-    settings.telemetry.enabled = enabled;
-    settings.telemetry.first_run_prompt_completed = true;
-    await writeSettings(globalPmRoot, settings, "telemetry:first_run_prompt");
-    output.write(`Telemetry ${enabled ? "enabled" : "disabled"} for this CLI install. Update any time with pm config global set telemetry-tracking --policy ${enabled ? "disabled" : "enabled"}.
-`);
-  } catch {
-  }
-}
-
-// 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] = "05b6b4cc-d37d-593c-b34c-b491c722d181");
-  } catch (e2) {
-  }
-})();
-var SETUP_ROOT_COMMANDS = /* @__PURE__ */ new Set(["init", "config", "completion", "completion-tags"]);
-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",
-  "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;
-  }
+  const defaultLabel = currentDefault ? "Y/n" : "y/N";
+  const prompt = `pm telemetry helps improve reliability and usage diagnostics.
+It is enabled by default and can be changed anytime via:
+pm config global set telemetry-tracking --policy disabled
+Enable telemetry now? [${defaultLabel}] `;
+  const rl = readline.createInterface({ input, output });
   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 {
+    const answer = await rl.question(prompt);
+    if (answer.trim().length === 0) {
+      return currentDefault;
+    }
+    return parseTelemetryPromptAnswer(answer);
+  } finally {
+    rl.close();
   }
 }
-async function emitTelemetryErrorEvent(context) {
-  if (telemetryDisabledByEnvironment()) {
+async function maybeRunFirstUseTelemetryPrompt(commandPath, globalOptions) {
+  if (shouldSkipTelemetryPrompt(commandPath, globalOptions)) {
     return;
   }
   try {
     const globalPmRoot = resolveGlobalPmRoot(process.cwd());
     const settings = await readSettings(globalPmRoot);
-    if (!settings.telemetry.enabled) {
+    if (settings.telemetry.first_run_prompt_completed) {
       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);
+    const enabled = await promptTelemetryConsent(settings.telemetry.enabled);
+    settings.telemetry.enabled = enabled;
+    settings.telemetry.first_run_prompt_completed = true;
+    await writeSettings(globalPmRoot, settings, "telemetry:first_run_prompt");
+    output.write(`Telemetry ${enabled ? "enabled" : "disabled"} for this CLI install. Update any time with pm config global set telemetry-tracking --policy ${enabled ? "disabled" : "enabled"}.
+`);
   } 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;
@@ -1736,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")
@@ -2344,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] = "87ab8982-4eaf-5b48-88af-96ff4450ab0f");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "74a0432a-8374-53db-8e95-5ebd38cf8557");
   } catch (e2) {
   }
 })();
@@ -2488,6 +1071,70 @@ var HELP_BY_COMMAND_PATH = {
       "Use --dry-run before upgrade when automation needs a deterministic plan."
     ]
   },
+  "package init": {
+    why: "Generates an installable starter pm package with package metadata and a root extension entrypoint.",
+    examples: [
+      "pm package init ./my-package",
+      "pm install ./my-package --project",
+      "pm package doctor --project --detail summary"
+    ],
+    tips: [
+      "The generated package is local-install safe; add SDK runtime imports only after declaring dependencies and validating with package doctor.",
+      "Use package doctor after changes to verify activation, policy, and collision diagnostics."
+    ]
+  },
+  "package install": {
+    why: "Installs pm packages from local paths, npm sources, GitHub sources, bundled aliases, or wildcard/all aliases.",
+    examples: [
+      "pm package install ./my-package --project",
+      "pm install npm:pm-changelog --project",
+      "pm package install --github org/repo/packages/my-pm-package --ref main"
+    ],
+    tips: [
+      "Prefer the top-level pm install alias in scripts when only installation is needed.",
+      "Run pm package manage or pm package doctor after installing external packages."
+    ]
+  },
+  "package catalog": {
+    why: "Lists bundled first-party package catalog metadata and compact field projections.",
+    examples: [
+      "pm package catalog --project",
+      "pm package catalog --project --fields alias,installed,install_command",
+      "pm package list --project --fields alias,package_name,category"
+    ],
+    tips: [
+      "Use --fields for low-token package discovery in agent loops.",
+      "External npm package discovery still belongs to npm search."
+    ]
+  },
+  "extension init": {
+    why: "Generates an installable starter runtime extension with manifest and entrypoint files.",
+    examples: [
+      "pm extension init ./my-extension",
+      "pm extension --install --project ./my-extension",
+      "pm extension --doctor --project --detail summary"
+    ],
+    tips: [
+      "Use package init for new distributable package workflows; extension init is the compatibility-level runtime scaffold."
+    ]
+  },
+  "extension install": {
+    why: "Installs a compatibility runtime extension from local, npm, GitHub, bundled alias, or wildcard sources.",
+    examples: [
+      "pm extension install ./my-extension --project",
+      "pm extension --install --project ./my-extension",
+      "pm extension doctor --project --detail summary"
+    ],
+    tips: ["Prefer pm install or pm package install for new package-first automation."]
+  },
+  "extension catalog": {
+    why: "Compatibility view of bundled package catalog metadata.",
+    examples: [
+      "pm extension catalog --project",
+      "pm extension catalog --project --fields alias,installed,install_command"
+    ],
+    tips: ["Prefer pm package catalog in new user-facing workflows."]
+  },
   install: {
     why: "Installs a pm package into project scope by default, using local, npm, GitHub, or bundled alias sources.",
     examples: [
@@ -2553,6 +1200,21 @@ var HELP_BY_COMMAND_PATH = {
       "Checkpoints are enabled by default for apply mode and can be restored with --rollback."
     ]
   },
+  "close-many": {
+    why: "Bulk-closes matched items with a shared reason routed through full pm close semantics (close validation, active-child orphan checks, blocked-edge cleanup) plus dry-run previews and rollback checkpoints \u2014 unlike update-many --status closed, which bypasses close validation.",
+    examples: [
+      'pm close-many --filter-sprint S-12 --reason "Sprint S-12 acceptance criteria met" --dry-run',
+      'pm close-many --filter-tag wave:7 --reason "Superseded by redesign" --validate-close warn',
+      'pm close-many --ids pm-a,pm-b,pm-c --reason "Closed in batch" --resolution "Verified by integration suite"',
+      "pm close-many --rollback close-many-20260604-abc123"
+    ],
+    tips: [
+      "At least one filter (--filter-* or --ids) is required so close-many never matches every item.",
+      "Already-terminal matches are skipped by default; pass --force to re-close them.",
+      "Use --dry-run to preview matches plus per-item skip reasons and active-child orphan warnings before applying.",
+      "Checkpoints are enabled by default for apply mode; restore with --rollback <checkpoint-id>."
+    ]
+  },
   normalize: {
     why: "Scans items for low-signal lifecycle metadata drift, emits deterministic per-item plans, and optionally applies normalized metadata updates with update-style safety checks.",
     examples: [
@@ -2715,7 +1377,7 @@ var HELP_BY_COMMAND_PATH = {
       "pm get pm-a1b2 --fields id,title,status,parent,type --json"
     ],
     tips: [
-      "Default depth is deep for backward compatibility; use brief for metadata-only checks and standard for body plus linked artifacts without append-only logs.",
+      "Default depth is standard for body plus linked artifacts without append-only logs; use brief for metadata-only checks or --full for complete history-heavy metadata.",
       "Use --fields for the smallest deterministic item metadata payload when an agent only needs specific fields.",
       "JSON output shape is { item, body, linked, claim_state }; body is top-level (not item.body)."
     ]
@@ -2857,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: [
@@ -2980,7 +1651,7 @@ function attachRichHelpText(program2, argv = process.argv.slice(2)) {
 !(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] = "92cba1f2-f9c5-5748-90ce-ab2049ada502");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "7f17a5b9-5783-523d-b9cd-61968ddd9ed2");
   } catch (e2) {
   }
 })();
@@ -2996,13 +1667,17 @@ function normalizeLongOptionFlag(token) {
 }
 function extractProvidedOptionFlags(argv) {
   const provided = /* @__PURE__ */ new Set();
+  const ordered = [];
   for (const token of argv) {
     const normalized = normalizeLongOptionFlag(token);
     if (normalized) {
+      if (!provided.has(normalized)) {
+        ordered.push(normalized);
+      }
       provided.add(normalized);
     }
   }
-  return [...provided].sort((left, right) => left.localeCompare(right));
+  return ordered;
 }
 function quoteCommandArg(arg) {
   if (/^[A-Za-z0-9._:/@=-]+$/.test(arg)) {
@@ -3018,7 +1693,7 @@ function renderPmCommand(argv) {
 !(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] = "98367a9e-b72b-56c3-a337-fcc10e562f6e");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "883618a4-a53f-5506-ab97-d734647806e7");
   } catch (e2) {
   }
 })();
@@ -3181,6 +1856,10 @@ function guidanceToClassification(message) {
 function normalizeMessage(message) {
   return message.replace(/\(outputHelp\)/g, "").trim();
 }
+function isModuleResolutionErrorMessage(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("cannot find module") || normalized.includes("cannot find package") || normalized.includes("err_module_not_found") || normalized.includes("module_not_found");
+}
 function normalizeContextList(values) {
   if (!Array.isArray(values)) {
     return void 0;
@@ -3600,10 +2279,26 @@ function formatUnknownErrorForJson(rawMessage, exitCode) {
   return guidanceToJsonEnvelope(guidance, exitCode);
 }
 function buildUnknownErrorGuidance(rawMessage) {
+  const message = normalizeMessage(rawMessage);
+  if (isModuleResolutionErrorMessage(message)) {
+    return makeGuidanceMessage({
+      code: "module_import_failed",
+      title: "Module import failed",
+      happened: message,
+      required: "Ensure the active checkout is built and any package or extension entry file exists before retrying.",
+      why: "Node could not resolve an imported module. In pm this usually means an extension/package entrypoint, build artifact, or dependency is missing from the active runtime.",
+      examples: ["pnpm build", "pm package manage --doctor --project", "pm health --check-only --json"],
+      nextSteps: [
+        "Rebuild the checkout or package that provides the missing module.",
+        "Run package doctor for installed extensions when the failure follows package installation or activation.",
+        "Rerun the original pm command after the runtime files are present."
+      ]
+    });
+  }
   return makeGuidanceMessage({
     code: "unknown_error",
     title: "Unhandled error",
-    happened: normalizeMessage(rawMessage),
+    happened: message,
     required: "Inspect command input and runtime state, then retry.",
     why: "Unexpected runtime failures can occur from environment or extension-level issues.",
     examples: ["pm --help", "pm health --json"]
@@ -4009,7 +2704,7 @@ function ensureCommandPath(root, pathParts) {
 !(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] = "09a59142-b988-5127-9105-7bdfc1f9c832");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "abcf109c-c846-5b61-b510-f1ad6ff4f3aa");
   } catch (e2) {
   }
 })();
@@ -4520,7 +3215,8 @@ function normalizeBootstrapInvocation(argv) {
   }
   const aliasNormalized = rewriteCommandAlias(legacyNormalized, trace);
   const commandName = parseBootstrapCommandName(aliasNormalized);
-  const lookup = buildFlagLookup(commandName);
+  const commandPathName = parseBootstrapCommandPathName(aliasNormalized);
+  const lookup = buildFlagLookup(commandPathName ?? commandName);
   const normalizedArgv = [];
   for (let index = 0; index < aliasNormalized.length; index += 1) {
     const token = aliasNormalized[index];
@@ -4564,6 +3260,15 @@ function normalizeBootstrapInvocation(argv) {
     trace
   };
 }
+function parseBootstrapCommandPathName(argv) {
+  const stripped = stripGlobalBootstrapTokens(argv);
+  const first = stripped[0]?.trim().toLowerCase();
+  const second = stripped[1]?.trim().toLowerCase();
+  if ((first === "extension" || first === "package" || first === "packages") && typeof second === "string" && second.length > 0 && !second.startsWith("-")) {
+    return `${first} ${second}`;
+  }
+  return first;
+}
 function parseBootstrapTypeValue(argv) {
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index];
@@ -5012,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 {
@@ -5427,7 +4132,7 @@ function attachCreateUpdatePolicyHelpText(rootProgram, typeRegistry, argv) {
 !(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] = "fb080e3e-ad71-5608-a944-ce887395e3e9");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "85d31f87-d392-5da2-9d53-1525fb938ff2");
   } catch (e2) {
   }
 })();
@@ -5457,6 +4162,7 @@ var TELEMETRY_COMMAND_RESOLUTION_SET = /* @__PURE__ */ new Set([
 var TELEMETRY_RESOLUTION_STAGE_SET = /* @__PURE__ */ new Set(["parse", "preflight", "execute", "unknown"]);
 var TELEMETRY_ERROR_CATEGORY_SET = /* @__PURE__ */ new Set(["usage", "validation", "conflict", "runtime", "unknown"]);
 var runtimeExtensionSnapshotCache = null;
+var runtimeExtensionDiscoverySnapshotCache = null;
 var activeRuntimeExtensionCommandDescriptors = /* @__PURE__ */ new Map();
 var HANDLED_ERROR_SENTRY_FLUSH_TIMEOUT_MS = 250;
 var EXPECTED_HANDLED_ERROR_EXIT_CODES = /* @__PURE__ */ new Set([
@@ -5465,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-V56GDRUS.js"));
-var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-UP3VRUFS.js"));
-var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-YWSBF545.js"));
-var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-3BDTGSDH.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;
@@ -5533,7 +4239,7 @@ function buildPmCliRecoveryContext(context, invocationArgv, rawMessage) {
   if (!suggestedRetry) {
     suggestedRetry = attemptedCommand;
   }
-  if (suggestedRetry === attemptedCommand) {
+  if (!existingRecovery?.suggested_retry && suggestedRetry === attemptedCommand) {
     suggestedRetry = void 0;
   }
   const recovery = {
@@ -5607,7 +4313,7 @@ function normalizeTelemetryResolutionStage(value) {
   }
   return normalized;
 }
-function normalizeTelemetryErrorCategory2(value) {
+function normalizeTelemetryErrorCategory(value) {
   if (!value) {
     return void 0;
   }
@@ -5673,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";
@@ -5686,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
@@ -5711,17 +4417,28 @@ async function runAndClearAfterCommandHooks(outcome) {
     clearActiveExtensionHooks();
     return;
   }
-  const hookWarnings = await runAfterCommandHooks(runtime.hooks, {
-    command: runtime.commandName,
-    args: runtime.commandArgs,
-    options: { ...runtime.commandOptions },
-    global: { ...runtime.globalOptions },
-    pm_root: runtime.pmRoot,
-    ok: outcome.ok,
-    error: outcome.error,
-    result: getActiveCommandResult()
-  });
-  clearActiveExtensionHooks();
+  let hookWarnings = [];
+  try {
+    hookWarnings = await runAfterCommandHooks(runtime.hooks, {
+      command: runtime.commandName,
+      args: runtime.commandArgs,
+      options: { ...runtime.commandOptions },
+      global: { ...runtime.globalOptions },
+      pm_root: runtime.pmRoot,
+      ok: outcome.ok,
+      error: outcome.error,
+      result: getActiveCommandResult(),
+      affected: consumeAfterCommandAffectedItems()
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    hookWarnings = [`afterCommand hooks failed: ${message}`];
+  } finally {
+    clearActiveExtensionHooks();
+  }
+  if (!runtime.globalOptions.json && hookWarnings.length > 0) {
+    printError(`[pm] warning: afterCommand hook_warnings=${formatHookWarnings(hookWarnings)}`);
+  }
   if (runtime.profileEnabled && hookWarnings.length > 0) {
     printError(`profile:extensions hook_warnings=${formatHookWarnings(hookWarnings)}`);
   }
@@ -5920,6 +4637,18 @@ async function registerRuntimeSchemaFieldFlags(rootProgram, invocationArgv) {
     }
   }
 }
+async function maybeAttachCreateUpdatePolicyHelpText(rootProgram, pmRoot, invocationArgv, registrations, settings) {
+  const bootstrapCommand = parseBootstrapCommandName(invocationArgv);
+  if (bootstrapCommand !== "create" && bootstrapCommand !== "update") {
+    return;
+  }
+  try {
+    const resolvedSettings = settings ?? await readSettings(pmRoot);
+    const typeRegistry = resolveItemTypeRegistry(resolvedSettings, registrations);
+    attachCreateUpdatePolicyHelpText(rootProgram, typeRegistry, invocationArgv);
+  } catch {
+  }
+}
 function defaultPreflightDecision() {
   return {
     enforce_item_format_gate: true,
@@ -5931,6 +4660,180 @@ function defaultPreflightDecision() {
 function buildRuntimeExtensionSnapshotCacheKey(pmRoot) {
   return `pm-root:${pmRoot}`;
 }
+function bootstrapProfileEnabled(invocationArgv) {
+  return invocationArgv.some((token) => token === "--profile");
+}
+function buildRuntimeExtensionDiscoverySnapshotCacheKey(pmRoot) {
+  return `pm-root:${pmRoot}`;
+}
+function collectLeadingCommandArgs(commandArgs) {
+  const leading = [];
+  for (const arg of commandArgs ?? []) {
+    if (arg.startsWith("-")) {
+      break;
+    }
+    const normalized = normalizeExtensionCommandPath(arg);
+    if (normalized.length === 0) {
+      continue;
+    }
+    leading.push(normalized);
+  }
+  return leading;
+}
+function collectActivationCommandCandidates(probe) {
+  const commandPath = normalizeExtensionCommandPath(probe.commandPath ?? "");
+  if (commandPath.length === 0) {
+    return [];
+  }
+  const candidates = [commandPath];
+  const parts = commandPath.split(" ").filter((part) => part.length > 0);
+  for (const arg of collectLeadingCommandArgs(probe.commandArgs)) {
+    parts.push(...arg.split(" ").filter((part) => part.length > 0));
+    candidates.push(parts.join(" "));
+  }
+  return [...new Set(candidates)];
+}
+function activationCommandMatchesProbe(command, probe) {
+  const normalized = normalizeExtensionCommandPath(command);
+  if (normalized.length === 0) {
+    return false;
+  }
+  const candidates = collectActivationCommandCandidates(probe);
+  for (const candidate of candidates) {
+    if (candidate === normalized || candidate.startsWith(`${normalized} `)) {
+      return true;
+    }
+  }
+  if (probe.allowCommandPrefixMatch === true) {
+    return candidates.some((candidate) => normalized.startsWith(`${candidate} `));
+  }
+  return false;
+}
+function extensionActivationCommands(extension) {
+  return extension.activation?.commands ?? [];
+}
+function extensionCapabilities(extension) {
+  return new Set((extension.capabilities ?? []).map((capability) => capability.trim().toLowerCase()));
+}
+var GLOBAL_EXTENSION_ACTIVATION_CAPABILITIES = /* @__PURE__ */ new Set(["hooks", "parser", "preflight", "renderers"]);
+var CONSERVATIVE_EXTENSION_ACTIVATION_CAPABILITIES = /* @__PURE__ */ new Set(["commands", "schema", "services"]);
+var SEARCH_EXTENSION_ACTIVATION_COMMANDS = /* @__PURE__ */ new Set(["reindex", "search", "search-advanced"]);
+var CREATE_TEMPLATE_FLAGS = /* @__PURE__ */ new Set(["--template"]);
+function hasAnyCapability(capabilities, expected) {
+  for (const capability of expected) {
+    if (capabilities.has(capability)) {
+      return true;
+    }
+  }
+  return false;
+}
+function commandPathNeedsSearchExtensions(commandPath) {
+  const normalized = normalizeExtensionCommandPath(commandPath ?? "");
+  if (normalized.length === 0) {
+    return false;
+  }
+  const [topLevel] = normalized.split(" ");
+  return SEARCH_EXTENSION_ACTIVATION_COMMANDS.has(topLevel ?? normalized);
+}
+function probeUsesAnyFlag(probe, flags) {
+  for (const arg of probe.commandArgs ?? []) {
+    if (!arg.startsWith("--")) {
+      continue;
+    }
+    const [flagName] = arg.split("=", 1);
+    if (flags.has(flagName)) {
+      return true;
+    }
+  }
+  return false;
+}
+function commandPathNeedsTemplateExtensions(probe) {
+  return normalizeExtensionCommandPath(probe.commandPath ?? "") === "create" && probeUsesAnyFlag(probe, CREATE_TEMPLATE_FLAGS);
+}
+function extensionProvidesTemplatesRuntime(commands) {
+  return commands.some((command) => {
+    const normalized = normalizeExtensionCommandPath(command);
+    return normalized === "templates" || normalized.startsWith("templates ");
+  });
+}
+function extensionNeedsActivationForProbe(extension, probe) {
+  const capabilities = extensionCapabilities(extension);
+  const commands = extensionActivationCommands(extension);
+  if (commands.length > 0 && commands.some((command) => activationCommandMatchesProbe(command, probe))) {
+    return true;
+  }
+  if (hasAnyCapability(capabilities, GLOBAL_EXTENSION_ACTIVATION_CAPABILITIES)) {
+    return true;
+  }
+  if (commandPathNeedsTemplateExtensions(probe) && extensionProvidesTemplatesRuntime(commands)) {
+    return true;
+  }
+  if (capabilities.has("search")) {
+    return commandPathNeedsSearchExtensions(probe.commandPath);
+  }
+  if (commands.length > 0) {
+    return false;
+  }
+  if (hasAnyCapability(capabilities, CONSERVATIVE_EXTENSION_ACTIVATION_CAPABILITIES)) {
+    return true;
+  }
+  if (capabilities.has("importers")) {
+    return probe.allowCommandPrefixMatch === true;
+  }
+  return false;
+}
+function discoveryNeedsActivationForProbe(discovery, probe) {
+  if (discovery.effective.length === 0) {
+    return false;
+  }
+  const hasCommandProbe = normalizeExtensionCommandPath(probe.commandPath ?? "").length > 0;
+  if (!hasCommandProbe) {
+    return discovery.effective.some((extension) => {
+      const capabilities = extensionCapabilities(extension);
+      return extensionActivationCommands(extension).length > 0 || hasAnyCapability(capabilities, GLOBAL_EXTENSION_ACTIVATION_CAPABILITIES) || hasAnyCapability(capabilities, CONSERVATIVE_EXTENSION_ACTIVATION_CAPABILITIES) || capabilities.has("importers") || capabilities.has("search");
+    });
+  }
+  return discovery.effective.some((extension) => extensionNeedsActivationForProbe(extension, probe));
+}
+function buildBootstrapActivationProbe(invocationArgv) {
+  const helpRequest = parseBootstrapHelpRequest(invocationArgv);
+  if (helpRequest.requested && helpRequest.commandPathTokens.length > 0) {
+    const [commandPath, ...commandArgs] = helpRequest.commandPathTokens;
+    return {
+      commandPath,
+      commandArgs,
+      allowCommandPrefixMatch: true
+    };
+  }
+  const stripped = stripGlobalBootstrapTokens(invocationArgv);
+  const commandIndex = stripped.findIndex((token) => token.trim().length > 0 && !token.startsWith("-"));
+  if (commandIndex < 0) {
+    return {};
+  }
+  return {
+    commandPath: stripped[commandIndex],
+    commandArgs: stripped.slice(commandIndex + 1),
+    allowCommandPrefixMatch: helpRequest.requested
+  };
+}
+function collectParsedActivationCommandArgs(command) {
+  const commandArgs = command.args.map(String);
+  const commandPath = normalizeExtensionCommandPath(getCommandPath(command));
+  if (commandPath === "create") {
+    const options = command.optsWithGlobals();
+    if (typeof options.template === "string" && options.template.trim().length > 0) {
+      commandArgs.push("--template");
+    }
+  }
+  return commandArgs;
+}
+function emitSettingsReadWarnings(warnings) {
+  for (const warning of warnings) {
+    if (warning.startsWith("settings_read_")) {
+      printError(`[pm] warning: ${warning} \u2014 settings.json could not be loaded and pm fell back to defaults; run pm health for remediation.`);
+    }
+  }
+}
 function emitExtensionProfile(globalOptions, snapshot) {
   if (!globalOptions.profile) {
     return;
@@ -5940,6 +4843,55 @@ function emitExtensionProfile(globalOptions, snapshot) {
     printError(`profile:extensions activation_warnings=${formatHookWarnings(snapshot.activationWarnings)}`);
   }
 }
+function emitExtensionSkippedProfile(profileEnabled, snapshot, probe) {
+  if (!profileEnabled) {
+    return;
+  }
+  const command = normalizeExtensionCommandPath(probe.commandPath ?? "") || "<none>";
+  printError(`profile:extensions activation=skipped command=${command} effective=${snapshot.discovery.effective.length} warnings=${snapshot.discovery.warnings.length} discovery_ms=${snapshot.discoveryMs}`);
+}
+async function loadRuntimeExtensionDiscoverySnapshot(pmRoot) {
+  const cacheKey = buildRuntimeExtensionDiscoverySnapshotCacheKey(pmRoot);
+  if (runtimeExtensionDiscoverySnapshotCache?.key === cacheKey) {
+    return runtimeExtensionDiscoverySnapshotCache.snapshot;
+  }
+  const settingsPath = getSettingsPath(pmRoot);
+  if (!await pathExists(settingsPath)) {
+    runtimeExtensionDiscoverySnapshotCache = {
+      key: cacheKey,
+      snapshot: null
+    };
+    return null;
+  }
+  try {
+    const startedAt = Date.now();
+    const { settings, warnings: settingsReadWarnings } = await readSettingsWithMetadata(pmRoot);
+    const discovery = await discoverExtensions({
+      pmRoot,
+      settings,
+      cwd: process.cwd(),
+      noExtensions: false
+    });
+    const snapshot = {
+      pmRoot,
+      settings,
+      discovery,
+      discoveryMs: Date.now() - startedAt,
+      settingsReadWarnings: [...settingsReadWarnings]
+    };
+    runtimeExtensionDiscoverySnapshotCache = {
+      key: cacheKey,
+      snapshot
+    };
+    return snapshot;
+  } catch {
+    runtimeExtensionDiscoverySnapshotCache = {
+      key: cacheKey,
+      snapshot: null
+    };
+    return null;
+  }
+}
 async function loadRuntimeExtensionSnapshot(pmRoot) {
   const cacheKey = buildRuntimeExtensionSnapshotCacheKey(pmRoot);
   if (runtimeExtensionSnapshotCache?.key === cacheKey) {
@@ -6003,9 +4955,26 @@ async function loadRuntimeExtensionSnapshot(pmRoot) {
 async function maybeLoadRuntimeExtensions(command) {
   const globalOptions = getGlobalOptions(command);
   if (globalOptions.noExtensions) {
+    const noExtPmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
+    if (await pathExists(getSettingsPath(noExtPmRoot))) {
+      emitSettingsReadWarnings((await readSettingsWithMetadata(noExtPmRoot)).warnings);
+    }
     return null;
   }
   const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
+  const discoverySnapshot = await loadRuntimeExtensionDiscoverySnapshot(pmRoot);
+  if (!discoverySnapshot) {
+    return null;
+  }
+  emitSettingsReadWarnings(discoverySnapshot.settingsReadWarnings);
+  const probe = {
+    commandPath: getCommandPath(command),
+    commandArgs: collectParsedActivationCommandArgs(command)
+  };
+  if (!discoveryNeedsActivationForProbe(discoverySnapshot.discovery, probe)) {
+    emitExtensionSkippedProfile(globalOptions.profile, discoverySnapshot, probe);
+    return null;
+  }
   const snapshot = await loadRuntimeExtensionSnapshot(pmRoot);
   if (!snapshot) {
     return null;
@@ -6197,22 +5166,37 @@ function wrapProgramActionsForExtensionHandlers(rootProgram) {
 }
 async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv) {
   const bootstrapGlobalOptions = parseBootstrapGlobalOptions(invocationArgv);
+  const pmRoot = resolvePmRoot(process.cwd(), bootstrapGlobalOptions.path);
   if (bootstrapGlobalOptions.noExtensions) {
     activeRuntimeExtensionCommandDescriptors = /* @__PURE__ */ new Map();
     setActiveExtensionServices({ overrides: [] });
+    await maybeAttachCreateUpdatePolicyHelpText(rootProgram, pmRoot, invocationArgv, createEmptyExtensionRegistrationRegistry());
+    return;
+  }
+  const discoverySnapshot = await loadRuntimeExtensionDiscoverySnapshot(pmRoot);
+  const probe = buildBootstrapActivationProbe(invocationArgv);
+  if (!discoverySnapshot) {
+    activeRuntimeExtensionCommandDescriptors = /* @__PURE__ */ new Map();
+    setActiveExtensionServices({ overrides: [] });
+    return;
+  }
+  if (!discoveryNeedsActivationForProbe(discoverySnapshot.discovery, probe)) {
+    activeRuntimeExtensionCommandDescriptors = /* @__PURE__ */ new Map();
+    setActiveExtensionServices({ overrides: [] });
+    await maybeAttachCreateUpdatePolicyHelpText(rootProgram, pmRoot, invocationArgv, createEmptyExtensionRegistrationRegistry(), discoverySnapshot.settings);
+    emitExtensionSkippedProfile(bootstrapProfileEnabled(invocationArgv), discoverySnapshot, probe);
     return;
   }
-  const pmRoot = resolvePmRoot(process.cwd(), bootstrapGlobalOptions.path);
   const snapshot = await loadRuntimeExtensionSnapshot(pmRoot);
   if (!snapshot) {
     activeRuntimeExtensionCommandDescriptors = /* @__PURE__ */ new Map();
     setActiveExtensionServices({ overrides: [] });
+    await maybeAttachCreateUpdatePolicyHelpText(rootProgram, pmRoot, invocationArgv, createEmptyExtensionRegistrationRegistry(), discoverySnapshot.settings);
     return;
   }
   setActiveExtensionServices(snapshot.services);
   activeRuntimeExtensionCommandDescriptors = new Map(snapshot.commandDescriptors);
-  const typeRegistry = resolveItemTypeRegistry(snapshot.settings, snapshot.registrations);
-  attachCreateUpdatePolicyHelpText(rootProgram, typeRegistry, invocationArgv);
+  await maybeAttachCreateUpdatePolicyHelpText(rootProgram, pmRoot, invocationArgv, snapshot.registrations, snapshot.settings);
   const commandPaths = [.../* @__PURE__ */ new Set([...snapshot.commandHandlers, ...snapshot.commandDescriptors.keys()])].sort((left, right) => left.localeCompare(right));
   for (const commandPath of commandPaths) {
     const pathParts = commandPath.split(" ").filter((part) => part.length > 0);
@@ -6272,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";
@@ -6450,6 +5434,7 @@ var LIST_QUERY_COMMAND_NAMES = /* @__PURE__ */ new Set([
 var MUTATION_COMMAND_NAMES = /* @__PURE__ */ new Set([
   "append",
   "close",
+  "close-many",
   "comments",
   "delete",
   "deps",
@@ -6480,6 +5465,14 @@ var OPERATION_COMMAND_NAMES = /* @__PURE__ */ new Set([
   "test-runs-worker",
   "validate"
 ]);
+var MUTATING_OPERATION_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "claim",
+  "close-task",
+  "pause-task",
+  "release",
+  "start-task",
+  "test"
+]);
 var REGISTER_ALL_CORE_COMMAND_FAMILIES = {
   setup: true,
   listQuery: true,
@@ -6619,12 +5612,37 @@ function shouldRegisterRuntimeSchemaFlags(invocationArgv) {
   }
   return RUNTIME_SCHEMA_FLAG_BOOTSTRAP_COMMANDS.has(commandName);
 }
+function enforceExplicitRetryForFlagTypos(bootstrapInvocation) {
+  const commandName = bootstrapInvocation.commandName;
+  if (!commandName) {
+    return;
+  }
+  const typoEvent = bootstrapInvocation.trace.find((entry) => entry.reason === "flag_typo");
+  if (!typoEvent) {
+    return;
+  }
+  const normalizedTokens = Array.isArray(typoEvent.to) ? typoEvent.to : [String(typoEvent.to ?? "")].filter((entry) => entry.length > 0);
+  const normalizedDisplay = normalizedTokens.length > 0 ? normalizedTokens.join(" ") : "the canonical flag";
+  const mutatingCommand = MUTATION_COMMAND_NAMES.has(commandName) || MUTATING_OPERATION_COMMAND_NAMES.has(commandName);
+  const code = mutatingCommand ? "mutating_flag_typo_requires_retry" : "flag_typo_requires_retry";
+  const commandScope = mutatingCommand ? "mutating option" : "option";
+  throw new PmCliError(`Refusing to auto-correct ${commandScope} ${typoEvent.from} to ${normalizedDisplay}. Retry with the canonical flag so the command is explicit.`, EXIT_CODE.USAGE, {
+    code,
+    examples: [renderPmCommand(bootstrapInvocation.argv)],
+    nextSteps: ["Retry the command with the canonical flag shown in examples."],
+    recovery: {
+      normalized_args: [...bootstrapInvocation.argv],
+      suggested_retry: renderPmCommand(bootstrapInvocation.argv)
+    }
+  });
+}
 async function runPmCli(rawArgv = process.argv.slice(2)) {
   const bootstrapInvocation = normalizeBootstrapInvocation(rawArgv);
   const invocationArgv = bootstrapInvocation.argv;
   const invocationProcessArgv = [process.argv[0], process.argv[1], ...invocationArgv];
   const isBareInvocation = invocationArgv.length === 0;
   try {
+    enforceExplicitRetryForFlagTypos(bootstrapInvocation);
     applyBootstrapPagerPolicy(invocationArgv);
     const registrationSelection = resolveCoreCommandRegistrationSelection(invocationArgv);
     await registerCoreCommandFamilies(program, registrationSelection);
@@ -6683,8 +5701,17 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
       };
     };
     if (!bootstrapGlobal.noExtensions) {
-      const bootstrapSnapshot = await loadRuntimeExtensionSnapshot(bootstrapPmRoot);
-      setActiveExtensionServices(bootstrapSnapshot?.services ?? { overrides: [] });
+      const bootstrapProbe = buildBootstrapActivationProbe(invocationArgv);
+      const discoverySnapshot = await loadRuntimeExtensionDiscoverySnapshot(bootstrapPmRoot);
+      if (discoverySnapshot && discoveryNeedsActivationForProbe(discoverySnapshot.discovery, bootstrapProbe)) {
+        const bootstrapSnapshot = await loadRuntimeExtensionSnapshot(bootstrapPmRoot);
+        setActiveExtensionServices(bootstrapSnapshot?.services ?? { overrides: [] });
+      } else {
+        if (discoverySnapshot) {
+          emitExtensionSkippedProfile(bootstrapProfileEnabled(invocationArgv), discoverySnapshot, bootstrapProbe);
+        }
+        setActiveExtensionServices({ overrides: [] });
+      }
     }
     const numericExitCode = readThrownExitCode(error);
     if (error instanceof PmCliError || !isCommanderError(error) && typeof numericExitCode === "number" && Number.isFinite(numericExitCode)) {
@@ -6729,7 +5756,9 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
         command_resolution: commandResolution2,
         resolution_stage: "execute"
       });
-      sentryCaptureCliError(wrapThrownErrorForSentry(error, errorMessage));
+      if (loggedHandledErrorToSentry) {
+        sentryCaptureCliError(wrapThrownErrorForSentry(error, errorMessage));
+      }
       if (jsonErrors) {
         printError(JSON.stringify(formatPmCliErrorForJson(errorMessage, exitCode, enrichedContext), null, 2));
       } else {