@unbrained/pm-cli 2026.6.12 → 2026.6.16

package/dist/cli-bundle/main.js

@@ -5,13 +5,13 @@ import {
   emitTelemetryErrorEvent,
   finishTelemetryCommand,
   startTelemetryCommand
-} from "./chunks/chunk-GKIZW7SM.js";
+} from "./chunks/chunk-764O7EUA.js";
 import {
   migrateItemFilesToFormat
-} from "./chunks/chunk-VSRZRLG3.js";
+} from "./chunks/chunk-F2GC6L3N.js";
 import {
   normalizeExtensionNameForMatch
-} from "./chunks/chunk-ZLMIWZUG.js";
+} from "./chunks/chunk-SY4PZWIZ.js";
 import {
   applyDefaultOutputFormat,
   clearResolvedGlobalOptions,
@@ -21,27 +21,27 @@ import {
   getGlobalOptions,
   invalidateSearchCachesForMutation,
   setResolvedGlobalOptions
-} from "./chunks/chunk-37CYVF73.js";
+} from "./chunks/chunk-TIRZIQRP.js";
 import {
   PM_CORE_COMMAND_NAMES,
   resolveSubcommandFlagContractsForCommand
-} from "./chunks/chunk-35P4GT6E.js";
-import "./chunks/chunk-7UGSRQCL.js";
+} from "./chunks/chunk-H6EH6ENJ.js";
+import "./chunks/chunk-TUB3DZAZ.js";
 import {
   printError,
   printResult,
   writeStdout
-} from "./chunks/chunk-GWZSYR6X.js";
-import "./chunks/chunk-3KLPFWZ4.js";
-import "./chunks/chunk-VPEAS7PS.js";
-import "./chunks/chunk-73ZPG2I3.js";
+} from "./chunks/chunk-SPYPC5CB.js";
+import "./chunks/chunk-4KBK4BA3.js";
+import "./chunks/chunk-WZCQVABQ.js";
+import "./chunks/chunk-GYMG7AG6.js";
 import {
   commandOptionFlagLabel,
   resolveCommandOptionPolicyState,
   resolveItemTypeRegistry,
   resolveTypeDefinition
-} from "./chunks/chunk-5SCT2JCT.js";
-import "./chunks/chunk-IUKD4W6Z.js";
+} from "./chunks/chunk-6BV7ENQL.js";
+import "./chunks/chunk-OY3P2I6B.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
@@ -85,7 +85,7 @@ import {
   setActiveExtensionServices,
   toNonEmptyStringOrUndefined,
   writeSettings
-} from "./chunks/chunk-FY4SPXSC.js";
+} from "./chunks/chunk-LV5FFQ7M.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] = "0ae19066-4ac9-55c8-bb28-0204a184caba");
   } 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: {
@@ -1703,7 +1722,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 +1781,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] = "492e5d0f-cf1f-5e6e-a75e-b74944ffcb84");
+    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}`;
 }
@@ -1798,7 +1835,17 @@ function normalizeRecoveryPayload(payload) {
   if (!payload || typeof payload !== "object") {
     return void 0;
   }
+  const normalizeStringArray = (values) => {
+    if (!Array.isArray(values)) {
+      return void 0;
+    }
+    const normalized2 = values.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    return normalized2.length > 0 ? normalized2 : void 0;
+  };
   const normalized = {};
+  if (payload.recovery_mode === "compact") {
+    normalized.recovery_mode = "compact";
+  }
   if (typeof payload.attempted_command === "string" && payload.attempted_command.trim().length > 0) {
     normalized.attempted_command = payload.attempted_command.trim();
   }
@@ -1820,6 +1867,14 @@ function normalizeRecoveryPayload(payload) {
       normalized.missing = missing;
     }
   }
+  const missingRequiredFields = normalizeStringArray(payload.missing_required_fields);
+  if (missingRequiredFields) {
+    normalized.missing_required_fields = missingRequiredFields;
+  }
+  const suggestedFlags = normalizeStringArray(payload.suggested_flags);
+  if (suggestedFlags) {
+    normalized.suggested_flags = suggestedFlags;
+  }
   if (typeof payload.suggested_retry === "string" && payload.suggested_retry.trim().length > 0) {
     normalized.suggested_retry = payload.suggested_retry.trim();
   }
@@ -1856,6 +1911,12 @@ function renderRecoveryBundle(recovery) {
   if (normalized.missing && normalized.missing.length > 0) {
     lines.push(`  missing: ${normalized.missing.join(", ")}`);
   }
+  if (normalized.missing_required_fields && normalized.missing_required_fields.length > 0) {
+    lines.push(`  missing_required_fields: ${normalized.missing_required_fields.join(", ")}`);
+  }
+  if (normalized.suggested_flags && normalized.suggested_flags.length > 0) {
+    lines.push(`  suggested_flags: ${normalized.suggested_flags.join(", ")}`);
+  }
   if (normalized.suggested_retry) {
     lines.push(`  suggested_retry: ${normalized.suggested_retry}`);
   }
@@ -1908,7 +1969,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) {
@@ -1930,7 +1991,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) {
@@ -2003,7 +2064,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;
   }
@@ -2110,10 +2171,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.",
@@ -2921,7 +2983,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) {
   }
 })();
@@ -3206,8 +3268,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();
@@ -3717,7 +3779,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) {
   }
 })();
@@ -3894,9 +3956,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));
@@ -4018,7 +4080,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;
@@ -4036,7 +4098,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 {
@@ -4198,7 +4261,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) {
   }
 })();
@@ -4294,14 +4357,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) => {
@@ -4472,7 +4534,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] = "5b1ed048-2b19-58fc-8c2b-10036fb6c237");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "690692b1-fa87-55c9-9782-7324e6d15db3");
   } catch (e2) {
   }
 })();
@@ -4485,6 +4547,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",
@@ -4511,10 +4576,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-KVNLO5OJ.js"));
-var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-4UPMHONX.js"));
-var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-FARSGYRD.js"));
-var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-HCJKDUA6.js"));
+var loadSetupRegistrationModule = createLazyModule(() => import("./chunks/register-setup-7UKEFKT6.js"));
+var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-N7Z7RTDM.js"));
+var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-UFZK6Q57.js"));
+var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-6ZCLKRBG.js"));
 function describeUnknownError(error) {
   if (error instanceof PmCliError) {
     return error.message;
@@ -4561,10 +4626,18 @@ function inferMissingFieldsFromErrorMessage(message) {
   return normalized.length > 0 ? normalized : void 0;
 }
 function buildPmCliRecoveryContext(context, invocationArgv, rawMessage) {
+  const explainRequested = invocationArgv.includes("--explain");
+  const existingRecovery = context?.recovery;
+  if (existingRecovery?.recovery_mode === "compact" && !explainRequested) {
+    return {
+      /* c8 ignore next */
+      ...context ?? {},
+      recovery: existingRecovery
+    };
+  }
   const attemptedCommand = renderAttemptedCommand3(invocationArgv);
   const providedFields = extractProvidedOptionFlags(invocationArgv);
   const providedSet = new Set(providedFields.map((flag) => normalizeLongOptionFlag(flag) ?? flag));
-  const existingRecovery = context?.recovery;
   const rawInferred = existingRecovery?.suggested_retry ? void 0 : inferMissingFieldsFromErrorMessage(rawMessage);
   const trulyMissing = rawInferred?.filter((flag) => !providedSet.has(normalizeLongOptionFlag(flag) ?? flag));
   const inferredMissing = trulyMissing && trulyMissing.length > 0 ? trulyMissing : void 0;
@@ -4585,8 +4658,12 @@ 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 } : {},
+    ...existingRecovery?.missing_required_fields ? { missing_required_fields: existingRecovery.missing_required_fields } : {},
+    ...existingRecovery?.suggested_flags ? { suggested_flags: existingRecovery.suggested_flags } : {},
     ...suggestedRetry ? { suggested_retry: suggestedRetry } : {},
     ...existingRecovery?.fallback_candidates ? { fallback_candidates: existingRecovery.fallback_candidates } : {},
     ...existingRecovery?.next_best_command ? { next_best_command: existingRecovery.next_best_command } : {}
@@ -4805,6 +4882,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 };
@@ -5996,11 +6134,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,
@@ -6012,13 +6150,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) {
@@ -6040,11 +6178,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
@@ -6053,38 +6193,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);
       }
@@ -6102,7 +6237,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,
@@ -6111,10 +6246,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,
@@ -6124,29 +6259,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) {
@@ -6191,7 +6326,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,
@@ -6200,10 +6335,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,
@@ -6213,29 +6348,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) {
@@ -6250,51 +6385,81 @@ 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,
+  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 {