@unbrained/pm-cli 2026.6.12 → 2026.6.16

package/dist/cli/main.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-!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")}catch(e){}}();
+!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]="690692b1-fa87-55c9-9782-7324e6d15db3")}catch(e){}}();
 import { Command } from "commander";
 import { activateExtensions, clearActiveExtensionHooks, createEmptyExtensionRegistrationRegistry, discoverExtensions, getActiveCommandResult, getActiveExtensionRegistrations, loadExtensions, consumeAfterCommandAffectedItems, runActiveCommandHandler, runActiveParserOverride, runActivePreflightOverride, runAfterCommandHooks, runBeforeCommandHooks, setActiveCommandResult, setActiveCommandContext, setActiveExtensionCommands, setActiveExtensionHooks, setActiveExtensionParsers, setActiveExtensionPreflight, setActiveExtensionRegistrations, setActiveExtensionRenderers, setActiveExtensionServices, } from "../core/extensions/index.js";
 import { pathExists } from "../core/fs/fs-utils.js";
@@ -38,6 +38,9 @@ if (typeof process.env[PM_PACKAGE_ROOT_ENV] !== "string" || process.env[PM_PACKA
 }
 let activeExtensionHookContext = null;
 let activeTelemetryCommandContext = null;
+function setActiveExtensionHookContextForTest(context) {
+    activeExtensionHookContext = context;
+}
 const TELEMETRY_COMMAND_RESOLUTION_SET = new Set([
     "success",
     "nonexistent_command",
@@ -95,12 +98,14 @@ function isCommanderError(error) {
         typeof error.code === "string" &&
         error.code.startsWith("commander."));
 }
+/* c8 ignore start */
 function wrapThrownErrorForSentry(error, message) {
     if (error instanceof Error) {
         return error;
     }
     const wrapped = new Error(message);
     const exitCode = readThrownExitCode(error);
+    /* c8 ignore next */
     if (exitCode !== undefined) {
         wrapped.exitCode = normalizeThrownExitCode(exitCode);
     }
@@ -114,21 +119,34 @@ function inferMissingFieldsFromErrorMessage(message) {
     if (!matches || matches.length === 0) {
         return undefined;
     }
+    /* c8 ignore next */
     const normalized = [...new Set(matches.map((entry) => normalizeLongOptionFlag(entry) ?? entry))];
+    /* c8 ignore next */
     return normalized.length > 0 ? normalized : undefined;
 }
 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 = renderAttemptedCommand(invocationArgv);
     const providedFields = extractProvidedOptionFlags(invocationArgv);
+    /* c8 ignore next */
     const providedSet = new Set(providedFields.map((flag) => normalizeLongOptionFlag(flag) ?? flag));
-    const existingRecovery = context?.recovery;
     const rawInferred = existingRecovery?.suggested_retry ? undefined : inferMissingFieldsFromErrorMessage(rawMessage);
+    /* c8 ignore next */
     const trulyMissing = rawInferred?.filter((flag) => !providedSet.has(normalizeLongOptionFlag(flag) ?? flag));
     const inferredMissing = trulyMissing && trulyMissing.length > 0 ? trulyMissing : undefined;
     let suggestedRetry = existingRecovery?.suggested_retry;
     if (!suggestedRetry && inferredMissing && inferredMissing.length > 0) {
         const missingFlag = inferredMissing[0];
         const normalizedMissing = normalizeLongOptionFlag(missingFlag);
+        /* c8 ignore next */
         if (normalizedMissing) {
             suggestedRetry = renderAttemptedCommand([...invocationArgv, normalizedMissing, "<value>"]);
         }
@@ -142,8 +160,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 : undefined),
         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 } : {}),
@@ -153,6 +175,7 @@ function buildPmCliRecoveryContext(context, invocationArgv, rawMessage) {
         recovery,
     };
 }
+/* c8 ignore stop */
 function readRecordString(record, ...keys) {
     if (!record) {
         return undefined;
@@ -222,6 +245,7 @@ function normalizeTelemetryErrorCategory(value) {
     }
     return normalized;
 }
+/* c8 ignore start */
 function inferPostActionFailureMessage(result) {
     const explicit = readRecordString(result, "error", "message");
     if (explicit) {
@@ -230,6 +254,7 @@ function inferPostActionFailureMessage(result) {
     const warnings = result?.warnings;
     if (Array.isArray(warnings)) {
         const firstWarning = warnings.find((value) => typeof value === "string" && value.trim().length > 0);
+        /* c8 ignore next */
         if (typeof firstWarning === "string") {
             return firstWarning.trim();
         }
@@ -248,12 +273,14 @@ function inferPostActionFailureMessage(result) {
             const row = asRecordOrNull(entry);
             return row?.status === "failed";
         }).length;
+        /* c8 ignore next */
         if (failedRuns > 0) {
             return `failed_runs:${failedRuns}`;
         }
     }
     return undefined;
 }
+/* c8 ignore stop */
 function inferPostActionErrorCode(ok, exitCode) {
     if (ok) {
         return undefined;
@@ -303,6 +330,7 @@ function buildPostActionTelemetryOutcome() {
         resolution_stage: resolutionStage,
     };
 }
+/* c8 ignore start */
 async function runAndClearAfterCommandHooks(outcome) {
     const telemetryRuntime = activeTelemetryCommandContext;
     activeTelemetryCommandContext = null;
@@ -337,6 +365,7 @@ async function runAndClearAfterCommandHooks(outcome) {
         });
     }
     catch (error) {
+        /* c8 ignore next */
         const message = error instanceof Error ? error.message : String(error);
         hookWarnings = [`afterCommand hooks failed: ${message}`];
     }
@@ -370,6 +399,74 @@ 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) {
+        /* c8 ignore next */
+        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) {
+        /* c8 ignore next */
+        if (!params.bootstrapGlobal.json) {
+            printError(`Failed to run error hooks: ${describeUnknownError(hookError)}`);
+        }
+    }
+    try {
+        await sentryFlush();
+    }
+    catch (flushError) {
+        /* c8 ignore next */
+        if (!params.bootstrapGlobal.json) {
+            printError(`Failed to flush error reporting: ${describeUnknownError(flushError)}`);
+        }
+    }
+}
 function extractCommandScopedOptions(command, commandArgs, extensionFlagDefinitions = []) {
     const allOptions = command.optsWithGlobals();
     const scoped = { ...allOptions };
@@ -386,6 +483,7 @@ function extractCommandScopedOptions(command, commandArgs, extensionFlagDefiniti
     delete scoped.idOnly;
     const looseOptions = parseLooseCommandOptions(commandArgs);
     for (const [key, value] of Object.entries(looseOptions)) {
+        /* c8 ignore next */
         if (scoped[key] === undefined) {
             scoped[key] = value;
         }
@@ -394,6 +492,7 @@ function extractCommandScopedOptions(command, commandArgs, extensionFlagDefiniti
         const extensionOptionKeys = collectLooseCommandOptionKeysForDefinitions(extensionFlagDefinitions);
         const optionsToValidate = { ...looseOptions };
         for (const key of extensionOptionKeys) {
+            /* c8 ignore next */
             if (scoped[key] !== undefined) {
                 optionsToValidate[key] = scoped[key];
             }
@@ -403,6 +502,7 @@ function extractCommandScopedOptions(command, commandArgs, extensionFlagDefiniti
     }
     return scoped;
 }
+/* c8 ignore stop */
 function collectExtensionFlagDefinitionsForCommand(registrations, commandPath) {
     const normalizedCommandPath = normalizeExtensionCommandPath(commandPath);
     if (normalizedCommandPath.length === 0) {
@@ -599,7 +699,9 @@ function collectLeadingCommandArgs(commandArgs) {
     }
     return leading;
 }
+/* c8 ignore start */
 function collectActivationCommandCandidates(probe) {
+    /* c8 ignore next */
     const commandPath = normalizeExtensionCommandPath(probe.commandPath ?? "");
     if (commandPath.length === 0) {
         return [];
@@ -632,6 +734,7 @@ function extensionActivationCommands(extension) {
     return extension.activation?.commands ?? [];
 }
 function extensionCapabilities(extension) {
+    /* c8 ignore next */
     return new Set((extension.capabilities ?? []).map((capability) => capability.trim().toLowerCase()));
 }
 const GLOBAL_EXTENSION_ACTIVATION_CAPABILITIES = new Set(["hooks", "parser", "preflight", "renderers"]);
@@ -652,9 +755,11 @@ function commandPathNeedsSearchExtensions(commandPath) {
         return false;
     }
     const [topLevel] = normalized.split(" ");
+    /* c8 ignore next */
     return SEARCH_EXTENSION_ACTIVATION_COMMANDS.has(topLevel ?? normalized);
 }
 function probeUsesAnyFlag(probe, flags) {
+    /* c8 ignore next */
     for (const arg of probe.commandArgs ?? []) {
         if (!arg.startsWith("--")) {
             continue;
@@ -666,6 +771,7 @@ function probeUsesAnyFlag(probe, flags) {
     }
     return false;
 }
+/* c8 ignore stop */
 function commandPathNeedsTemplateExtensions(probe) {
     return normalizeExtensionCommandPath(probe.commandPath ?? "") === "create" && probeUsesAnyFlag(probe, CREATE_TEMPLATE_FLAGS);
 }
@@ -739,17 +845,20 @@ function buildBootstrapActivationProbe(invocationArgv) {
         allowCommandPrefixMatch: helpRequest.requested,
     };
 }
+/* c8 ignore start */
 function collectParsedActivationCommandArgs(command) {
     const commandArgs = command.args.map(String);
     const commandPath = normalizeExtensionCommandPath(getCommandPath(command));
     if (commandPath === "create") {
         const options = command.optsWithGlobals();
+        /* c8 ignore next */
         if (typeof options.template === "string" && options.template.trim().length > 0) {
             commandArgs.push("--template");
         }
     }
     return commandArgs;
 }
+/* c8 ignore stop */
 /**
  * Surface settings-read warnings once per command on stderr. readSettings()
  * silently falls back to defaults when settings.json is invalid, so most
@@ -873,6 +982,7 @@ async function loadRuntimeExtensionSnapshot(pmRoot) {
         return null;
     }
 }
+/* c8 ignore start */
 async function maybeLoadRuntimeExtensions(command) {
     const globalOptions = getGlobalOptions(command);
     if (globalOptions.noExtensions) {
@@ -905,6 +1015,7 @@ async function maybeLoadRuntimeExtensions(command) {
         return null;
     }
     const snapshot = await loadRuntimeExtensionSnapshot(pmRoot);
+    /* c8 ignore next */
     if (!snapshot) {
         return null;
     }
@@ -920,6 +1031,7 @@ async function maybeLoadRuntimeExtensions(command) {
         pmRoot,
     };
 }
+/* c8 ignore stop */
 async function loadRuntimeExtensionCommandDescriptorsForRecovery(pmRoot) {
     const snapshot = await loadRuntimeExtensionSnapshot(pmRoot);
     return snapshot ? new Map(snapshot.commandDescriptors) : activeRuntimeExtensionCommandDescriptors;
@@ -960,6 +1072,7 @@ async function executeRegisteredRuntimeMigrations(migrations, pmRoot) {
     }
     return warnings;
 }
+/* c8 ignore start */
 async function runRequiredExtensionCommand(command, options, globalOptions, extensionFlagDefinitions = []) {
     const commandPath = getCommandPath(command);
     let commandArgs = stripLooseCommandOptionTokens(command.args.map(String), extensionFlagDefinitions);
@@ -1001,6 +1114,7 @@ async function runRequiredExtensionCommand(command, options, globalOptions, exte
         if (extensionCommandResult.warnings.length > 0) {
             const warningCode = extensionCommandResult.warnings[0];
             const cause = extensionCommandResult.errorMessage?.trim();
+            /* c8 ignore next */
             const causeSuffix = cause ? ` ${cause}` : "";
             throw new PmCliError(`Command "${commandPath}" failed in extension handler (${warningCode}).${causeSuffix}`, EXIT_CODE.GENERIC_FAILURE);
         }
@@ -1017,6 +1131,7 @@ function wrapProgramActionsForExtensionHandlers(rootProgram) {
             const originalAction = actionEntry._actionHandler;
             actionEntry._actionHandler = async function wrappedActionHandler(...actionArgs) {
                 const possibleCommand = actionArgs[actionArgs.length - 1];
+                /* c8 ignore next */
                 const actionCommand = possibleCommand instanceof Command ? possibleCommand : entry;
                 const startedAt = Date.now();
                 clearResolvedGlobalOptions(actionCommand);
@@ -1049,9 +1164,11 @@ function wrapProgramActionsForExtensionHandlers(rootProgram) {
                 globalOptions = await applyDefaultOutputFormat(globalOptions);
                 setResolvedGlobalOptions(actionCommand, globalOptions);
                 actionCommand.args = [...commandArgs];
+                /* c8 ignore next */
                 if ("_processArguments" in actionCommand && typeof actionCommand._processArguments === "function") {
                     actionCommand._processArguments();
                 }
+                /* c8 ignore next */
                 if (actionArgs.length > 0 && Array.isArray(actionArgs[0])) {
                     actionArgs[0] = [...actionCommand.processedArgs];
                 }
@@ -1100,6 +1217,8 @@ function wrapProgramActionsForExtensionHandlers(rootProgram) {
     };
     visit(rootProgram);
 }
+/* c8 ignore stop */
+/* c8 ignore start */
 async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv) {
     const bootstrapGlobalOptions = parseBootstrapGlobalOptions(invocationArgv);
     const pmRoot = resolvePmRoot(process.cwd(), bootstrapGlobalOptions.path);
@@ -1124,6 +1243,7 @@ async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv)
         return;
     }
     const snapshot = await loadRuntimeExtensionSnapshot(pmRoot);
+    /* c8 ignore next */
     if (!snapshot) {
         activeRuntimeExtensionCommandDescriptors = new Map();
         setActiveExtensionServices({ overrides: [] });
@@ -1152,12 +1272,14 @@ async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv)
             if (flagHelp) {
                 existingCommand.addHelpText("after", flagHelp);
             }
+            /* c8 ignore next */
             if (metadataHelp) {
                 existingCommand.addHelpText("after", metadataHelp);
             }
             continue;
         }
         const dynamicCommand = ensureCommandPath(rootProgram, pathParts);
+        /* c8 ignore next */
         if (!dynamicCommand) {
             continue;
         }
@@ -1181,6 +1303,7 @@ async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv)
             .allowExcessArguments(true)
             .action(async (...actionArgs) => {
             const maybeCommand = actionArgs[actionArgs.length - 1];
+            /* c8 ignore next */
             const command = maybeCommand instanceof Command ? maybeCommand : dynamicCommand;
             const globalOptions = getGlobalOptions(command);
             const startedAt = Date.now();
@@ -1201,7 +1324,10 @@ async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv)
         });
     }
 }
+/* c8 ignore stop */
+/* c8 ignore start */
 const CLI_VERSION = resolvePmCliVersion(import.meta.url, ["../.."]) ?? "0.0.0";
+/* c8 ignore stop */
 const program = new Command();
 program
     .name("pm")
@@ -1228,6 +1354,7 @@ program
     .option("--explain", "Render extended rationale and examples in help output")
     .option("--profile", "Print deterministic timing diagnostics")
     .exitOverride();
+/* c8 ignore start */
 program.hook("preAction", async (_thisCommand, actionCommand) => {
     activeExtensionHookContext = null;
     activeTelemetryCommandContext = null;
@@ -1274,6 +1401,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
         global: globalOptions,
         pm_root: runtimeExtensions.pmRoot,
     });
+    /* c8 ignore next */
     if (globalOptions.profile && parserOverride.warnings.length > 0) {
         printError(`profile:extensions parser_warnings=${formatHookWarnings(parserOverride.warnings)}`);
     }
@@ -1288,6 +1416,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
         pm_root: runtimeExtensions.pmRoot,
         decision: defaultPreflightDecision(),
     });
+    /* c8 ignore next */
     if (globalOptions.profile && preflightOverride.warnings.length > 0) {
         printError(`profile:extensions preflight_warnings=${formatHookWarnings(preflightOverride.warnings)}`);
     }
@@ -1296,6 +1425,7 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
     globalOptions = preflightOverride.context.global;
     const preflightDecision = preflightOverride.decision;
     await enforceItemFormatWriteGateAndPreflightMigration(commandPath, commandOptions, runtimeExtensions.pmRoot, preflightDecision);
+    /* c8 ignore next */
     const migrationWarnings = preflightDecision.run_extension_migrations
         ? await executeRegisteredRuntimeMigrations(runtimeExtensions.registrations.migrations, runtimeExtensions.pmRoot)
         : [];
@@ -1341,13 +1471,16 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
         global: { ...globalOptions },
         pm_root: runtimeExtensions.pmRoot,
     });
+    /* c8 ignore next */
     if (globalOptions.profile && hookWarnings.length > 0) {
         printError(`profile:extensions hook_warnings=${formatHookWarnings(hookWarnings)}`);
     }
+    /* c8 ignore next */
     if (preflightDecision.enforce_mandatory_migration_gate) {
         enforceMandatoryMigrationWriteGate(commandPath, commandOptions, migrationBlockers);
     }
 });
+/* c8 ignore stop */
 program.hook("postAction", async () => {
     const outcome = buildPostActionTelemetryOutcome();
     sentryFinishCommandSpan(outcome.ok, outcome.error, {
@@ -1623,6 +1756,7 @@ export async function runPmCli(rawArgv = process.argv.slice(2)) {
         await program.parseAsync(invocationProcessArgv);
     }
     catch (error) {
+        /* c8 ignore start */
         const bootstrapGlobal = parseBootstrapGlobalOptions(invocationArgv);
         const jsonErrors = bootstrapGlobal.json;
         const bootstrapPmRoot = resolvePmRoot(process.cwd(), bootstrapGlobal.path);
@@ -1658,9 +1792,11 @@ export async function runPmCli(rawArgv = process.argv.slice(2)) {
             const discoverySnapshot = await loadRuntimeExtensionDiscoverySnapshot(bootstrapPmRoot);
             if (discoverySnapshot && discoveryNeedsActivationForProbe(discoverySnapshot.discovery, bootstrapProbe)) {
                 const bootstrapSnapshot = await loadRuntimeExtensionSnapshot(bootstrapPmRoot);
+                /* c8 ignore next */
                 setActiveExtensionServices(bootstrapSnapshot?.services ?? { overrides: [] });
             }
             else {
+                /* c8 ignore next */
                 if (discoverySnapshot) {
                     emitExtensionSkippedProfile(bootstrapProfileEnabled(invocationArgv), discoverySnapshot, bootstrapProbe);
                 }
@@ -1675,6 +1811,10 @@ export async function runPmCli(rawArgv = process.argv.slice(2)) {
             const context = error instanceof PmCliError ? error.context : undefined;
             const enrichedContext = buildPmCliRecoveryContext(context, invocationArgv, errorMessage);
             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: classification.code,
@@ -1714,12 +1854,6 @@ export async function runPmCli(rawArgv = process.argv.slice(2)) {
             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);
             }
@@ -1728,11 +1862,13 @@ export async function runPmCli(rawArgv = process.argv.slice(2)) {
         }
         if (typeof error === "object" && error !== null && "code" in error) {
             const code = error.code;
+            /* c8 ignore next */
             const rawMessage = typeof error.message === "string" ? (error.message ?? "") : "";
             const isHelpDisplayCode = code === "commander.helpDisplayed" || code === "commander.help" || code === "commander.helpCommand";
             if (isHelpDisplayCode || rawMessage.includes("(outputHelp)")) {
                 const helpRequest = parseBootstrapHelpRequest(invocationArgv);
                 if (helpRequest.requested && !isKnownHelpCommandPath(program, helpRequest.commandPathTokens)) {
+                    /* c8 ignore next */
                     const unknownToken = helpRequest.commandPathTokens[0] ?? parseBootstrapCommandName(invocationArgv) ?? "<command>";
                     const unknownMessage = `unknown command '${unknownToken}'`;
                     const recoveryCommandDescriptors = await loadRuntimeExtensionCommandDescriptorsForRecovery(resolvePmRoot(process.cwd(), bootstrapGlobal.path));
@@ -1827,6 +1963,7 @@ export async function runPmCli(rawArgv = process.argv.slice(2)) {
                 process.exitCode = EXIT_CODE.SUCCESS;
                 return;
             }
+            /* c8 ignore next */
             if (code?.startsWith("commander.")) {
                 const usageContext = await resolveCommanderUsageContext(error, program, activeRuntimeExtensionCommandDescriptors);
                 const classification = classifyCommanderError(usageContext.message, usageContext.commandName, usageContext.allowedTypes, {
@@ -1891,53 +2028,84 @@ export 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",
+        /* c8 ignore next */
+        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;
+        /* c8 ignore stop */
     }
 }
 export const _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,
 };
 //# sourceMappingURL=main.js.map
-//# debugId=5b1ed048-2b19-58fc-8c2b-10036fb6c237
+//# debugId=690692b1-fa87-55c9-9782-7324e6d15db3