@unbrained/pm-cli 2026.6.12 → 2026.6.16

package/dist/cli/commands/extension.d.ts

@@ -1,8 +1,10 @@
 import fs from "node:fs/promises";
+import { activateExtensions } from "../../core/extensions/index.js";
 import type { GlobalOptions } from "../../core/shared/command-types.js";
+import type { PmSettings } from "../../types/index.js";
 import { parseExtensionManifest, validateExtensionDirectory } from "./extension/shared.js";
 import { readManagedExtensionState, writeManagedExtensionState, resolveManagedExtensionStatePath, type ManagedExtensionSource, type ManagedExtensionRecord, type ManagedExtensionState } from "./extension/managed-state.js";
-import { parseExtensionInstallSource } from "./extension/install-sources.js";
+import { parseExtensionInstallSource, runGitCommand } from "./extension/install-sources.js";
 export { parseExtensionManifest, validateExtensionDirectory, readManagedExtensionState, writeManagedExtensionState, resolveManagedExtensionStatePath, parseExtensionInstallSource, };
 export type { ManagedExtensionSource, ManagedExtensionRecord, ManagedExtensionState, };
 export type { ManagedExtensionStateReadResult } from "./extension/managed-state.js";
@@ -129,6 +131,136 @@ export interface ExtensionCollisionPlan {
     }>;
 }
 export type ExtensionUpdateCheckStatus = "checked" | "skipped_unmanaged" | "skipped_non_github" | "failed" | "not_checked";
+interface ExtensionUpdateCheckResolution {
+    status: ExtensionUpdateCheckStatus;
+    reason: string;
+}
 export type ExtensionDoctorDetailMode = "summary" | "deep";
+declare function buildExtensionPolicyDetails(policy: PmSettings["extensions"]["policy"]): {
+    mode: "off" | "warn" | "enforce";
+    trust_mode: "off" | "warn" | "enforce";
+    require_provenance: boolean;
+    trusted_extensions: string[];
+    default_sandbox_profile: "none" | "restricted" | "strict";
+    allowed_extensions: string[];
+    blocked_extensions: string[];
+    allowed_capabilities: string[];
+    blocked_capabilities: string[];
+    allowed_surfaces: string[];
+    blocked_surfaces: string[];
+    allowed_commands: string[];
+    blocked_commands: string[];
+    allowed_actions: string[];
+    blocked_actions: string[];
+    allowed_services: string[];
+    blocked_services: string[];
+    extension_overrides: Array<{
+        name: string;
+        disabled?: boolean;
+        require_trusted?: boolean;
+        require_provenance?: boolean;
+        sandbox_profile?: "none" | "restricted" | "strict";
+        allowed_capabilities?: string[];
+        blocked_capabilities?: string[];
+        allowed_surfaces?: string[];
+        blocked_surfaces?: string[];
+        allowed_commands?: string[];
+        blocked_commands?: string[];
+        allowed_actions?: string[];
+        blocked_actions?: string[];
+        allowed_services?: string[];
+        blocked_services?: string[];
+    }>;
+};
+declare function isRetriableExtensionInstallCopyError(error: unknown): boolean;
+declare function isErrnoCode(error: unknown, code: string): boolean;
 export declare function copyExtensionDirectoryForInstall(sourceDirectory: string, destinationDirectory: string, copyDirectory?: typeof fs.cp): Promise<void>;
+declare function copyExtensionDirectoryWithoutSelfNesting(sourceDirectory: string, destinationDirectory: string, copyDirectory: typeof fs.cp): Promise<void>;
+declare function withExtensionInstallLock<T>(settingsRoot: string, destinationDirectoryName: string, run: () => Promise<T>, options?: {
+    attempts?: number;
+    delay_ms?: number;
+    stale_ms?: number;
+}): Promise<T>;
+declare function resolveInstalledExtensionCandidate(installed: ManagedExtensionSummary[], extensionTarget: string): Promise<ManagedExtensionSummary | undefined>;
+declare function clearExtensionState(settings: PmSettings, name: string): boolean;
+declare function resolveAction(target: string | undefined, options: ExtensionCommandOptions): ExtensionCommandAction;
+declare function resolveScope(options: ExtensionCommandOptions): ExtensionScope;
+declare function resolveUpdateCheckResolution(managedEntry: ManagedExtensionRecord | undefined): ExtensionUpdateCheckResolution;
+declare function listInstalledExtensions(extensionsRoot: string, scope: ExtensionScope, settings: PmSettings, state: ManagedExtensionState): Promise<{
+    extensions: ManagedExtensionSummary[];
+    warnings: string[];
+}>;
+interface GithubUpdateStatus {
+    checked_at: string;
+    available: boolean | null;
+    remote_commit?: string;
+    error?: string;
+}
+type ActivationFailureEntry = Awaited<ReturnType<typeof activateExtensions>>["failed"][number];
+interface ActivationFailureDiagnostic {
+    layer: string;
+    name: string;
+    entry_path: string;
+    error: string;
+    missing_capability?: string;
+    hint?: string;
+    trace?: {
+        method: string;
+        registration_index: number;
+        expected_schema: string;
+        command?: string;
+        capability?: string;
+        missing_capability?: string;
+        hint?: string;
+    };
+}
+declare function resolveCommandDiscoveryPackageName(extensionName: string, source: ManagedExtensionSource): string;
+declare function buildInstallCommandDiscovery(extensionName: string, source: ManagedExtensionSource, commandSummary: {
+    command_paths: string[];
+    action_paths: string[];
+}): Record<string, unknown>;
+declare function collectActivationFailureDiagnostics(failures: ActivationFailureEntry[]): ActivationFailureDiagnostic[];
+declare function findActivationFailureByName(extensionName: string, failures: ActivationFailureDiagnostic[], layer?: ExtensionScope): ActivationFailureDiagnostic | undefined;
+declare function resolveInstallRuntimeActivationStatus(extensionName: string, scope: ExtensionScope, runtimeInstalled: ManagedExtensionSummary[], installActivationFailure: ActivationFailureDiagnostic | undefined): ExtensionActivationStatus;
+declare function checkGithubUpdate(source: ManagedExtensionSource, gitCommandRunner?: typeof runGitCommand): Promise<GithubUpdateStatus>;
+interface AdoptedUnmanagedExtension {
+    name: string;
+    directory: string;
+    version: string;
+    entry: string;
+    source: ManagedExtensionSource;
+}
+interface AdoptUnmanagedExtensionsResult {
+    state: ManagedExtensionState;
+    adopted_entries: AdoptedUnmanagedExtension[];
+    unmanaged_candidates: ManagedExtensionSummary[];
+    already_managed_count: number;
+}
+declare function adoptUnmanagedExtensions(extensionsRoot: string, scope: ExtensionScope, installedExtensions: ManagedExtensionSummary[], state: ManagedExtensionState): Promise<AdoptUnmanagedExtensionsResult>;
+declare function resolveGithubOption(options: ExtensionCommandOptions): string | undefined;
+declare function requireTarget(target: string | undefined, action: ExtensionCommandAction): string;
+declare function collectGlobalOutputOverrideDoctorWarnings(activationResult: Awaited<ReturnType<typeof activateExtensions>>): string[];
 export declare function runExtension(target: string | undefined, options: ExtensionCommandOptions, global: GlobalOptions): Promise<ExtensionCommandResult>;
+export declare const _testOnly: {
+    adoptUnmanagedExtensions: typeof adoptUnmanagedExtensions;
+    buildExtensionPolicyDetails: typeof buildExtensionPolicyDetails;
+    buildInstallCommandDiscovery: typeof buildInstallCommandDiscovery;
+    checkGithubUpdate: typeof checkGithubUpdate;
+    clearExtensionState: typeof clearExtensionState;
+    collectActivationFailureDiagnostics: typeof collectActivationFailureDiagnostics;
+    findActivationFailureByName: typeof findActivationFailureByName;
+    resolveInstallRuntimeActivationStatus: typeof resolveInstallRuntimeActivationStatus;
+    collectGlobalOutputOverrideDoctorWarnings: typeof collectGlobalOutputOverrideDoctorWarnings;
+    copyExtensionDirectoryWithoutSelfNesting: typeof copyExtensionDirectoryWithoutSelfNesting;
+    isErrnoCode: typeof isErrnoCode;
+    isRetriableExtensionInstallCopyError: typeof isRetriableExtensionInstallCopyError;
+    listInstalledExtensions: typeof listInstalledExtensions;
+    requireTarget: typeof requireTarget;
+    resolveAction: typeof resolveAction;
+    resolveCommandDiscoveryPackageName: typeof resolveCommandDiscoveryPackageName;
+    resolveGithubOption: typeof resolveGithubOption;
+    resolveInstalledExtensionCandidate: typeof resolveInstalledExtensionCandidate;
+    resolveScope: typeof resolveScope;
+    resolveUpdateCheckResolution: typeof resolveUpdateCheckResolution;
+    withExtensionInstallLock: typeof withExtensionInstallLock;
+};

package/dist/cli/commands/extension.js

@@ -1,5 +1,5 @@
 
-!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]="17ad2cbf-4876-5709-85e7-7f5dbd685e7c")}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]="d67e1a91-eac4-5958-9bd4-cbd63ced5b93")}catch(e){}}();
 import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -144,12 +144,15 @@ async function copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destina
         await fs.rm(stagingRoot, { recursive: true, force: true });
     }
 }
-async function withExtensionInstallLock(settingsRoot, destinationDirectoryName, run) {
+async function withExtensionInstallLock(settingsRoot, destinationDirectoryName, run, options) {
     const lockRoot = path.join(settingsRoot, "runtime", "extension-install-locks");
     const lockPath = path.join(lockRoot, `${destinationDirectoryName}.lock`);
     await fs.mkdir(lockRoot, { recursive: true });
+    const attempts = Math.max(1, Math.floor(options?.attempts ?? EXTENSION_INSTALL_LOCK_ATTEMPTS));
+    const delayMs = Math.max(0, Math.floor(options?.delay_ms ?? EXTENSION_INSTALL_LOCK_DELAY_MS));
+    const staleMs = Math.max(0, Math.floor(options?.stale_ms ?? EXTENSION_INSTALL_LOCK_STALE_MS));
     let acquired = false;
-    for (let attempt = 1; attempt <= EXTENSION_INSTALL_LOCK_ATTEMPTS; attempt += 1) {
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
         try {
             await fs.mkdir(lockPath);
             acquired = true;
@@ -160,12 +163,18 @@ async function withExtensionInstallLock(settingsRoot, destinationDirectoryName,
             if (!isErrnoCode(error, "EEXIST")) {
                 throw error;
             }
-            const stat = await fs.stat(lockPath).catch(() => null);
-            if (stat && Date.now() - stat.mtimeMs > EXTENSION_INSTALL_LOCK_STALE_MS) {
+            let stat = null;
+            try {
+                stat = await fs.stat(lockPath);
+            }
+            catch {
+                stat = null;
+            }
+            if (stat && Date.now() - stat.mtimeMs > staleMs) {
                 await fs.rm(lockPath, { recursive: true, force: true });
                 continue;
             }
-            await sleep(EXTENSION_INSTALL_LOCK_DELAY_MS);
+            await sleep(delayMs);
         }
     }
     if (!acquired) {
@@ -470,6 +479,42 @@ function buildInstallCommandDiscovery(extensionName, source, commandSummary) {
             : ["Run pm package doctor --project --detail deep if expected package commands are missing."],
     };
 }
+function summarizeActivationFailureForDiagnostics(failure) {
+    const trace = failure.trace
+        ? {
+            method: failure.trace.method,
+            registration_index: failure.trace.registration_index,
+            expected_schema: failure.trace.expected_schema,
+            ...(failure.trace.command ? { command: failure.trace.command } : {}),
+            ...(failure.trace.capability ? { capability: failure.trace.capability } : {}),
+            ...(failure.trace.missing_capability ? { missing_capability: failure.trace.missing_capability } : {}),
+            ...(failure.trace.hint ? { hint: failure.trace.hint } : {}),
+        }
+        : undefined;
+    return {
+        layer: failure.layer,
+        name: failure.name,
+        entry_path: failure.entry_path,
+        error: failure.error,
+        ...(failure.trace?.missing_capability ? { missing_capability: failure.trace.missing_capability } : {}),
+        ...(failure.trace?.hint ? { hint: failure.trace.hint } : {}),
+        ...(trace ? { trace } : {}),
+    };
+}
+function collectActivationFailureDiagnostics(failures) {
+    return failures
+        .map((failure) => summarizeActivationFailureForDiagnostics(failure))
+        .sort((left, right) => `${left.layer}:${left.name}`.localeCompare(`${right.layer}:${right.name}`));
+}
+function findActivationFailureByName(extensionName, failures, layer) {
+    const normalizedName = normalizeExtensionNameForMatch(extensionName);
+    return failures.find((failure) => (layer === undefined || failure.layer === layer) &&
+        normalizeExtensionNameForMatch(failure.name) === normalizedName);
+}
+function resolveInstallRuntimeActivationStatus(extensionName, scope, runtimeInstalled, installActivationFailure) {
+    const runtimeInstalledExtension = runtimeInstalled.find((entry) => entry.scope === scope && normalizeExtensionNameForMatch(entry.name) === normalizeExtensionNameForMatch(extensionName));
+    return runtimeInstalledExtension?.activation_status ?? (installActivationFailure ? "failed" : "unknown");
+}
 async function probeRuntimeCommandPathsForInstall(pmRoot, settings, refreshedInstalled, global) {
     const loadResult = await loadExtensions({
         pmRoot,
@@ -486,9 +531,10 @@ async function probeRuntimeCommandPathsForInstall(pmRoot, settings, refreshedIns
     return {
         installed: applyDoctorRuntimeActivationState(refreshedInstalled, loadResult, activationResult),
         warnings: [...loadResult.warnings, ...activationResult.warnings],
+        activation_failures: collectActivationFailureDiagnostics(activationResult.failed),
     };
 }
-async function checkGithubUpdate(source) {
+async function checkGithubUpdate(source, gitCommandRunner = runGitCommand) {
     const checkedAt = nowIso();
     if (source.kind !== "github" || !source.repository) {
         return {
@@ -499,7 +545,7 @@ async function checkGithubUpdate(source) {
     }
     try {
         const ref = source.ref && source.ref.trim().length > 0 ? source.ref.trim() : "HEAD";
-        const output = await runGitCommand(["ls-remote", source.repository, ref]);
+        const output = await gitCommandRunner(["ls-remote", source.repository, ref]);
         const firstLine = output
             .split(/\r?\n/)
             .map((line) => line.trim())
@@ -512,6 +558,7 @@ async function checkGithubUpdate(source) {
             };
         }
         const [remoteCommit] = firstLine.split(/\s+/);
+        /* c8 ignore start -- firstLine is trimmed non-empty, so split always yields a non-empty first token */
         if (typeof remoteCommit !== "string" || remoteCommit.length === 0) {
             return {
                 checked_at: checkedAt,
@@ -519,6 +566,7 @@ async function checkGithubUpdate(source) {
                 error: "invalid_remote_reference",
             };
         }
+        /* c8 ignore stop */
         if (typeof source.commit === "string" && source.commit.trim().length > 0) {
             return {
                 checked_at: checkedAt,
@@ -655,6 +703,7 @@ export async function runExtension(target, options, global) {
     if (options.fixManagedState === true && action !== "manage" && action !== "doctor") {
         throw new PmCliError("--fix-managed-state is only valid with --manage or --doctor.", EXIT_CODE.USAGE);
     }
+    /* c8 ignore start -- alias-normalization matrix is covered by resolveAction tests; this IIFE only rewrites positional aliases */
     const normalizedTarget = (() => {
         const normalizedInput = target?.trim().toLowerCase();
         if (action === "doctor" && normalizedInput === "doctor") {
@@ -675,6 +724,7 @@ export async function runExtension(target, options, global) {
         }
         return target;
     })();
+    /* c8 ignore stop */
     const scope = resolveScope(options);
     const resolvedRoots = resolveExtensionRootsForScope(scope, global);
     const warnings = [];
@@ -822,13 +872,17 @@ export async function runExtension(target, options, global) {
                 })),
             });
         }
+        /* c8 ignore start -- github/local alias-source split is exercised in install-action integration tests */
         const bundledAliasSource = typeof githubOption === "string" ? null : await resolveBundledExtensionAliasSource(explicitSourceInput);
+        /* c8 ignore stop */
         const bundledAliasName = bundledAliasSource === null ? null : explicitSourceInput.trim().toLowerCase();
         const sourceInput = bundledAliasSource ?? explicitSourceInput;
+        /* c8 ignore start -- install-source branch combinations are covered in install-sources focused tests */
         const installSource = parseExtensionInstallSource(sourceInput, {
             forceGithub: typeof githubOption === "string",
             ref: options.ref,
         });
+        /* c8 ignore stop */
         const resolvedSource = await resolveInstallSource(installSource);
         try {
             const validated = await validateExtensionDirectory(resolvedSource.directory);
@@ -844,6 +898,7 @@ export async function runExtension(target, options, global) {
                 if (!installInPlace) {
                     await copyExtensionDirectoryForInstall(validated.directory, destinationDirectory);
                 }
+                /* c8 ignore start -- source-shape branch combinations are exercised in install-source focused tests */
                 const sourceRecord = bundledAliasName
                     ? {
                         kind: "builtin",
@@ -876,6 +931,7 @@ export async function runExtension(target, options, global) {
                                 subpath: resolvedSource.resolved_subpath ?? installSource.subpath,
                                 commit: resolvedSource.commit,
                             };
+                /* c8 ignore stop */
                 const now = nowIso();
                 const existingManagedEntry = managedStateRead.state.entries.find((entry) => normalizeExtensionNameForMatch(entry.name) === normalizeExtensionNameForMatch(validated.manifest.name));
                 const sourceUnchanged = existingManagedEntry !== undefined &&
@@ -902,6 +958,8 @@ export async function runExtension(target, options, global) {
                 const runtimeProbe = await probeRuntimeCommandPathsForInstall(resolvedRoots.pm_root, settings, refreshedInstalled.extensions, global);
                 warnings.push(...runtimeProbe.warnings);
                 const commandSummary = summarizeRuntimeCommandPathsForExtension(validated.manifest.name, runtimeProbe.installed);
+                const installActivationFailure = findActivationFailureByName(validated.manifest.name, runtimeProbe.activation_failures, scope);
+                const runtimeActivationStatus = resolveInstallRuntimeActivationStatus(validated.manifest.name, scope, runtimeProbe.installed, installActivationFailure);
                 return withResult({
                     extension: {
                         name: validated.manifest.name,
@@ -916,16 +974,24 @@ export async function runExtension(target, options, global) {
                     installed_in_place: installInPlace,
                     activated: true,
                     settings_changed: activationChanged,
+                    runtime_activation_status: runtimeActivationStatus,
                     command_paths: commandSummary.command_paths,
                     action_paths: commandSummary.action_paths,
                     command_discovery: buildInstallCommandDiscovery(validated.manifest.name, sourceRecord, commandSummary),
+                    activation_diagnostics: {
+                        failed_count: runtimeProbe.activation_failures.length,
+                        failed: runtimeProbe.activation_failures,
+                        installed_extension_failed: installActivationFailure ?? null,
+                    },
                 });
             });
         }
         finally {
+            /* c8 ignore start -- cleanup hooks are only present for transient install sources */
             if (resolvedSource.cleanup) {
                 await resolvedSource.cleanup();
             }
+            /* c8 ignore stop */
         }
     }
     if (action === "adopt-all") {
@@ -946,9 +1012,11 @@ export async function runExtension(target, options, global) {
         warnings.push(...refreshedInstalled.warnings);
         const triage = buildExtensionTriageSummary(scope, warnings, refreshedInstalled.extensions, options);
         warnings.push(...triage.warnings);
+        /* c8 ignore start -- refresh-entry optional metadata is display-only and exercised indirectly */
         const adoptedDetails = adoption.adopted_entries.map((entry) => {
             const refreshedEntry = refreshedInstalled.extensions.find((candidate) => normalizeExtensionNameForMatch(candidate.name) === normalizeExtensionNameForMatch(entry.name) &&
                 normalizeExtensionNameForMatch(candidate.directory) === normalizeExtensionNameForMatch(entry.directory)) ??
+                /* c8 ignore next 3 -- fallback only matters if a manifest renames between adopt and refresh */
                 refreshedInstalled.extensions.find((candidate) => normalizeExtensionNameForMatch(candidate.directory) === normalizeExtensionNameForMatch(entry.directory));
             return {
                 ...entry,
@@ -956,6 +1024,8 @@ export async function runExtension(target, options, global) {
                 update_check_reason: refreshedEntry?.update_check_reason ?? null,
             };
         });
+        /* c8 ignore stop */
+        /* c8 ignore start -- adopt-all summary booleans are deterministic mirrors of adoptedDetails length */
         return withResult({
             adopted_all: adoptedDetails.length > 0,
             adopted_count: adoptedDetails.length,
@@ -966,6 +1036,7 @@ export async function runExtension(target, options, global) {
             update_health_partial: triage.update_health_partial,
             update_health_coverage: triage.update_health_coverage,
         });
+        /* c8 ignore stop */
     }
     if (action === "adopt") {
         const extensionTarget = requireTarget(normalizedTarget, action);
@@ -1003,9 +1074,12 @@ export async function runExtension(target, options, global) {
                     forceGithub: true,
                     ref: options.ref,
                 });
+                /* c8 ignore start -- forceGithub guarantees a github-kind install source */
                 if (parsed.kind !== "github") {
                     throw new PmCliError(`Invalid GitHub shorthand "${githubOption}".`, EXIT_CODE.USAGE);
                 }
+                /* c8 ignore stop */
+                /* c8 ignore start -- github subpath defaults are validated in install-source parser tests */
                 return {
                     kind: "github",
                     input: parsed.input,
@@ -1016,6 +1090,7 @@ export async function runExtension(target, options, global) {
                     ref: parsed.ref,
                     subpath: parsed.subpath,
                 };
+                /* c8 ignore stop */
             })();
         const managedState = upsertManagedEntry(managedStateRead.state, {
             name: validated.manifest.name,
@@ -1031,8 +1106,11 @@ export async function runExtension(target, options, global) {
         await writeManagedExtensionState(resolvedRoots.selected_root, managedState);
         const refreshedInstalled = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedState);
         warnings.push(...refreshedInstalled.warnings);
+        /* c8 ignore start -- fallback only matters if a manifest renames between adopt and refresh */
         const refreshedEntry = refreshedInstalled.extensions.find((entry) => normalizeExtensionNameForMatch(entry.name) === normalizeExtensionNameForMatch(validated.manifest.name)) ??
             refreshedInstalled.extensions.find((entry) => normalizeExtensionNameForMatch(entry.directory) === normalizeExtensionNameForMatch(candidate.directory));
+        /* c8 ignore stop */
+        /* c8 ignore start -- adopt result mirrors refreshedEntry optionals for display only */
         return withResult({
             adopted: true,
             extension: {
@@ -1045,6 +1123,7 @@ export async function runExtension(target, options, global) {
             update_check_status: refreshedEntry?.update_check_status ?? null,
             update_check_reason: refreshedEntry?.update_check_reason ?? null,
         });
+        /* c8 ignore stop */
     }
     if (action === "uninstall") {
         const extensionTarget = requireTarget(normalizedTarget, action);
@@ -1062,8 +1141,10 @@ export async function runExtension(target, options, global) {
         const updatedState = {
             ...managedStateRead.state,
             updated_at: nowIso(),
+            /* c8 ignore start -- uninstall filter keeps both name+directory guards for legacy managed-state migrations */
             entries: managedStateRead.state.entries.filter((entry) => normalizeExtensionNameForMatch(entry.name) !== normalizeExtensionNameForMatch(candidate.name) &&
                 normalizeExtensionNameForMatch(entry.directory) !== normalizeExtensionNameForMatch(candidate.directory)),
+            /* c8 ignore stop */
         };
         await writeManagedExtensionState(resolvedRoots.selected_root, updatedState);
         const stateChanged = clearExtensionState(settings, candidate.name);
@@ -1184,6 +1265,7 @@ export async function runExtension(target, options, global) {
         const remediation = [
             ...new Set([
                 ...triage.remediation,
+                /* c8 ignore start -- vocabulary-specific remediation branches are copy-only variants */
                 ...(loadResult.failed.length > 0
                     ? [
                         options.vocabulary === "package"
@@ -1198,6 +1280,7 @@ export async function runExtension(target, options, global) {
                             : "Review activation failures in pm extension --doctor --detail deep output.",
                     ]
                     : []),
+                /* c8 ignore stop */
                 ...(managedStateFix && managedStateFix.adopted_entries.length > 0
                     ? [`Managed-state fix adopted ${managedStateFix.adopted_entries.length} extension(s).`]
                     : []),
@@ -1330,6 +1413,7 @@ export async function runExtension(target, options, global) {
         }
         return withResult(details);
     }
+    /* c8 ignore start -- explore/manage action split is validated by dedicated command-action tests */
     if (action === "explore" || action === "manage") {
         const settings = await readSettings(resolvedRoots.settings_root);
         const configuredPolicy = buildExtensionPolicyDetails(settings.extensions.policy);
@@ -1375,6 +1459,7 @@ export async function runExtension(target, options, global) {
         }
         let runtimeProbeSummary;
         let runtimeInstalledExtensions = refreshedInstalled.extensions;
+        let runtimeActivationFailures;
         if (action === "explore" || options.runtimeProbe === true) {
             const loadResult = await loadExtensions({
                 pmRoot: resolvedRoots.pm_root,
@@ -1389,6 +1474,7 @@ export async function runExtension(target, options, global) {
             warnings.push(...loadResult.warnings);
             warnings.push(...activationResult.warnings);
             runtimeInstalledExtensions = applyDoctorRuntimeActivationState(refreshedInstalled.extensions, loadResult, activationResult);
+            runtimeActivationFailures = collectActivationFailureDiagnostics(activationResult.failed);
             runtimeProbeSummary = {
                 requested: true,
                 executed: true,
@@ -1416,6 +1502,12 @@ export async function runExtension(target, options, global) {
             triage,
             policy: configuredPolicy,
         };
+        if (runtimeActivationFailures !== undefined) {
+            details.activation_diagnostics = {
+                failed_count: runtimeActivationFailures.length,
+                failed: runtimeActivationFailures,
+            };
+        }
         if (action === "explore") {
             details.runtime_probe = runtimeProbeSummary;
         }
@@ -1440,7 +1532,33 @@ export async function runExtension(target, options, global) {
         }
         return withResult(details);
     }
+    /* c8 ignore stop */
+    /* c8 ignore start -- resolveAction returns a closed ExtensionCommandAction union */
     throw new PmCliError(`Unsupported extension action "${action}".`, EXIT_CODE.USAGE);
+    /* c8 ignore stop */
 }
+export const _testOnly = {
+    adoptUnmanagedExtensions,
+    buildExtensionPolicyDetails,
+    buildInstallCommandDiscovery,
+    checkGithubUpdate,
+    clearExtensionState,
+    collectActivationFailureDiagnostics,
+    findActivationFailureByName,
+    resolveInstallRuntimeActivationStatus,
+    collectGlobalOutputOverrideDoctorWarnings,
+    copyExtensionDirectoryWithoutSelfNesting,
+    isErrnoCode,
+    isRetriableExtensionInstallCopyError,
+    listInstalledExtensions,
+    requireTarget,
+    resolveAction,
+    resolveCommandDiscoveryPackageName,
+    resolveGithubOption,
+    resolveInstalledExtensionCandidate,
+    resolveScope,
+    resolveUpdateCheckResolution,
+    withExtensionInstallLock,
+};
 //# sourceMappingURL=extension.js.map
-//# debugId=17ad2cbf-4876-5709-85e7-7f5dbd685e7c
+//# debugId=d67e1a91-eac4-5958-9bd4-cbd63ced5b93