@unbrained/pm-cli 2026.6.13 → 2026.6.17

package/dist/cli-bundle/main.js

@@ -5,13 +5,13 @@ import {
   emitTelemetryErrorEvent,
   finishTelemetryCommand,
   startTelemetryCommand
-} from "./chunks/chunk-AAUYXSFF.js";
+} from "./chunks/chunk-3R3FYCBV.js";
 import {
   migrateItemFilesToFormat
-} from "./chunks/chunk-IIOIBAQW.js";
+} from "./chunks/chunk-26BM6YLO.js";
 import {
   normalizeExtensionNameForMatch
-} from "./chunks/chunk-5LMF75Q7.js";
+} from "./chunks/chunk-AXLDUGXA.js";
 import {
   applyDefaultOutputFormat,
   clearResolvedGlobalOptions,
@@ -21,27 +21,27 @@ import {
   getGlobalOptions,
   invalidateSearchCachesForMutation,
   setResolvedGlobalOptions
-} from "./chunks/chunk-JWXTOYBI.js";
+} from "./chunks/chunk-G2MOUCTU.js";
 import {
   PM_CORE_COMMAND_NAMES,
   resolveSubcommandFlagContractsForCommand
-} from "./chunks/chunk-7CRFV6JR.js";
-import "./chunks/chunk-PEH7SZD2.js";
+} from "./chunks/chunk-VXHMQDXA.js";
+import "./chunks/chunk-YLAW3FZN.js";
 import {
   printError,
   printResult,
   writeStdout
-} from "./chunks/chunk-O3YCJOVX.js";
-import "./chunks/chunk-XXLMJDUB.js";
-import "./chunks/chunk-LGOXXQUW.js";
-import "./chunks/chunk-MACCNKSZ.js";
+} from "./chunks/chunk-R4AKUPKI.js";
+import "./chunks/chunk-KA22USXD.js";
+import "./chunks/chunk-5XGWFUW2.js";
+import "./chunks/chunk-TBV33CB4.js";
 import {
   commandOptionFlagLabel,
   resolveCommandOptionPolicyState,
   resolveItemTypeRegistry,
   resolveTypeDefinition
-} from "./chunks/chunk-W6KNFAMZ.js";
-import "./chunks/chunk-IXVSSHGV.js";
+} from "./chunks/chunk-QXMXRPX5.js";
+import "./chunks/chunk-LNH5Q32E.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
@@ -85,7 +85,7 @@ import {
   setActiveExtensionServices,
   toNonEmptyStringOrUndefined,
   writeSettings
-} from "./chunks/chunk-LFW5NQUP.js";
+} from "./chunks/chunk-CHM2VFVL.js";
 
 // dist/cli/main.js
 import { Command } from "commander";
@@ -186,7 +186,7 @@ async function maybeRunFirstUseTelemetryPrompt(commandPath, globalOptions) {
 !(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] = "8db03e6a-d066-501e-98ea-09a81ba11273");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "8d40e365-c64b-5f7b-a275-92c9123cff27");
   } catch (e2) {
   }
 })();
@@ -655,7 +655,7 @@ async function sentryFlush(timeoutMs = 3e3) {
 !(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] = "b2a33807-c231-539d-ba55-045ba504f088");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "73a3f15b-1652-55b5-8ca9-6eadaaad6420");
   } catch (e2) {
   }
 })();
@@ -802,17 +802,19 @@ function validateLooseCommandOptionsWithFlagDefinitions(options, definitions, co
   for (const definition of definitions) {
     const keys = collectLooseOptionKeys(definition);
     const label = formatLooseOptionLabel(definition);
-    if (label) {
-      labels.push(label);
+    const fallbackLabel = keys.length > 0 ? `--${keys[0]}` : null;
+    const normalizedLabel = label ?? fallbackLabel;
+    if (normalizedLabel) {
+      labels.push(normalizedLabel);
     }
     for (const key of keys) {
       allowed.add(key);
       if (definition.enabled === false) {
-        disabled.set(key, label ?? `--${key}`);
+        disabled.set(key, normalizedLabel);
       }
     }
     if (definition.required === true && definition.enabled !== false && keys.length > 0) {
-      required.push({ keys, label: label ?? `--${keys[0]}` });
+      required.push({ keys, label: normalizedLabel });
     }
   }
   for (const key of Object.keys(options)) {
@@ -968,7 +970,7 @@ function stripLooseCommandOptionTokens(args, definitions) {
     if (parsed) {
       const normalizedKey = toLooseOptionKey(parsed.key);
       if (knownKeys.has(normalizedKey)) {
-        const token = args[index] ?? "";
+        const token = args[index];
         const consumed = booleanKeys.has(normalizedKey) && !token.includes("=") ? 1 : parsed.consumed;
         index += consumed;
         continue;
@@ -984,19 +986,23 @@ function stripLooseCommandOptionTokens(args, definitions) {
 !(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] = "a1d00ac8-e750-598f-a4ec-20581735dc84");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "146dcfa8-3537-5d79-b9b6-475987cf6224");
   } catch (e2) {
   }
 })();
+function firstExampleOrEmpty(examples) {
+  return examples.length > 0 ? [examples[0]] : [];
+}
 function renderCompactHelpBundle(bundle) {
   const lines = [
     "",
     "Intent:",
     `  ${bundle.why}`
   ];
-  if (bundle.examples.length > 0) {
+  const compactExamples = firstExampleOrEmpty(bundle.examples);
+  if (compactExamples.length > 0) {
     lines.push("", "Example:");
-    lines.push(`  ${bundle.examples[0]}`);
+    lines.push(`  ${compactExamples[0]}`);
   }
   lines.push("", "Need deeper rationale and more examples?");
   lines.push("  Re-run with --explain.");
@@ -1229,6 +1235,19 @@ var HELP_BY_COMMAND_PATH = {
       "Use --type <value> to load type-aware policy guidance in --help output."
     ]
   },
+  focus: {
+    why: "Sets a session focused item so new pm create items default their --parent to it (project management = context management).",
+    examples: [
+      "pm focus pm-epic1",
+      "pm focus",
+      "pm focus --clear"
+    ],
+    tips: [
+      "Focus is session-local (stored in .agents/pm/runtime/session.json, gitignored) \u2014 it never affects teammates.",
+      'An explicit --parent on pm create always overrides the focused item; use --parent "" to create with no parent.',
+      "A stale focused item produces the same missing-parent validation as an explicit stale --parent."
+    ]
+  },
   update: {
     why: "Mutates existing item fields while preserving history and lock safety.",
     examples: [
@@ -1436,7 +1455,7 @@ var HELP_BY_COMMAND_PATH = {
     tips: [
       "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)."
+      "JSON output shape is { item, linked, claim_state, children }; body is nested at item.body (parity with list --include-body), and children appears for requested/container rollups."
     ]
   },
   history: {
@@ -1652,6 +1671,30 @@ var HELP_BY_COMMAND_PATH = {
     why: "Lifecycle alias that closes with reason text and clears assignment metadata.",
     examples: ['pm close-task pm-a1b2 "All acceptance criteria met" --author "codex-agent" --message "Close and handoff"']
   },
+  meet: {
+    why: "Shortcut to create a Meeting from friendly time flags (start/duration) without structured --event CSV.",
+    examples: [
+      'pm meet "Sprint Planning" --start +1h --duration 1h',
+      'pm meet "1:1" --start 2026-07-01T15:00:00Z --end 2026-07-01T15:30:00Z --location "Room A"'
+    ],
+    tips: [
+      "Start defaults to now and duration to 1h; pass --end to set an explicit end instead of --duration.",
+      "--duration units are h/d/w/m where m is months (not minutes); use --end for sub-hour spans."
+    ]
+  },
+  event: {
+    why: "Shortcut to create an Event from friendly time flags (start/duration) without structured --event CSV.",
+    examples: [
+      'pm event "Release v2" --start 2026-07-01T10:00:00Z --duration 2h',
+      'pm event "Conference" --start 2026-08-01 --all-day'
+    ],
+    tips: ["Start defaults to now and duration to 1h; pass --end to set an explicit end instead of --duration."]
+  },
+  remind: {
+    why: "Shortcut to create a Reminder from a single point in time without structured --reminder CSV.",
+    examples: ['pm remind "Review PR" --at +2d', 'pm remind "Follow up" --at 2026-07-01T09:00:00Z --text "Ping the team"'],
+    tips: ["The reminder time defaults to +1d and the reminder text defaults to the title."]
+  },
   completion: {
     why: "Generates shell completion scripts for faster and more reliable command entry.",
     examples: ["pm completion bash", "pm completion zsh", "pm completion fish", "pm completion bash --eager-tags"],
@@ -1703,7 +1746,7 @@ function resolveHelpNarrative(commandPath, detailMode) {
   const bundle = resolveHelpBundleForPath(commandPath);
   return {
     intent: bundle.why,
-    examples: detailMode === "detailed" ? [...bundle.examples] : bundle.examples.length > 0 ? [bundle.examples[0]] : [],
+    examples: detailMode === "detailed" ? [...bundle.examples] : firstExampleOrEmpty(bundle.examples),
     tips: detailMode === "detailed" ? [...bundle.tips ?? []] : [],
     detail_mode: detailMode
   };
@@ -1762,10 +1805,28 @@ 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] = "1f68f12a-2565-58b4-b38f-dba63e31a88a");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "5ecd5461-a75d-524f-9d41-e4108f6c3d21");
   } catch (e2) {
   }
 })();
+var STRUCTURED_WHY_SUPPRESSION_CODES = /* @__PURE__ */ new Set([
+  "unknown_command",
+  "unknown_option",
+  "missing_required_option",
+  "missing_required_argument",
+  "invalid_argument_value",
+  "invalid_command_usage",
+  "command_failed"
+]);
+function includeWhyInStructuredGuidance(message) {
+  if (!message.why) {
+    return false;
+  }
+  if (message.recovery?.recovery_mode === "compact") {
+    return false;
+  }
+  return !STRUCTURED_WHY_SUPPRESSION_CODES.has(message.code);
+}
 function errorType(code) {
   return `urn:pm-cli:error:${code}`;
 }
@@ -1932,7 +1993,7 @@ function guidanceToJsonEnvelope(message, exitCode) {
     required: message.required,
     exit_code: exitCode
   };
-  if (message.why) {
+  if (includeWhyInStructuredGuidance(message)) {
     payload.why = message.why;
   }
   if (message.examples && message.examples.length > 0) {
@@ -1954,7 +2015,7 @@ function guidanceToClassification(message) {
     detail: message.happened,
     required: message.required
   };
-  if (message.why) {
+  if (includeWhyInStructuredGuidance(message)) {
     payload.why = message.why;
   }
   if (message.examples && message.examples.length > 0) {
@@ -2027,7 +2088,7 @@ function buildAllowedValueRetryCommand(recovery, allowedValues) {
   return void 0;
 }
 function buildFallbackTitleFromMessage(message) {
-  const firstLine = message.split(/\r?\n/)[0]?.trim() ?? "";
+  const firstLine = message.split(/\r?\n/)[0].trim();
   if (firstLine.length === 0) {
     return void 0;
   }
@@ -2134,10 +2195,11 @@ function buildPmCliErrorGuidance(rawMessage, context) {
   if (missingRequiredOption || missingRequiredOptions) {
     const plural = Boolean(missingRequiredOptions);
     const missingOptionFlag = !plural ? message.replace(/^Missing required option\s+/, "").trim() : null;
+    const missingOptionLabel = missingOptionFlag ?? "";
     const missingOptionRequired = missingOptionFlag ? `Pass ${missingOptionFlag} with a valid value before running the command.` : "Provide the required option for this command invocation.";
     return applyPmCliErrorContext(makeGuidanceMessage({
       code: "missing_required_option",
-      title: plural ? "Missing required options" : missingOptionFlag ? `Missing required option ${missingOptionFlag}` : "Missing required option",
+      title: plural ? "Missing required options" : `Missing required option ${missingOptionLabel}`,
       happened: message,
       required: plural ? "Provide every required option for this command invocation." : missingOptionRequired,
       why: "Required options define command intent and enforce deterministic write contracts.",
@@ -2945,7 +3007,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] = "b9a4b15e-8a4c-5a00-b42e-ff9a3cf88bf1");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "b586e62c-508a-5b84-9104-e9df98a81188");
   } catch (e2) {
   }
 })();
@@ -3230,8 +3292,8 @@ function collectLongFlagCandidates(contract) {
   }
   return candidates;
 }
-function buildFlagLookup(commandName) {
-  const contracts = resolveSubcommandFlagContractsForCommand(commandName);
+function buildFlagLookup(commandName, contractsOverride) {
+  const contracts = contractsOverride ?? resolveSubcommandFlagContractsForCommand(commandName);
   const canonicalByNormalized = /* @__PURE__ */ new Map();
   const canonicalByCompact = /* @__PURE__ */ new Map();
   const canonicalComparablesMap = /* @__PURE__ */ new Map();
@@ -3741,7 +3803,7 @@ async function enforceItemFormatWriteGateAndPreflightMigration(commandPath, opti
 !(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] = "591ae949-391a-5ede-8e92-15df7e3264df");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "40abf375-9b2a-5973-9c05-a3ba20617c07");
   } catch (e2) {
   }
 })();
@@ -3918,9 +3980,9 @@ function collectInstalledPackageCommandPathHints(unknownToken, extensionDescript
   }
   return [...new Set(hints)].sort((left, right) => left.localeCompare(right));
 }
-function collectKnownLongFlags(commandName) {
+function collectKnownLongFlags(commandName, contractsOverride) {
   const flags = /* @__PURE__ */ new Set();
-  const contracts = resolveSubcommandFlagContractsForCommand(commandName);
+  const contracts = contractsOverride ?? resolveSubcommandFlagContractsForCommand(commandName);
   for (const contract of contracts) {
     if (contract.flag.startsWith("--")) {
       flags.add(normalizeLongFlag(contract.flag));
@@ -4042,7 +4104,7 @@ function buildUnknownCommandGuidanceFromRuntime(rawMessage, root, extensionDescr
   if (commandPaths.length === 0) {
     return void 0;
   }
-  const primaryToken = normalizedUnknown.split(" ")[0] ?? normalizedUnknown;
+  const primaryToken = normalizedUnknown.split(" ")[0];
   const rankedCandidates = commandPaths.map((commandPath) => {
     const directScore = scoreCommandPathMatch(commandPath, normalizedUnknown);
     const fallbackScore = primaryToken !== normalizedUnknown ? scoreCommandPathMatch(commandPath, primaryToken) : Number.POSITIVE_INFINITY;
@@ -4060,7 +4122,8 @@ 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((path) => `pm ${path} --help`)])];
+  const suggestedExamples = suggestedPaths.map((path) => `pm ${path} --help`);
+  const examples = combinedCandidates.length > 0 ? [.../* @__PURE__ */ new Set([...suggestedExamples, "pm --help"])] : [.../* @__PURE__ */ new Set(["pm --help", ...suggestedExamples])];
   const optionalPackageHint = resolveOptionalPackageInstallHint(normalizedUnknown);
   const didYouMean = combinedCandidates.length > 0 ? `Did you mean: ${combinedCandidates.slice(0, 3).join(", ")}?` : null;
   return {
@@ -4222,7 +4285,7 @@ async function formatCommanderUsageJson(error, rootProgram, extensionDescriptors
 !(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] = "878a1569-b6af-5522-8c4a-458db8c0cbf4");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9cd6003e-01d2-51de-9fbd-aa1d49d03e68");
   } catch (e2) {
   }
 })();
@@ -4318,14 +4381,13 @@ function compactHelpOptionAliases(options) {
     }
   }
   for (const aliasOption of aliasOptions) {
-    if (!aliasOption.alias_for || !aliasOption.long) {
-      continue;
-    }
-    const canonical = canonicalByLong.get(aliasOption.alias_for);
+    const aliasFor = aliasOption.alias_for;
+    const canonical = canonicalByLong.get(aliasFor);
     if (!canonical) {
       continue;
     }
-    const aliases = /* @__PURE__ */ new Set([...canonical.aliases ?? [], aliasOption.long]);
+    const aliasLong = aliasOption.long;
+    const aliases = /* @__PURE__ */ new Set([...canonical.aliases ?? [], aliasLong]);
     canonical.aliases = [...aliases].sort((left, right) => left.localeCompare(right));
   }
   return options.filter((option) => {
@@ -4496,7 +4558,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] = "ac26a754-8191-5d1f-95a9-0edbaec1b09f");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "12283419-5440-5044-9a95-611ae055357c");
   } catch (e2) {
   }
 })();
@@ -4509,6 +4571,9 @@ if (typeof process.env[PM_PACKAGE_ROOT_ENV] !== "string" || process.env[PM_PACKA
 }
 var activeExtensionHookContext = null;
 var activeTelemetryCommandContext = null;
+function setActiveExtensionHookContextForTest(context) {
+  activeExtensionHookContext = context;
+}
 var TELEMETRY_COMMAND_RESOLUTION_SET = /* @__PURE__ */ new Set([
   "success",
   "nonexistent_command",
@@ -4535,10 +4600,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-DQEIKBIP.js"));
-var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-PWQ5F2VI.js"));
-var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-QKFPTIZG.js"));
-var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-2FMZ6WEF.js"));
+var loadSetupRegistrationModule = createLazyModule(() => import("./chunks/register-setup-WHG3NBP6.js"));
+var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-C2MS3BVQ.js"));
+var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-6UCOEQ6L.js"));
+var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-L6C32FDA.js"));
 function describeUnknownError(error) {
   if (error instanceof PmCliError) {
     return error.message;
@@ -4589,6 +4654,7 @@ function buildPmCliRecoveryContext(context, invocationArgv, rawMessage) {
   const existingRecovery = context?.recovery;
   if (existingRecovery?.recovery_mode === "compact" && !explainRequested) {
     return {
+      /* c8 ignore next */
       ...context ?? {},
       recovery: existingRecovery
     };
@@ -4616,6 +4682,7 @@ function buildPmCliRecoveryContext(context, invocationArgv, rawMessage) {
   const recovery = {
     attempted_command: existingRecovery?.attempted_command ?? attemptedCommand,
     normalized_args: existingRecovery?.normalized_args ?? [...invocationArgv],
+    /* c8 ignore next */
     provided_fields: existingRecovery?.provided_fields ?? (providedFields.length > 0 ? providedFields : void 0),
     missing: existingRecovery?.missing ?? inferredMissing,
     ...existingRecovery?.recovery_mode ? { recovery_mode: existingRecovery.recovery_mode } : {},
@@ -4839,6 +4906,67 @@ async function maybeLogHandledCliErrorToSentry(params) {
   sentryLogCliUsageError(params);
   return true;
 }
+async function handleGenericRunPmCliError(params) {
+  const message = describeUnknownError(params.error);
+  const classification = classifyUnknownError(message);
+  if (params.bootstrapGlobal.json) {
+    printError(JSON.stringify(formatUnknownErrorForJson(message, EXIT_CODE.GENERIC_FAILURE), null, 2));
+  } else {
+    printError(message);
+  }
+  process.exitCode = EXIT_CODE.GENERIC_FAILURE;
+  let errorCategory = "runtime";
+  let commandResolution = "runtime_failed";
+  try {
+    await ensureSentryForErrorReporting();
+    sentryCaptureCliError(params.error);
+    const telemetry = await params.emitTelemetryCommandError({
+      command: params.attemptedCommand,
+      errorCode: classification.code,
+      errorMessage: classification.detail,
+      exitCode: EXIT_CODE.GENERIC_FAILURE,
+      options: {
+        bootstrap_global_options: params.bootstrapGlobal
+      },
+      resolutionStage: "execute"
+    });
+    errorCategory = telemetry.errorCategory;
+    commandResolution = telemetry.commandResolution;
+    sentryFinishCommandSpan(false, message, {
+      error_code: classification.code,
+      error_category: errorCategory,
+      exit_code: EXIT_CODE.GENERIC_FAILURE,
+      command_resolution: commandResolution,
+      resolution_stage: "execute"
+    });
+  } catch (reportingError) {
+    if (!params.bootstrapGlobal.json) {
+      printError(`Failed to report error: ${describeUnknownError(reportingError)}`);
+    }
+  }
+  try {
+    await runAndClearAfterCommandHooks({
+      ok: false,
+      error: message,
+      exit_code: EXIT_CODE.GENERIC_FAILURE,
+      error_code: classification.code,
+      error_category: errorCategory,
+      command_resolution: commandResolution,
+      resolution_stage: "execute"
+    });
+  } catch (hookError) {
+    if (!params.bootstrapGlobal.json) {
+      printError(`Failed to run error hooks: ${describeUnknownError(hookError)}`);
+    }
+  }
+  try {
+    await sentryFlush();
+  } catch (flushError) {
+    if (!params.bootstrapGlobal.json) {
+      printError(`Failed to flush error reporting: ${describeUnknownError(flushError)}`);
+    }
+  }
+}
 function extractCommandScopedOptions(command, commandArgs, extensionFlagDefinitions = []) {
   const allOptions = command.optsWithGlobals();
   const scoped = { ...allOptions };
@@ -5924,7 +6052,24 @@ function resolveCoreCommandRegistrationSelection(invocationArgv) {
 function shouldAttachRichHelpTextForInvocation(invocationArgv) {
   return invocationArgv.length === 0 || parseBootstrapHelpRequest(invocationArgv).requested;
 }
+var IDEMPOTENT_TOP_LEVEL_REGISTRATION = /* @__PURE__ */ Symbol("pmCliIdempotentTopLevelRegistration");
+function ensureIdempotentTopLevelCommandRegistration(rootProgram) {
+  const guarded = rootProgram;
+  if (guarded[IDEMPOTENT_TOP_LEVEL_REGISTRATION]) {
+    return;
+  }
+  guarded[IDEMPOTENT_TOP_LEVEL_REGISTRATION] = true;
+  const registerOriginalCommand = rootProgram.command.bind(rootProgram);
+  rootProgram.command = ((nameAndArgs, ...rest) => {
+    const commandName = nameAndArgs.split(/\s+/u)[0];
+    if (rootProgram.commands.some((existing) => existing.name() === commandName || existing.aliases().includes(commandName))) {
+      return new Command(commandName);
+    }
+    return registerOriginalCommand(nameAndArgs, ...rest);
+  });
+}
 async function registerCoreCommandFamilies(rootProgram, selection) {
+  ensureIdempotentTopLevelCommandRegistration(rootProgram);
   if (selection.setup) {
     const { registerSetupCommands } = await loadSetupRegistrationModule();
     registerSetupCommands(rootProgram);
@@ -6030,11 +6175,11 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
     const bootstrapPmRoot = resolvePmRoot(process.cwd(), bootstrapGlobal.path);
     const attemptedCommand = parseBootstrapCommandName(invocationArgv) ?? "<unknown>";
     const emitTelemetryCommandError = async (params) => {
-      const errorCategory2 = resolveTelemetryErrorCategory(params.errorCode);
-      const commandResolution2 = deriveTelemetryCommandResolution({
+      const errorCategory = resolveTelemetryErrorCategory(params.errorCode);
+      const commandResolution = deriveTelemetryCommandResolution({
         ok: false,
         errorCode: params.errorCode,
-        errorCategory: errorCategory2
+        errorCategory
       });
       await emitTelemetryErrorEvent({
         command: params.command,
@@ -6046,13 +6191,13 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
         error_code: params.errorCode,
         error_message: params.errorMessage,
         exit_code: params.exitCode,
-        error_category: errorCategory2,
-        command_resolution: commandResolution2,
+        error_category: errorCategory,
+        command_resolution: commandResolution,
         resolution_stage: params.resolutionStage
       });
       return {
-        errorCategory: errorCategory2,
-        commandResolution: commandResolution2
+        errorCategory,
+        commandResolution
       };
     };
     if (!bootstrapGlobal.noExtensions) {
@@ -6074,11 +6219,13 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
       const exitCode = error instanceof PmCliError ? error.exitCode : normalizeThrownExitCode(numericExitCode);
       const context = error instanceof PmCliError ? error.context : void 0;
       const enrichedContext = buildPmCliRecoveryContext(context, invocationArgv, errorMessage);
-      const classification2 = classifyPmCliError(errorMessage, enrichedContext);
-      const { errorCategory: errorCategory2, commandResolution: commandResolution2 } = await emitTelemetryCommandError({
+      const classification = classifyPmCliError(errorMessage, enrichedContext);
+      const renderedError = jsonErrors ? JSON.stringify(formatPmCliErrorForJson(errorMessage, exitCode, enrichedContext), null, 2) : formatPmCliErrorForDisplay(errorMessage, enrichedContext);
+      printError(renderedError);
+      const { errorCategory, commandResolution } = await emitTelemetryCommandError({
         command: attemptedCommand,
-        errorCode: classification2.code,
-        errorMessage: classification2.detail,
+        errorCode: classification.code,
+        errorMessage: classification.detail,
         exitCode,
         options: {
           bootstrap_global_options: bootstrapGlobal
@@ -6087,38 +6234,33 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
       });
       const loggedHandledErrorToSentry = await maybeLogHandledCliErrorToSentry({
         command: attemptedCommand,
-        error_code: classification2.code,
-        error_category: errorCategory2,
+        error_code: classification.code,
+        error_category: errorCategory,
         exit_code: exitCode,
-        error_message: classification2.detail,
-        command_resolution: commandResolution2,
+        error_message: classification.detail,
+        command_resolution: commandResolution,
         resolution_stage: "execute",
         source_context: activeTelemetryCommandContext?.source_context
       });
       sentryFinishCommandSpan(false, errorMessage, {
-        error_code: classification2.code,
-        error_category: errorCategory2,
+        error_code: classification.code,
+        error_category: errorCategory,
         exit_code: exitCode,
-        command_resolution: commandResolution2,
+        command_resolution: commandResolution,
         resolution_stage: "execute"
       });
       await runAndClearAfterCommandHooks({
         ok: false,
         error: errorMessage,
         exit_code: exitCode,
-        error_code: classification2.code,
-        error_category: errorCategory2,
-        command_resolution: commandResolution2,
+        error_code: classification.code,
+        error_category: errorCategory,
+        command_resolution: commandResolution,
         resolution_stage: "execute"
       });
       if (loggedHandledErrorToSentry) {
         sentryCaptureCliError(wrapThrownErrorForSentry(error, errorMessage));
       }
-      if (jsonErrors) {
-        printError(JSON.stringify(formatPmCliErrorForJson(errorMessage, exitCode, enrichedContext), null, 2));
-      } else {
-        printError(formatPmCliErrorForDisplay(errorMessage, enrichedContext));
-      }
       if (loggedHandledErrorToSentry) {
         await sentryFlush(HANDLED_ERROR_SENTRY_FLUSH_TIMEOUT_MS);
       }
@@ -6136,7 +6278,7 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
           const unknownMessage = `unknown command '${unknownToken}'`;
           const recoveryCommandDescriptors = await loadRuntimeExtensionCommandDescriptorsForRecovery(resolvePmRoot(process.cwd(), bootstrapGlobal.path));
           const usageContext = await resolveCommanderUsageContext({ message: unknownMessage }, program, recoveryCommandDescriptors);
-          const classification2 = classifyCommanderError(usageContext.message, usageContext.commandName, usageContext.allowedTypes, {
+          const classification = classifyCommanderError(usageContext.message, usageContext.commandName, usageContext.allowedTypes, {
             unknownCommandExamples: usageContext.unknownCommandExamples,
             unknownCommandNextSteps: usageContext.unknownCommandNextSteps,
             attemptedCommand: usageContext.attemptedCommand,
@@ -6145,10 +6287,10 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
             unknownOptionSuggestions: usageContext.unknownOptionSuggestions,
             suggestedRetryCommand: usageContext.suggestedRetryCommand
           });
-          const { errorCategory: errorCategory2, commandResolution: commandResolution2 } = await emitTelemetryCommandError({
+          const { errorCategory, commandResolution } = await emitTelemetryCommandError({
             command: unknownToken,
-            errorCode: classification2.code,
-            errorMessage: classification2.detail,
+            errorCode: classification.code,
+            errorMessage: classification.detail,
             exitCode: EXIT_CODE.USAGE,
             options: {
               bootstrap_global_options: bootstrapGlobal,
@@ -6158,29 +6300,29 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
           });
           const loggedHandledErrorToSentry = await maybeLogHandledCliErrorToSentry({
             command: unknownToken,
-            error_code: classification2.code,
-            error_category: errorCategory2,
+            error_code: classification.code,
+            error_category: errorCategory,
             exit_code: EXIT_CODE.USAGE,
-            error_message: classification2.detail,
-            command_resolution: commandResolution2,
+            error_message: classification.detail,
+            command_resolution: commandResolution,
             resolution_stage: "parse",
             source_context: activeTelemetryCommandContext?.source_context
           });
           const renderedUsage = jsonErrors ? await formatCommanderUsageJson({ message: unknownMessage }, program, recoveryCommandDescriptors) : await formatCommanderUsageMessage({ message: unknownMessage }, program, recoveryCommandDescriptors);
           sentryFinishCommandSpan(false, unknownMessage, {
-            error_code: classification2.code,
-            error_category: errorCategory2,
+            error_code: classification.code,
+            error_category: errorCategory,
             exit_code: EXIT_CODE.USAGE,
-            command_resolution: commandResolution2,
+            command_resolution: commandResolution,
             resolution_stage: "parse"
           });
           await runAndClearAfterCommandHooks({
             ok: false,
             error: unknownMessage,
             exit_code: EXIT_CODE.USAGE,
-            error_code: classification2.code,
-            error_category: errorCategory2,
-            command_resolution: commandResolution2,
+            error_code: classification.code,
+            error_category: errorCategory,
+            command_resolution: commandResolution,
             resolution_stage: "parse"
           });
           if (jsonErrors) {
@@ -6225,7 +6367,7 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
       }
       if (code?.startsWith("commander.")) {
         const usageContext = await resolveCommanderUsageContext(error, program, activeRuntimeExtensionCommandDescriptors);
-        const classification2 = classifyCommanderError(usageContext.message, usageContext.commandName, usageContext.allowedTypes, {
+        const classification = classifyCommanderError(usageContext.message, usageContext.commandName, usageContext.allowedTypes, {
           unknownCommandExamples: usageContext.unknownCommandExamples,
           unknownCommandNextSteps: usageContext.unknownCommandNextSteps,
           attemptedCommand: usageContext.attemptedCommand,
@@ -6234,10 +6376,10 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
           unknownOptionSuggestions: usageContext.unknownOptionSuggestions,
           suggestedRetryCommand: usageContext.suggestedRetryCommand
         });
-        const { errorCategory: errorCategory2, commandResolution: commandResolution2 } = await emitTelemetryCommandError({
+        const { errorCategory, commandResolution } = await emitTelemetryCommandError({
           command: attemptedCommand,
-          errorCode: classification2.code,
-          errorMessage: classification2.detail,
+          errorCode: classification.code,
+          errorMessage: classification.detail,
           exitCode: EXIT_CODE.USAGE,
           options: {
             bootstrap_global_options: bootstrapGlobal,
@@ -6247,29 +6389,29 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
         });
         const loggedHandledErrorToSentry = await maybeLogHandledCliErrorToSentry({
           command: attemptedCommand,
-          error_code: classification2.code,
-          error_category: errorCategory2,
+          error_code: classification.code,
+          error_category: errorCategory,
           exit_code: EXIT_CODE.USAGE,
-          error_message: classification2.detail,
-          command_resolution: commandResolution2,
+          error_message: classification.detail,
+          command_resolution: commandResolution,
           resolution_stage: "parse",
           source_context: activeTelemetryCommandContext?.source_context
         });
         const renderedUsage = jsonErrors ? await formatCommanderUsageJson(error, program, activeRuntimeExtensionCommandDescriptors) : await formatCommanderUsageMessage(error, program, activeRuntimeExtensionCommandDescriptors);
         sentryFinishCommandSpan(false, usageContext.message, {
-          error_code: classification2.code,
-          error_category: errorCategory2,
+          error_code: classification.code,
+          error_category: errorCategory,
           exit_code: EXIT_CODE.USAGE,
-          command_resolution: commandResolution2,
+          command_resolution: commandResolution,
           resolution_stage: "parse"
         });
         await runAndClearAfterCommandHooks({
           ok: false,
           error: usageContext.message,
           exit_code: EXIT_CODE.USAGE,
-          error_code: classification2.code,
-          error_category: errorCategory2,
-          command_resolution: commandResolution2,
+          error_code: classification.code,
+          error_category: errorCategory,
+          command_resolution: commandResolution,
           resolution_stage: "parse"
         });
         if (jsonErrors) {
@@ -6284,51 +6426,82 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
         return;
       }
     }
-    await ensureSentryForErrorReporting();
-    sentryCaptureCliError(error);
-    const message = describeUnknownError(error);
-    const classification = classifyUnknownError(message);
-    const { errorCategory, commandResolution } = await emitTelemetryCommandError({
-      command: attemptedCommand,
-      errorCode: classification.code,
-      errorMessage: classification.detail,
-      exitCode: EXIT_CODE.GENERIC_FAILURE,
-      options: {
-        bootstrap_global_options: bootstrapGlobal
-      },
-      resolutionStage: "execute"
-    });
-    sentryFinishCommandSpan(false, message, {
-      error_code: classification.code,
-      error_category: errorCategory,
-      exit_code: EXIT_CODE.GENERIC_FAILURE,
-      command_resolution: commandResolution,
-      resolution_stage: "execute"
+    await handleGenericRunPmCliError({
+      error,
+      attemptedCommand,
+      bootstrapGlobal,
+      emitTelemetryCommandError
     });
-    await runAndClearAfterCommandHooks({
-      ok: false,
-      error: message,
-      exit_code: EXIT_CODE.GENERIC_FAILURE,
-      error_code: classification.code,
-      error_category: errorCategory,
-      command_resolution: commandResolution,
-      resolution_stage: "execute"
-    });
-    if (jsonErrors) {
-      printError(JSON.stringify(formatUnknownErrorForJson(message, EXIT_CODE.GENERIC_FAILURE), null, 2));
-    } else {
-      printError(message);
-    }
-    await sentryFlush();
-    process.exitCode = EXIT_CODE.GENERIC_FAILURE;
   }
 }
 var _testOnly = {
+  activationCommandMatchesProbe,
+  bootstrapProfileEnabled,
+  buildBootstrapActivationProbe,
+  buildPostActionTelemetryOutcome,
   buildPmCliRecoveryContext,
+  buildRuntimeExtensionDiscoverySnapshotCacheKey,
+  buildRuntimeExtensionSnapshotCacheKey,
+  addRuntimeFieldOption,
+  collectActivationCommandCandidates,
+  collectExtensionFlagDefinitionsForCommand,
+  collectExtensionFlagDefinitionsForInvocation,
+  collectLeadingCommandArgs,
+  collectParsedActivationCommandArgs,
+  collectRuntimeFieldLooseFlagDefinitionsForCommand,
+  commandHasLongOption,
+  commandHasShortOption,
+  commandPathNeedsSearchExtensions,
+  commandPathNeedsTemplateExtensions,
+  describeUnknownError,
+  defaultPreflightDecision,
+  discoveryNeedsActivationForProbe,
+  emitExtensionProfile,
+  emitExtensionSkippedProfile,
+  emitSettingsReadWarnings,
+  ensureIdempotentTopLevelCommandRegistration,
+  enforceExplicitRetryForFlagTypos,
+  envFlagEnabled,
+  executeRegisteredRuntimeMigrations,
+  extractCommandScopedOptions,
+  extensionActivationCommands,
+  extensionCapabilities,
+  extensionNeedsActivationForProbe,
+  extensionProvidesTemplatesRuntime,
+  hasAnyCapability,
+  handleGenericRunPmCliError,
+  inferMissingFieldsFromErrorMessage,
+  inferPostActionErrorCode,
+  inferPostActionFailureMessage,
+  invocationRequestsVersion,
   isCommanderError,
+  loadRuntimeExtensionCommandDescriptorsForRecovery,
+  loadRuntimeExtensionDiscoverySnapshot,
+  loadRuntimeExtensionSnapshot,
+  maybeLoadRuntimeExtensions,
+  maybeAttachCreateUpdatePolicyHelpText,
+  maybeLogHandledCliErrorToSentry,
+  normalizeTelemetryCommandResolution,
+  normalizeTelemetryErrorCategory,
+  normalizeTelemetryResolutionStage,
   normalizeThrownExitCode,
+  probeUsesAnyFlag,
+  readRecordBoolean,
+  readRecordNumber,
+  readRecordString,
+  registerDynamicExtensionCommandPaths,
+  registerRuntimeSchemaFieldFlags,
+  resolveCoreCommandRegistrationSelection,
   readThrownExitCode,
+  runAndClearAfterCommandHooks,
+  runRequiredExtensionCommand,
+  shouldAttachRichHelpTextForInvocation,
   shouldLogHandledErrorToSentry,
+  shouldRegisterDynamicExtensionPaths,
+  shouldRegisterRuntimeSchemaFlags,
+  setActiveExtensionHookContextForTest,
+  toLooseFieldDefinitionType,
+  wrapProgramActionsForExtensionHandlers,
   wrapThrownErrorForSentry
 };
 export {