@unbrained/pm-cli 2026.7.6 → 2026.7.7

package/dist/cli-bundle/chunks/chunk-WG34ZNQQ.js

@@ -1,3423 +0,0 @@
-
-!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]="40f0d0e2-0ce8-5774-a5dc-06db389b346f")}catch(e){}}();
-import {
-  buildExtensionDescribeResult,
-  scaffoldExtensionProject
-} from "./chunk-WLSM645P.js";
-import {
-  splitCommaList
-} from "./chunk-P4SESZGT.js";
-import {
-  normalizeExtensionNameForMatch,
-  normalizeManagedDirectoryName,
-  normalizeStringList,
-  parseExtensionManifest,
-  validateExtensionDirectory
-} from "./chunk-Y4M7CPQP.js";
-import {
-  ensureTypeFolderScaffold
-} from "./chunk-LPSSSDJR.js";
-import {
-  nowIso
-} from "./chunk-3GCS5SKL.js";
-import {
-  PmCliError,
-  readSettings,
-  writeSettings
-} from "./chunk-E3SZTQ4K.js";
-import {
-  EXIT_CODE,
-  EXTENSION_CAPABILITY_CONTRACT,
-  KNOWN_EXTENSION_CAPABILITIES,
-  activateExtensions,
-  isPathWithinDirectory,
-  levenshteinDistanceWithinLimit,
-  loadExtensions,
-  nextExtensionReloadToken,
-  parseLegacyExtensionCapabilityAliasWarning,
-  parseUnknownExtensionCapabilityWarning,
-  pathExists,
-  reconcileExtensionCapabilityUsage,
-  resolveExtensionRoots,
-  resolveGlobalPmRoot,
-  resolvePmPackageRootFromModule,
-  resolvePmRoot
-} from "./chunk-57NWPFF2.js";
-
-// dist/cli/commands/extension.js
-import { execFile as execFile2 } from "node:child_process";
-import fs5 from "node:fs/promises";
-import os2 from "node:os";
-import path5 from "node:path";
-import { promisify as promisify2 } from "node:util";
-
-// dist/cli/commands/extension/managed-state.js
-import fs from "node:fs/promises";
-import path from "node:path";
-var MANAGED_EXTENSION_STATE_FILENAME = ".managed-extensions.json";
-var MANAGED_EXTENSION_STATE_VERSION = 1;
-function resolveManagedExtensionStatePath(extensionsRoot) {
-  return path.join(extensionsRoot, MANAGED_EXTENSION_STATE_FILENAME);
-}
-function createEmptyManagedExtensionState() {
-  return {
-    version: MANAGED_EXTENSION_STATE_VERSION,
-    updated_at: nowIso(),
-    entries: []
-  };
-}
-function sortManagedEntries(entries) {
-  return [...entries].sort((left, right) => {
-    const byScope = left.scope.localeCompare(right.scope);
-    if (byScope !== 0) {
-      return byScope;
-    }
-    const byName = left.name.localeCompare(right.name);
-    if (byName !== 0) {
-      return byName;
-    }
-    return left.directory.localeCompare(right.directory);
-  });
-}
-function managedExtensionSourcesEquivalent(left, right) {
-  if (left.kind !== right.kind || left.input !== right.input || left.location !== right.location) {
-    return false;
-  }
-  if (left.kind === "npm" && right.kind === "npm") {
-    return left.package === right.package && left.version === right.version;
-  }
-  if (left.kind === "github" && right.kind === "github") {
-    return left.repository === right.repository && left.ref === right.ref && left.subpath === right.subpath && left.commit === right.commit;
-  }
-  if (left.kind === "builtin" && right.kind === "builtin") {
-    return left.name === right.name;
-  }
-  return true;
-}
-function optionalString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function hasRequiredManagedRecordFields(entry) {
-  return typeof entry.name === "string" && entry.name.trim().length > 0 && typeof entry.directory === "string" && entry.directory.trim().length > 0 && (entry.scope === "project" || entry.scope === "global") && typeof entry.manifest_version === "string" && typeof entry.manifest_entry === "string" && Array.isArray(entry.capabilities) && entry.capabilities.every((value) => typeof value === "string") && typeof entry.installed_at === "string" && typeof entry.updated_at === "string";
-}
-function normalizeManagedSource(raw) {
-  if (typeof raw !== "object" || raw === null) {
-    return null;
-  }
-  const source = raw;
-  if (source.kind !== "local" && source.kind !== "github" && source.kind !== "npm" && source.kind !== "builtin" || typeof source.input !== "string" || typeof source.location !== "string") {
-    return null;
-  }
-  return {
-    kind: source.kind,
-    input: source.input,
-    location: source.location,
-    name: optionalString(source.name),
-    package: optionalString(source.package),
-    version: optionalString(source.version),
-    repository: optionalString(source.repository),
-    owner: optionalString(source.owner),
-    repo: optionalString(source.repo),
-    ref: optionalString(source.ref),
-    subpath: optionalString(source.subpath),
-    commit: optionalString(source.commit)
-  };
-}
-function normalizeManagedRecord(raw) {
-  if (typeof raw !== "object" || raw === null) {
-    return null;
-  }
-  const entry = raw;
-  if (!hasRequiredManagedRecordFields(entry)) {
-    return null;
-  }
-  const source = normalizeManagedSource(entry.source);
-  if (!source) {
-    return null;
-  }
-  return {
-    name: entry.name.trim(),
-    directory: entry.directory.trim(),
-    scope: entry.scope,
-    manifest_version: entry.manifest_version,
-    manifest_entry: entry.manifest_entry,
-    capabilities: normalizeStringList(entry.capabilities),
-    installed_at: entry.installed_at,
-    updated_at: entry.updated_at,
-    source,
-    last_update_check_at: optionalString(entry.last_update_check_at),
-    last_update_remote_commit: optionalString(entry.last_update_remote_commit),
-    update_available: typeof entry.update_available === "boolean" || entry.update_available === null ? entry.update_available : void 0,
-    update_error: optionalString(entry.update_error)
-  };
-}
-function normalizeManagedState(raw) {
-  if (typeof raw !== "object" || raw === null) {
-    return null;
-  }
-  const candidate = raw;
-  if (candidate.version !== MANAGED_EXTENSION_STATE_VERSION || !Array.isArray(candidate.entries)) {
-    return null;
-  }
-  const entries = [];
-  for (const rawEntry of candidate.entries) {
-    const record = normalizeManagedRecord(rawEntry);
-    if (record) {
-      entries.push(record);
-    }
-  }
-  return {
-    version: MANAGED_EXTENSION_STATE_VERSION,
-    updated_at: optionalString(candidate.updated_at) ?? nowIso(),
-    entries: sortManagedEntries(entries)
-  };
-}
-async function readManagedExtensionState(extensionsRoot) {
-  const statePath = resolveManagedExtensionStatePath(extensionsRoot);
-  const fallback = createEmptyManagedExtensionState();
-  try {
-    const raw = await fs.readFile(statePath, "utf8");
-    const parsed = JSON.parse(raw);
-    const normalized = normalizeManagedState(parsed);
-    if (!normalized) {
-      throw new PmCliError(`Managed extension state file "${statePath}" has an invalid schema. Repair or remove it before mutating extension state.`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    return {
-      path: statePath,
-      state: normalized,
-      warnings: []
-    };
-  } catch (error) {
-    if (error instanceof PmCliError) {
-      throw error;
-    }
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
-      return {
-        path: statePath,
-        state: fallback,
-        warnings: []
-      };
-    }
-    throw new PmCliError(`Managed extension state file "${statePath}" could not be read. Repair or remove it before mutating extension state.`, EXIT_CODE.GENERIC_FAILURE);
-  }
-}
-async function writeManagedExtensionState(extensionsRoot, state) {
-  const statePath = resolveManagedExtensionStatePath(extensionsRoot);
-  const normalized = {
-    version: MANAGED_EXTENSION_STATE_VERSION,
-    updated_at: nowIso(),
-    entries: sortManagedEntries(state.entries)
-  };
-  await fs.mkdir(extensionsRoot, { recursive: true });
-  await fs.writeFile(statePath, `${JSON.stringify(normalized, null, 2)}
-`, "utf8");
-}
-function upsertManagedEntry(state, entry) {
-  const updatedEntries = state.entries.filter((candidate) => normalizeExtensionNameForMatch(candidate.name) !== normalizeExtensionNameForMatch(entry.name) && normalizeExtensionNameForMatch(candidate.directory) !== normalizeExtensionNameForMatch(entry.directory));
-  updatedEntries.push(entry);
-  return {
-    ...state,
-    updated_at: nowIso(),
-    entries: sortManagedEntries(updatedEntries)
-  };
-}
-
-// dist/cli/commands/extension/install-sources.js
-import { execFile } from "node:child_process";
-import fs3 from "node:fs/promises";
-import os from "node:os";
-import path3 from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-
-// dist/core/packages/manifest.js
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
-var PM_PACKAGE_RESOURCE_KINDS = [
-  "extensions",
-  "docs",
-  "examples",
-  "assets",
-  "prompts"
-];
-var PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS = Object.freeze({
-  extensions: Object.freeze([
-    ".agents/pm/extensions",
-    "extensions",
-    ".custom/pm-extensions",
-    ".custom/pm-extension"
-  ]),
-  docs: Object.freeze([
-    "docs",
-    "documentation"
-  ]),
-  examples: Object.freeze([
-    "examples",
-    "docs/examples"
-  ]),
-  assets: Object.freeze([
-    "assets",
-    ".agents/pm/assets"
-  ]),
-  prompts: Object.freeze([
-    "prompts",
-    ".agents/pm/prompts"
-  ])
-});
-function isKnownPackageResourceKind(value) {
-  return PM_PACKAGE_RESOURCE_KINDS.includes(value);
-}
-function normalizePackageResourceEntries(kind, raw) {
-  if (raw === void 0 || raw === null) {
-    return [];
-  }
-  const entries = Array.isArray(raw) ? raw : [raw];
-  const normalized = [];
-  for (const entry of entries) {
-    if (typeof entry !== "string" || entry.trim().length === 0) {
-      throw new PmCliError(`Package manifest field pm.${kind} must contain string paths.`, EXIT_CODE.USAGE);
-    }
-    normalized.push(entry.trim());
-  }
-  return [...new Set(normalized)].sort((left, right) => left.localeCompare(right));
-}
-function normalizePackageResourceMap(raw) {
-  if (raw === void 0 || raw === null) {
-    return {};
-  }
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new PmCliError("Package manifest field pm must be an object.", EXIT_CODE.USAGE);
-  }
-  const resources = {};
-  const candidate = raw;
-  for (const [key, value] of Object.entries(candidate)) {
-    if (!isKnownPackageResourceKind(key)) {
-      continue;
-    }
-    const entries = normalizePackageResourceEntries(key, value);
-    if (entries.length > 0) {
-      resources[key] = entries;
-    }
-  }
-  return resources;
-}
-function readStringField(source, key) {
-  const value = source[key];
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-}
-function normalizeStringArray(raw) {
-  if (!Array.isArray(raw)) {
-    return void 0;
-  }
-  const values = raw.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0);
-  return values.length > 0 ? [...new Set(values)].sort((left, right) => left.localeCompare(right)) : void 0;
-}
-function readUrlLikeField(raw) {
-  if (typeof raw === "string" && raw.trim().length > 0) {
-    return raw.trim();
-  }
-  if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
-    const value = raw.url;
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-  }
-  return void 0;
-}
-function normalizeCatalogLinks(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return void 0;
-  }
-  const source = raw;
-  const links = {
-    docs: readStringField(source, "docs"),
-    npm: readStringField(source, "npm"),
-    repository: readStringField(source, "repository"),
-    report: readStringField(source, "report")
-  };
-  return Object.values(links).some((value) => typeof value === "string") ? links : void 0;
-}
-function normalizeCatalogMedia(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return void 0;
-  }
-  const source = raw;
-  const media = {
-    image: readStringField(source, "image"),
-    video: readStringField(source, "video")
-  };
-  return Object.values(media).some((value) => typeof value === "string") ? media : void 0;
-}
-function normalizePackageCatalogMetadata(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return void 0;
-  }
-  const source = raw;
-  const catalog = {
-    display_name: readStringField(source, "display_name") ?? readStringField(source, "displayName"),
-    category: readStringField(source, "category"),
-    summary: readStringField(source, "summary"),
-    links: normalizeCatalogLinks(source.links),
-    media: normalizeCatalogMedia(source.media),
-    tags: normalizeStringArray(source.tags)
-  };
-  return Object.values(catalog).some((value) => value !== void 0) ? catalog : void 0;
-}
-async function readPmPackageManifest(packageRoot) {
-  const packageJsonPath = path2.join(packageRoot, "package.json");
-  if (!await pathExists(packageJsonPath)) {
-    return {
-      source: "convention",
-      resources: {}
-    };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(await fs2.readFile(packageJsonPath, "utf8"));
-  } catch (error) {
-    throw new PmCliError(`Failed to parse package manifest at "${packageJsonPath}": ${String(error)}`, EXIT_CODE.USAGE);
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new PmCliError(`Package manifest at "${packageJsonPath}" must be a JSON object.`, EXIT_CODE.USAGE);
-  }
-  const packageJson = parsed;
-  const pmManifest = packageJson.pm;
-  const hasPmManifest = pmManifest !== void 0 && pmManifest !== null;
-  const pmManifestRecord = typeof pmManifest === "object" && pmManifest !== null && !Array.isArray(pmManifest) ? pmManifest : {};
-  return {
-    source: hasPmManifest ? "pm" : "convention",
-    package_json_path: packageJsonPath,
-    package_name: typeof packageJson.name === "string" ? packageJson.name : void 0,
-    package_version: typeof packageJson.version === "string" ? packageJson.version : void 0,
-    package_private: packageJson.private === true,
-    package_description: typeof packageJson.description === "string" ? packageJson.description : void 0,
-    package_keywords: normalizeStringArray(packageJson.keywords),
-    package_homepage: typeof packageJson.homepage === "string" ? packageJson.homepage : void 0,
-    package_repository_url: readUrlLikeField(packageJson.repository),
-    package_bugs_url: readUrlLikeField(packageJson.bugs),
-    aliases: normalizeStringArray(pmManifestRecord.aliases),
-    resources: normalizePackageResourceMap(pmManifest),
-    catalog: normalizePackageCatalogMetadata(pmManifestRecord.catalog)
-  };
-}
-async function listExtensionManifestDirectories(parentDirectory) {
-  if (!await pathExists(parentDirectory)) {
-    return [];
-  }
-  const entries = await fs2.readdir(parentDirectory, { withFileTypes: true });
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const directory = path2.join(parentDirectory, entry.name);
-    if (await pathExists(path2.join(directory, "manifest.json"))) {
-      candidates.push(directory);
-    }
-  }
-  return candidates.sort((left, right) => left.localeCompare(right));
-}
-async function collectPackageExtensionDirectories(packageRoot) {
-  if (await pathExists(path2.join(packageRoot, "manifest.json"))) {
-    return [packageRoot];
-  }
-  const manifest = await readPmPackageManifest(packageRoot);
-  const manifestEntries = manifest.resources.extensions ?? [];
-  const discovered = /* @__PURE__ */ new Set();
-  for (const entry of manifestEntries) {
-    if (entry.includes("*") || entry.startsWith("!")) {
-      throw new PmCliError(`Package extension entry "${entry}" uses a glob/exclusion pattern. pm package installs currently require concrete extension paths or directories.`, EXIT_CODE.USAGE);
-    }
-    const absolute = path2.resolve(packageRoot, entry);
-    if (!isPathWithinDirectory(packageRoot, absolute)) {
-      throw new PmCliError(`Package extension entry "${entry}" resolves outside package root.`, EXIT_CODE.USAGE);
-    }
-    if (await pathExists(path2.join(absolute, "manifest.json"))) {
-      discovered.add(absolute);
-      continue;
-    }
-    for (const child of await listExtensionManifestDirectories(absolute)) {
-      discovered.add(child);
-    }
-  }
-  if (manifestEntries.length === 0) {
-    for (const root of PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS.extensions) {
-      for (const child of await listExtensionManifestDirectories(path2.join(packageRoot, root))) {
-        discovered.add(child);
-      }
-    }
-  }
-  return [...discovered].sort((left, right) => left.localeCompare(right));
-}
-
-// dist/cli/commands/extension/install-sources.js
-var execFileAsync = promisify(execFile);
-var PM_CLI_PACKAGE_NAME = "@unbrained/pm-cli";
-function parseGithubPathSpec(pathSpec, input, refOverride) {
-  const segments = pathSpec.split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
-  if (segments.length < 2) {
-    return null;
-  }
-  const owner = segments[0];
-  const repo = segments[1].replace(/\.git$/i, "");
-  if (owner.length === 0 || repo.length === 0) {
-    return null;
-  }
-  const tail = segments.slice(2);
-  let ref;
-  let subpath;
-  if (tail[0] === "tree" && tail.length >= 2) {
-    ref = tail[1];
-    subpath = tail.slice(2).join("/");
-  } else if (tail.length > 0) {
-    subpath = tail.join("/");
-  }
-  if (typeof refOverride === "string" && refOverride.trim().length > 0) {
-    ref = refOverride.trim();
-  }
-  return {
-    kind: "github",
-    input,
-    owner,
-    repo,
-    repository: `https://github.com/${owner}/${repo}.git`,
-    ref,
-    subpath: subpath && subpath.length > 0 ? subpath : void 0
-  };
-}
-function parseExtensionInstallSource(input, options = {}) {
-  const normalizedInput = input.trim();
-  if (normalizedInput.length === 0) {
-    throw new PmCliError("Extension source is required for --install.", EXIT_CODE.USAGE);
-  }
-  const refOverride = typeof options.ref === "string" && options.ref.trim().length > 0 ? options.ref.trim() : void 0;
-  if (normalizedInput.startsWith("npm:")) {
-    const spec = normalizedInput.slice("npm:".length).trim();
-    if (spec.length === 0) {
-      throw new PmCliError('npm package source must include a package spec after "npm:".', EXIT_CODE.USAGE);
-    }
-    if (options.forceGithub) {
-      throw new PmCliError('Options "--gh/--github" cannot be combined with npm: package sources.', EXIT_CODE.USAGE);
-    }
-    if (refOverride) {
-      throw new PmCliError('Option "--ref" cannot be combined with npm: package sources.', EXIT_CODE.USAGE);
-    }
-    return {
-      kind: "npm",
-      input: normalizedInput,
-      spec
-    };
-  }
-  const maybeGithubByUrl = (() => {
-    try {
-      const parsed = new URL(normalizedInput);
-      if (parsed.hostname !== "github.com") {
-        return null;
-      }
-      const pathSpec = parsed.pathname.replace(/^\/+/, "");
-      return parseGithubPathSpec(pathSpec, normalizedInput, refOverride);
-    } catch {
-      return null;
-    }
-  })();
-  if (maybeGithubByUrl) {
-    return maybeGithubByUrl;
-  }
-  const strippedDomainInput = normalizedInput.startsWith("github.com/") ? normalizedInput.slice("github.com/".length) : null;
-  if (strippedDomainInput) {
-    const parsed = parseGithubPathSpec(strippedDomainInput, normalizedInput, refOverride);
-    if (!parsed) {
-      throw new PmCliError(`Invalid GitHub source "${normalizedInput}".`, EXIT_CODE.USAGE);
-    }
-    return parsed;
-  }
-  if (options.forceGithub) {
-    const parsed = parseGithubPathSpec(normalizedInput, normalizedInput, refOverride);
-    if (!parsed) {
-      throw new PmCliError(`Invalid GitHub shorthand "${normalizedInput}".`, EXIT_CODE.USAGE);
-    }
-    return parsed;
-  }
-  if (/^https?:\/\//i.test(normalizedInput)) {
-    throw new PmCliError(`Unsupported extension source URL "${normalizedInput}". Supported remote source host: github.com.`, EXIT_CODE.USAGE);
-  }
-  return {
-    kind: "local",
-    input: normalizedInput,
-    absolute_path: path3.resolve(process.cwd(), normalizedInput)
-  };
-}
-async function runGitCommand(args, execRunner = execFileAsync) {
-  try {
-    const result = await execRunner("git", args, { encoding: "utf8" });
-    return (result.stdout ?? "").trim();
-  } catch (error) {
-    const stderr = typeof error === "object" && error !== null && "stderr" in error ? String(error.stderr) : "";
-    const message = stderr.trim().length > 0 ? stderr.trim() : error instanceof Error ? error.message : String(error);
-    throw new PmCliError(`Git command failed: git ${args.join(" ")}
-${message}`, EXIT_CODE.GENERIC_FAILURE);
-  }
-}
-function resolveNpmCommandName(platform = process.platform) {
-  return platform === "win32" ? "npm.cmd" : "npm";
-}
-function shouldRunNpmCommandInShell(platform = process.platform) {
-  return platform === "win32";
-}
-async function runNpmCommand(args, cwd, execRunner = execFileAsync) {
-  const npmCommand = resolveNpmCommandName();
-  try {
-    const result = await execRunner(npmCommand, args, { cwd, encoding: "utf8", shell: shouldRunNpmCommandInShell() });
-    return (result.stdout ?? "").trim();
-  } catch (error) {
-    const stderr = typeof error === "object" && error !== null && "stderr" in error ? String(error.stderr) : "";
-    const message = stderr.trim().length > 0 ? stderr.trim() : error instanceof Error ? error.message : String(error);
-    throw new PmCliError(`npm command failed: ${npmCommand} ${args.join(" ")}
-${message}`, EXIT_CODE.GENERIC_FAILURE);
-  }
-}
-function npmPackageNameFromSpec(spec) {
-  const trimmed = spec.trim();
-  const withoutAlias = trimmed.includes("@file:") ? trimmed.slice(0, trimmed.lastIndexOf("@file:")) : trimmed;
-  if (withoutAlias.startsWith("@")) {
-    const scoped = withoutAlias.match(/^(@[^/@\s]+\/[^/@\s]+)/);
-    return scoped?.[1] ?? withoutAlias;
-  }
-  const unscoped = withoutAlias.match(/^([^/@\s]+)/);
-  return unscoped?.[1] ?? withoutAlias;
-}
-function isNpmNotFoundError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const normalized = message.toLowerCase();
-  return normalized.includes("npm err! code e404") || normalized.includes("404 not found") || normalized.includes("is not in this registry");
-}
-function isNpmPackNotFoundError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const normalized = message.toLowerCase();
-  return isNpmNotFoundError(error) || normalized.includes("not found");
-}
-function isFirstPartyPmPackageName(packageName) {
-  const normalized = packageName.trim().toLowerCase();
-  return normalized.startsWith("@unbrained/pm-") || normalized.startsWith("pm-");
-}
-function buildNpmNotFoundRecovery(spec) {
-  const packageName = npmPackageNameFromSpec(spec);
-  const isFirstPartyPackage = isFirstPartyPmPackageName(packageName);
-  const repoName = packageName.replace(/^.*\//, "");
-  const githubSource = isFirstPartyPackage ? `github.com/unbraind/${repoName}` : void 0;
-  const nextBestCommand = githubSource ? `pm install --project ${githubSource}` : void 0;
-  return {
-    message: isFirstPartyPackage ? `npm package "${spec}" was not found in the registry. If this is an unpublished first-party pm package, install its GitHub repository instead.` : `npm package "${spec}" was not found in the registry.`,
-    context: {
-      code: "npm_package_not_found",
-      required: "Use an install source that exists, or publish the npm package before installing it with npm:<name>.",
-      why: "Classifying npm 404s avoids repeated registry retries and gives agents a deterministic fallback path.",
-      examples: nextBestCommand ? [nextBestCommand, `pm package catalog --project --json`] : [`npm view ${packageName}`, `pm package catalog --project --json`],
-      nextSteps: nextBestCommand ? [
-        `Try ${nextBestCommand} if the repository exists.`,
-        "Use pm package catalog --project --json to inspect bundled package aliases before installing."
-      ] : [
-        `Verify ${packageName} exists in the npm registry and that you have access to it.`,
-        "Use pm package catalog --project --json to inspect bundled package aliases before installing."
-      ],
-      recovery: {
-        attempted_command: `pm install --project npm:${spec}`,
-        normalized_args: ["install", "--project", `npm:${spec}`],
-        ...githubSource && nextBestCommand ? {
-          fallback_candidates: [
-            {
-              source: githubSource,
-              command: nextBestCommand,
-              reason: "canonical first-party GitHub repository fallback for unpublished pm packages"
-            }
-          ],
-          next_best_command: nextBestCommand
-        } : {}
-      }
-    }
-  };
-}
-function wrapNpmPackResolutionError(spec, error) {
-  if (!isNpmPackNotFoundError(error)) {
-    return null;
-  }
-  const recovery = buildNpmNotFoundRecovery(spec);
-  return new PmCliError(recovery.message, EXIT_CODE.NOT_FOUND, recovery.context);
-}
-async function resolveLocalNpmPackagePath(spec) {
-  if (path3.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..")) {
-    const absolutePath = path3.resolve(process.cwd(), spec);
-    return await pathExists(absolutePath) ? absolutePath : null;
-  }
-  try {
-    const parsed = new URL(spec);
-    if (parsed.protocol === "file:") {
-      const absolutePath = fileURLToPath(parsed);
-      return await pathExists(absolutePath) ? absolutePath : null;
-    }
-  } catch {
-  }
-  if (!/^[a-z][a-z0-9+.-]*:/i.test(spec)) {
-    const absolutePath = path3.resolve(process.cwd(), spec);
-    if (await pathExists(absolutePath)) {
-      return absolutePath;
-    }
-  }
-  return null;
-}
-async function resolveNpmPackSpec(spec) {
-  const localPath = await resolveLocalNpmPackagePath(spec);
-  if (localPath) {
-    return localPath;
-  }
-  const localFileAlias = normalizeNpmLocalFileAliasSpec(spec);
-  if (localFileAlias !== spec) {
-    return localFileAlias;
-  }
-  if (/^[a-z][a-z0-9+.-]*:/i.test(spec)) {
-    return spec;
-  }
-  return spec;
-}
-function normalizeNpmLocalFileAliasSpec(spec, cwd = process.cwd()) {
-  const marker = "@file:";
-  const markerIndex = spec.lastIndexOf(marker);
-  if (markerIndex <= 0) {
-    return spec;
-  }
-  const packageName = spec.slice(0, markerIndex);
-  const target = spec.slice(markerIndex + marker.length);
-  if (packageName.trim().length === 0 || target.trim().length === 0) {
-    return spec;
-  }
-  if (target.startsWith("//") && !target.startsWith("///")) {
-    return spec;
-  }
-  if (!target.startsWith("/")) {
-    return `${packageName}@${path3.resolve(cwd, target)}`;
-  }
-  let decodedPath;
-  try {
-    decodedPath = decodeURIComponent(new URL(`file:${target}`).pathname);
-  } catch {
-    return spec;
-  }
-  const nativePath = /^\/[A-Za-z]:/.test(decodedPath) ? decodedPath.slice(1) : decodedPath;
-  return `${packageName}@${nativePath}`;
-}
-function parsePackedNpmPackage(stdout, packDirectory) {
-  try {
-    const parsed = JSON.parse(stdout);
-    const first = Array.isArray(parsed) ? parsed[0] : void 0;
-    if (first && typeof first.filename === "string" && first.filename.trim().length > 0) {
-      return {
-        tarball: path3.resolve(packDirectory, first.filename),
-        package: typeof first.name === "string" ? first.name : void 0,
-        version: typeof first.version === "string" ? first.version : void 0
-      };
-    }
-  } catch {
-  }
-  const lastLine = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).at(-1);
-  if (!lastLine) {
-    throw new PmCliError("npm pack did not report a tarball filename.", EXIT_CODE.GENERIC_FAILURE);
-  }
-  return {
-    tarball: path3.resolve(packDirectory, lastLine)
-  };
-}
-async function resolveNpmSourceDirectory(source) {
-  return resolveNpmSourceDirectoryWithRunner(source, runNpmCommand);
-}
-async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
-  const localPackageRoot = await resolveLocalNpmPackagePath(source.spec);
-  if (localPackageRoot) {
-    const packageJsonPath = path3.join(localPackageRoot, "package.json");
-    const packageJson = await pathExists(packageJsonPath) ? JSON.parse(await fs3.readFile(packageJsonPath, "utf8")) : {};
-    return {
-      directory: await resolvePackageExtensionDirectory(localPackageRoot, source.input),
-      package: typeof packageJson.name === "string" ? packageJson.name : void 0,
-      version: typeof packageJson.version === "string" ? packageJson.version : void 0,
-      cleanup: async () => {
-      }
-    };
-  }
-  const tempRoot = await fs3.mkdtemp(path3.join(os.tmpdir(), "pm-npm-package-source-"));
-  const packDirectory = path3.join(tempRoot, "pack");
-  const extractDirectory = path3.join(tempRoot, "extract");
-  await fs3.mkdir(packDirectory, { recursive: true });
-  await fs3.mkdir(extractDirectory, { recursive: true });
-  try {
-    const packSpec = await resolveNpmPackSpec(source.spec);
-    const packStdout = await npmRunner(["pack", packSpec, "--json", "--pack-destination", packDirectory]);
-    const packed = parsePackedNpmPackage(packStdout, packDirectory);
-    await execFileAsync("tar", ["-xzf", packed.tarball, "-C", extractDirectory], { encoding: "utf8" });
-    const packageRoot = path3.join(extractDirectory, "package");
-    await installNpmPackageRuntimeDependencies(packageRoot);
-    const directory = await resolvePackageExtensionDirectory(packageRoot, source.input);
-    return {
-      directory,
-      package: packed.package,
-      version: packed.version,
-      cleanup: async () => {
-        await fs3.rm(tempRoot, { recursive: true, force: true });
-      }
-    };
-  } catch (error) {
-    await fs3.rm(tempRoot, { recursive: true, force: true });
-    const wrappedError = wrapNpmPackResolutionError(source.spec, error);
-    if (wrappedError) {
-      throw wrappedError;
-    }
-    throw error;
-  }
-}
-async function installNpmPackageRuntimeDependencies(packageRoot) {
-  const packageJsonPath = path3.join(packageRoot, "package.json");
-  if (!await pathExists(packageJsonPath)) {
-    return;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(await fs3.readFile(packageJsonPath, "utf8"));
-  } catch {
-    return;
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    return;
-  }
-  const manifest = parsed;
-  const dependencySpecs = runtimeDependencyInstallSpecs(manifest);
-  const shouldLinkHostedPmCli = hasHostedPmCliDependency(manifest);
-  if (dependencySpecs.length === 0 && !shouldLinkHostedPmCli) {
-    return;
-  }
-  const runtimeOnlyManifest = { ...parsed };
-  delete runtimeOnlyManifest.devDependencies;
-  const installManifest = { ...runtimeOnlyManifest };
-  removeHostedPmCliDependency(installManifest);
-  await fs3.writeFile(packageJsonPath, `${JSON.stringify(installManifest, null, 2)}
-`, "utf8");
-  try {
-    await Promise.all([
-      fs3.rm(path3.join(packageRoot, "package-lock.json"), { force: true }),
-      fs3.rm(path3.join(packageRoot, "npm-shrinkwrap.json"), { force: true })
-    ]);
-    if (dependencySpecs.length > 0) {
-      await runNpmCommand([
-        "install",
-        "--ignore-scripts",
-        "--no-audit",
-        "--fund=false",
-        "--package-lock=false",
-        "--no-save",
-        "--omit=peer",
-        ...dependencySpecs
-      ], packageRoot);
-    }
-    if (shouldLinkHostedPmCli) {
-      await linkHostedPmCliDependency(packageRoot);
-    }
-  } finally {
-    await fs3.writeFile(packageJsonPath, `${JSON.stringify(runtimeOnlyManifest, null, 2)}
-`, "utf8");
-  }
-}
-function hasHostedPmCliDependency(manifest) {
-  for (const dependencyMap of [manifest.dependencies, manifest.optionalDependencies, manifest.peerDependencies]) {
-    if (typeof dependencyMap === "object" && dependencyMap !== null && PM_CLI_PACKAGE_NAME in dependencyMap) {
-      return true;
-    }
-  }
-  return false;
-}
-function removeHostedPmCliDependency(manifest) {
-  for (const field of ["dependencies", "optionalDependencies", "peerDependencies"]) {
-    const dependencyMap = manifest[field];
-    if (typeof dependencyMap !== "object" || dependencyMap === null) {
-      continue;
-    }
-    const nextMap = { ...dependencyMap };
-    delete nextMap[PM_CLI_PACKAGE_NAME];
-    if (Object.keys(nextMap).length === 0) {
-      delete manifest[field];
-    } else {
-      manifest[field] = nextMap;
-    }
-  }
-}
-async function linkHostedPmCliDependency(packageRoot) {
-  const hostPackageRoot = resolvePmPackageRootFromModule(import.meta.url, ["../../../.."]);
-  const [scope, packageName] = PM_CLI_PACKAGE_NAME.split("/");
-  const scopedDirectory = path3.join(packageRoot, "node_modules", scope);
-  const linkPath = path3.join(scopedDirectory, packageName);
-  await fs3.mkdir(scopedDirectory, { recursive: true });
-  await fs3.rm(linkPath, { recursive: true, force: true });
-  await fs3.symlink(hostPackageRoot, linkPath, resolveDirectorySymlinkType(process.platform));
-}
-function resolveDirectorySymlinkType(platform) {
-  return platform === "win32" ? "junction" : "dir";
-}
-function runtimeDependencyInstallSpecs(manifest) {
-  const specs = /* @__PURE__ */ new Map();
-  for (const dependencyMap of [manifest.dependencies, manifest.optionalDependencies, manifest.peerDependencies]) {
-    if (typeof dependencyMap !== "object" || dependencyMap === null) {
-      continue;
-    }
-    for (const [name, version] of Object.entries(dependencyMap)) {
-      if (name === PM_CLI_PACKAGE_NAME || typeof version !== "string" || version.trim().length === 0 || specs.has(name)) {
-        continue;
-      }
-      specs.set(name, `${name}@${version.trim()}`);
-    }
-  }
-  return [...specs.values()];
-}
-async function resolvePackageExtensionDirectory(packageRoot, sourceLabel) {
-  const discovered = await collectPackageExtensionDirectories(packageRoot);
-  if (discovered.length === 1) {
-    return discovered[0];
-  }
-  if (discovered.length > 1) {
-    const choices = discovered.map((entry) => path3.relative(packageRoot, entry).replaceAll(path3.sep, "/")).sort((left, right) => left.localeCompare(right));
-    throw new PmCliError(`Package source "${sourceLabel}" contains multiple extension manifests. Provide an explicit extension path. Candidates: ${choices.join(", ")}`, EXIT_CODE.USAGE);
-  }
-  throw new PmCliError(`Unable to locate a pm extension manifest in package source "${sourceLabel}". Package installs currently activate only extension resources, so add package.json pm.extensions or an extensions/ directory. Metadata-only resources like pm.docs/pm.examples are catalog metadata and do not activate commands.`, EXIT_CODE.USAGE);
-}
-async function resolveGithubSourceDirectory(cloneDirectory, source) {
-  const candidatePaths = [];
-  if (source.subpath) {
-    candidatePaths.push(source.subpath);
-    candidatePaths.push(path3.posix.join(".agents/pm/extensions", source.subpath));
-    candidatePaths.push(path3.posix.join(".custom/pm-extensions", source.subpath));
-    candidatePaths.push(path3.posix.join(".custom/pm-extension", source.subpath));
-  }
-  for (const candidate of candidatePaths) {
-    const absolute = path3.resolve(cloneDirectory, candidate);
-    if (!isPathWithinDirectory(cloneDirectory, absolute)) {
-      continue;
-    }
-    if (await pathExists(path3.join(absolute, "manifest.json"))) {
-      return { directory: absolute, resolved_subpath: candidate };
-    }
-  }
-  if (await pathExists(path3.join(cloneDirectory, "manifest.json"))) {
-    return { directory: cloneDirectory, resolved_subpath: "." };
-  }
-  const discoveredDirectory = await resolvePackageExtensionDirectory(cloneDirectory, source.input);
-  return {
-    directory: discoveredDirectory,
-    resolved_subpath: path3.relative(cloneDirectory, discoveredDirectory).replaceAll(path3.sep, "/")
-  };
-}
-async function resolveInstallSource(source) {
-  if (source.kind === "local") {
-    let localStats;
-    try {
-      localStats = await fs3.stat(source.absolute_path);
-    } catch {
-      throw new PmCliError(`Local extension source does not exist: "${source.absolute_path}".`, EXIT_CODE.NOT_FOUND);
-    }
-    if (!localStats.isDirectory()) {
-      throw new PmCliError(`Local extension source must be a directory: "${source.absolute_path}".`, EXIT_CODE.USAGE);
-    }
-    const directory = await resolvePackageExtensionDirectory(source.absolute_path, source.input);
-    return {
-      source,
-      directory
-    };
-  }
-  if (source.kind === "npm") {
-    const resolved = await resolveNpmSourceDirectory(source);
-    return {
-      source,
-      directory: resolved.directory,
-      cleanup: resolved.cleanup,
-      resolved_subpath: path3.relative(path3.dirname(resolved.directory), resolved.directory).replaceAll(path3.sep, "/"),
-      npm_package: resolved.package,
-      npm_version: resolved.version
-    };
-  }
-  const cloneDirectory = await fs3.mkdtemp(path3.join(os.tmpdir(), "pm-extension-source-"));
-  const cloneArgs = ["clone", "--depth", "1"];
-  if (source.ref) {
-    cloneArgs.push("--branch", source.ref);
-  }
-  cloneArgs.push(source.repository, cloneDirectory);
-  try {
-    await runGitCommand(cloneArgs);
-    const commit = await runGitCommand(["-C", cloneDirectory, "rev-parse", "HEAD"]);
-    const resolved = await resolveGithubSourceDirectory(cloneDirectory, source);
-    return {
-      source,
-      directory: resolved.directory,
-      resolved_subpath: resolved.resolved_subpath,
-      commit,
-      cleanup: async () => {
-        await fs3.rm(cloneDirectory, { recursive: true, force: true });
-      }
-    };
-  } catch (error) {
-    await fs3.rm(cloneDirectory, { recursive: true, force: true });
-    throw error;
-  }
-}
-async function areDirectoriesEquivalent(left, right) {
-  if (!await pathExists(left) || !await pathExists(right)) {
-    return false;
-  }
-  const [leftRealPath, rightRealPath] = await Promise.all([fs3.realpath(left), fs3.realpath(right)]);
-  return leftRealPath === rightRealPath;
-}
-
-// dist/cli/commands/extension/bundled-catalog.js
-import fs4 from "node:fs/promises";
-import path4 from "node:path";
-var PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
-var LEGACY_BUNDLED_PACKAGE_ALIASES = {
-  beads: {
-    package_directory: "pm-beads",
-    legacy_extension_directory: "beads"
-  },
-  todos: {
-    package_directory: "pm-todos",
-    legacy_extension_directory: "todos"
-  }
-};
-var BUNDLED_PACKAGE_INSTALL_ALL_TARGETS = /* @__PURE__ */ new Set(["*", "all"]);
-function resolvePackageRootCandidates() {
-  const candidates = [];
-  const envRoot = process.env[PM_PACKAGE_ROOT_ENV];
-  if (typeof envRoot === "string" && envRoot.trim().length > 0) {
-    candidates.push(path4.resolve(envRoot.trim()));
-  }
-  candidates.push(resolvePmPackageRootFromModule(import.meta.url, ["../../../.."]));
-  return [...new Set(candidates)];
-}
-async function resolveBundledExtensionAliasSource(input) {
-  const normalized = input.trim().toLowerCase();
-  const packageRoot = await resolveBundledPackageRoot(normalized);
-  if (packageRoot) {
-    return packageRoot;
-  }
-  const alias = LEGACY_BUNDLED_PACKAGE_ALIASES[normalized];
-  if (!alias) {
-    return null;
-  }
-  for (const packageRoot2 of resolvePackageRootCandidates()) {
-    const legacyExtensionPath = path4.join(packageRoot2, ".agents", "pm", "extensions", alias.legacy_extension_directory);
-    if (await pathExists(path4.join(legacyExtensionPath, "manifest.json"))) {
-      return legacyExtensionPath;
-    }
-  }
-  return null;
-}
-function isBundledPackageInstallAllTarget(input) {
-  return BUNDLED_PACKAGE_INSTALL_ALL_TARGETS.has(input.trim().toLowerCase());
-}
-function derivePackageAlias(packageDirectory) {
-  return packageDirectory.replace(/^pm-/i, "").trim().toLowerCase();
-}
-async function collectBundledPackageEntries() {
-  const entriesByAlias = /* @__PURE__ */ new Map();
-  for (const packageRoot of resolvePackageRootCandidates()) {
-    const packagesRoot = path4.join(packageRoot, "packages");
-    if (!await pathExists(packagesRoot)) {
-      continue;
-    }
-    const entries = await fs4.readdir(packagesRoot, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || !entry.name.startsWith("pm-")) {
-        continue;
-      }
-      const candidateRoot = path4.join(packagesRoot, entry.name);
-      if (!await pathExists(path4.join(candidateRoot, "package.json"))) {
-        continue;
-      }
-      const manifest = await readPmPackageManifest(candidateRoot);
-      const aliases = manifest.aliases && manifest.aliases.length > 0 ? manifest.aliases : [derivePackageAlias(entry.name)];
-      for (const alias of aliases) {
-        const normalizedAlias = alias.trim().toLowerCase();
-        if (normalizedAlias.length === 0 || entriesByAlias.has(normalizedAlias)) {
-          continue;
-        }
-        entriesByAlias.set(normalizedAlias, {
-          alias: normalizedAlias,
-          package_directory: entry.name,
-          package_root: candidateRoot
-        });
-      }
-    }
-  }
-  for (const [alias, legacy] of Object.entries(LEGACY_BUNDLED_PACKAGE_ALIASES)) {
-    if (entriesByAlias.has(alias)) {
-      continue;
-    }
-    for (const packageRoot of resolvePackageRootCandidates()) {
-      const packagePath = path4.join(packageRoot, "packages", legacy.package_directory);
-      if (await pathExists(path4.join(packagePath, "package.json"))) {
-        entriesByAlias.set(alias, {
-          alias,
-          package_directory: legacy.package_directory,
-          package_root: packagePath
-        });
-        break;
-      }
-    }
-  }
-  return [...entriesByAlias.values()].sort((left, right) => left.alias.localeCompare(right.alias));
-}
-async function listBundledPackageAliases() {
-  return (await collectBundledPackageEntries()).map((entry) => entry.alias);
-}
-async function resolveBundledPackageRoot(alias) {
-  const normalized = alias.trim().toLowerCase();
-  const entry = (await collectBundledPackageEntries()).find((candidate) => candidate.alias === normalized);
-  return entry?.package_root ?? null;
-}
-async function resolveBundledPackageNpmName(alias) {
-  const packageRoot = await resolveBundledPackageRoot(alias);
-  if (!packageRoot) {
-    return null;
-  }
-  const manifest = await readPmPackageManifest(packageRoot);
-  return manifest.package_name ?? null;
-}
-async function resolveBundledAliasManifestName(input) {
-  const bundledAliasSource = await resolveBundledExtensionAliasSource(input);
-  if (!bundledAliasSource) {
-    return null;
-  }
-  try {
-    const extensionDirectories = await collectPackageExtensionDirectories(bundledAliasSource);
-    if (extensionDirectories.length !== 1) {
-      return null;
-    }
-    const validated = await validateExtensionDirectory(extensionDirectories[0]);
-    return validated.manifest.name;
-  } catch {
-    return null;
-  }
-}
-function buildBundledCatalogLinks(manifest) {
-  return {
-    docs: manifest.catalog?.links?.docs ?? manifest.package_homepage,
-    npm: manifest.catalog?.links?.npm ?? (manifest.package_name && manifest.package_private !== true ? `https://www.npmjs.com/package/${encodeURIComponent(manifest.package_name)}` : void 0),
-    repository: manifest.catalog?.links?.repository ?? manifest.package_repository_url,
-    report: manifest.catalog?.links?.report ?? manifest.package_bugs_url
-  };
-}
-function buildBundledCatalogPackageEntry(manifest, bundledEntry, scope, installedBuiltinAliases, installedLocations) {
-  const installScopeFlag = scope === "global" ? "--global" : "--project";
-  const metadataOnlyResources = Object.fromEntries(PM_PACKAGE_RESOURCE_KINDS.filter((resourceKind) => resourceKind !== "extensions").map((resourceKind) => [resourceKind, manifest.resources[resourceKind] ?? []]).filter(([, entries]) => Array.isArray(entries) && entries.length > 0));
-  return {
-    alias: bundledEntry.alias,
-    bundled: true,
-    available: true,
-    installed: installedBuiltinAliases.has(bundledEntry.alias) || installedLocations.has(path4.resolve(bundledEntry.package_root)),
-    install_target: bundledEntry.alias,
-    install_command: `pm install ${bundledEntry.alias} ${installScopeFlag}`,
-    package_name: manifest.package_name,
-    package_version: manifest.package_version,
-    description: manifest.catalog?.summary ?? manifest.package_description,
-    keywords: manifest.package_keywords ?? [],
-    resources: manifest.resources,
-    installable_resources: {
-      extensions: manifest.resources.extensions ?? []
-    },
-    metadata_only_resources: metadataOnlyResources,
-    catalog: {
-      display_name: manifest.catalog?.display_name,
-      category: manifest.catalog?.category,
-      tags: manifest.catalog?.tags ?? manifest.package_keywords ?? [],
-      links: buildBundledCatalogLinks(manifest),
-      media: manifest.catalog?.media
-    }
-  };
-}
-async function buildBundledPackageCatalog(scope, global, options = {}) {
-  const roots = resolveExtensionRoots(resolvePmRoot(process.cwd(), global.path), process.cwd());
-  const selectedRoot = scope === "global" ? roots.global : roots.project;
-  const managedStateRead = await readManagedExtensionState(selectedRoot);
-  const installedLocations = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope).filter((entry) => entry.source.kind !== "builtin").map((entry) => path4.resolve(entry.source.location)));
-  const installedBuiltinAliases = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope && entry.source.kind === "builtin").flatMap((entry) => [entry.source.name, entry.source.input, entry.source.location]).filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim().toLowerCase()));
-  const packages = [];
-  for (const bundledEntry of await collectBundledPackageEntries()) {
-    const manifest = await readPmPackageManifest(bundledEntry.package_root);
-    packages.push(buildBundledCatalogPackageEntry(manifest, bundledEntry, scope, installedBuiltinAliases, installedLocations));
-  }
-  const fields = parsePackageCatalogFields(options.fields);
-  const outputPackages = fields ? packages.map((entry) => projectPackageCatalogEntry(entry, fields)) : packages;
-  return {
-    total: outputPackages.length,
-    scope,
-    installable_resource_kinds: ["extensions"],
-    metadata_only_resource_kinds: PM_PACKAGE_RESOURCE_KINDS.filter((resourceKind) => resourceKind !== "extensions"),
-    packages: outputPackages
-  };
-}
-var PACKAGE_CATALOG_FIELD_KEYS = /* @__PURE__ */ new Set([
-  "alias",
-  "bundled",
-  "available",
-  "installed",
-  "install_target",
-  "install_command",
-  "package_name",
-  "package_version",
-  "description",
-  "keywords",
-  "resources",
-  "installable_resources",
-  "metadata_only_resources",
-  "catalog",
-  "category",
-  "display_name"
-]);
-function parsePackageCatalogFields(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  const fields = splitCommaList(raw);
-  if (fields.length === 0) {
-    throw new PmCliError("Package catalog --fields requires a comma-separated list of field names", EXIT_CODE.USAGE);
-  }
-  const unknown = fields.filter((field) => !PACKAGE_CATALOG_FIELD_KEYS.has(field));
-  if (unknown.length > 0) {
-    throw new PmCliError(`Unknown package catalog --fields value(s): ${unknown.join(", ")}`, EXIT_CODE.USAGE, {
-      examples: [
-        "pm package list --project --fields alias,installed,install_command",
-        "pm package catalog --project --fields alias,package_name,category"
-      ]
-    });
-  }
-  return fields;
-}
-function projectPackageCatalogEntry(entry, fields) {
-  const projected = {};
-  for (const field of fields) {
-    if (field === "category") {
-      projected[field] = entry.catalog?.category ?? null;
-    } else if (field === "display_name") {
-      projected[field] = entry.catalog?.display_name ?? null;
-    } else {
-      projected[field] = entry[field] ?? null;
-    }
-  }
-  return projected;
-}
-
-// dist/cli/commands/extension/doctor.js
-function addRuntimePath(pathsByExtension, extensionName, pathValue) {
-  const normalizedName = normalizeExtensionNameForMatch(extensionName);
-  const normalizedPath = pathValue.trim();
-  if (normalizedName.length === 0 || normalizedPath.length === 0) {
-    return;
-  }
-  const existing = pathsByExtension.get(normalizedName) ?? /* @__PURE__ */ new Set();
-  existing.add(normalizedPath);
-  pathsByExtension.set(normalizedName, existing);
-}
-function collectRuntimeActivationPaths(activationResult) {
-  const commandPathsByExtension = /* @__PURE__ */ new Map();
-  const actionPathsByExtension = /* @__PURE__ */ new Map();
-  for (const registration of activationResult.registrations.commands) {
-    addRuntimePath(commandPathsByExtension, registration.name, registration.command);
-    addRuntimePath(actionPathsByExtension, registration.name, registration.action);
-  }
-  for (const handler of activationResult.commands.handlers) {
-    addRuntimePath(commandPathsByExtension, handler.name, handler.command);
-  }
-  for (const override of activationResult.commands.overrides) {
-    addRuntimePath(commandPathsByExtension, override.name, override.command);
-  }
-  return { commandPathsByExtension, actionPathsByExtension };
-}
-function sortedRuntimePaths(values) {
-  if (!values || values.size === 0) {
-    return void 0;
-  }
-  return [...values].sort((left, right) => left.localeCompare(right));
-}
-function resolveDoctorActivationStatus(params) {
-  const { enabled, normalizedName, loadedNames, loadFailedNames, activationFailedNames } = params;
-  if (!enabled) {
-    return { runtime_active: false, activation_status: "not_loaded" };
-  }
-  if (loadFailedNames.has(normalizedName) || activationFailedNames.has(normalizedName)) {
-    return { runtime_active: false, activation_status: "failed" };
-  }
-  if (loadedNames.has(normalizedName)) {
-    return { runtime_active: true, activation_status: "ok" };
-  }
-  return { runtime_active: false, activation_status: "not_loaded" };
-}
-function applyDoctorRuntimeActivationState(extensions, loadResult, activationResult) {
-  const loadedNames = new Set(loadResult.loaded.map((entry) => normalizeExtensionNameForMatch(entry.name)));
-  const loadFailedNames = new Set(loadResult.failed.map((entry) => normalizeExtensionNameForMatch(entry.name)));
-  const activationFailedNames = new Set(activationResult.failed.map((entry) => normalizeExtensionNameForMatch(entry.name)));
-  const { commandPathsByExtension, actionPathsByExtension } = collectRuntimeActivationPaths(activationResult);
-  return extensions.map((entry) => {
-    const normalizedName = normalizeExtensionNameForMatch(entry.name);
-    const commandPaths = sortedRuntimePaths(commandPathsByExtension.get(normalizedName));
-    const actionPaths = sortedRuntimePaths(actionPathsByExtension.get(normalizedName));
-    const runtimeMetadata = {
-      ...commandPaths ? { command_paths: commandPaths } : {},
-      ...actionPaths ? { action_paths: actionPaths } : {}
-    };
-    const activationStatus = resolveDoctorActivationStatus({
-      enabled: entry.enabled,
-      normalizedName,
-      loadedNames,
-      loadFailedNames,
-      activationFailedNames
-    });
-    return {
-      ...entry,
-      ...activationStatus,
-      ...runtimeMetadata
-    };
-  });
-}
-function summarizePolicyWarnings(warnings) {
-  let warningCount = 0;
-  let violationCount = 0;
-  let blockedCount = 0;
-  for (const warning of warnings) {
-    if (!warning.startsWith("extension_policy_")) {
-      continue;
-    }
-    warningCount += 1;
-    if (warning.startsWith("extension_policy_violation_")) {
-      violationCount += 1;
-      continue;
-    }
-    if (warning.startsWith("extension_policy_blocked_")) {
-      blockedCount += 1;
-    }
-  }
-  return {
-    warning_count: warningCount,
-    violation_count: violationCount,
-    blocked_count: blockedCount
-  };
-}
-function lifecycleFlagCommand(options, action) {
-  return options.vocabulary === "package" ? `pm package --${action}` : `pm extension --${action}`;
-}
-var REGISTRATION_COLLISION_WARNING_CODES = /* @__PURE__ */ new Set([
-  "extension_command_handler_collision",
-  "extension_command_override_collision",
-  "extension_command_override_handler_overlap",
-  "extension_parser_override_collision",
-  "extension_preflight_override_collision",
-  "extension_renderer_collision",
-  "extension_service_override_collision"
-]);
-function isRegistrationCollisionWarning(warning) {
-  return REGISTRATION_COLLISION_WARNING_CODES.has(warningCode(warning));
-}
-function isExtensionLayer(value) {
-  return value === "project" || value === "global";
-}
-function parseRegistrationCollisionWarning(warning) {
-  const parts = warning.split(":");
-  const code = parts[0];
-  if (!code || !REGISTRATION_COLLISION_WARNING_CODES.has(code)) {
-    return null;
-  }
-  const winnerLayer = parts.at(-4);
-  const winnerName = parts.at(-3)?.trim();
-  const displacedLayer = parts.at(-2);
-  const displacedName = parts.at(-1)?.trim();
-  if (!isExtensionLayer(winnerLayer) || !isExtensionLayer(displacedLayer) || !winnerName || !displacedName) {
-    return null;
-  }
-  return {
-    code,
-    surface: parts.slice(1, -4).join(":") || "global",
-    winner: { layer: winnerLayer, name: winnerName },
-    displaced: { layer: displacedLayer, name: displacedName }
-  };
-}
-function collectRegistrationCollisionExtensionNames(warnings) {
-  const names = /* @__PURE__ */ new Set();
-  for (const warning of warnings) {
-    const parsed = parseRegistrationCollisionWarning(warning);
-    if (!parsed) {
-      continue;
-    }
-    names.add(parsed.winner.name);
-    names.add(parsed.displaced.name);
-  }
-  return [...names].sort((left, right) => left.localeCompare(right));
-}
-function buildRegistrationCollisionRemediation(warnings, commands) {
-  const registrationCollisionWarnings = warnings.filter(isRegistrationCollisionWarning);
-  if (registrationCollisionWarnings.length === 0) {
-    return null;
-  }
-  const collisionNames = collectRegistrationCollisionExtensionNames(registrationCollisionWarnings);
-  const collisionNameText = collisionNames.length > 0 ? ` Conflicting extensions: ${collisionNames.join(", ")}.` : "";
-  return `Extension registration collisions or handler/override overlaps detected.${collisionNameText} Single-winner surfaces can hide earlier package behavior. Deactivate one conflicting package with ${commands.deactivate}, or scope registration surfaces in extensions.policy.extension_overrides, then rerun ${commands.doctor}.`;
-}
-function buildRegistrationCollisionPlan(scope, warnings, extensions, options) {
-  const collisions = warnings.map((warning) => parseRegistrationCollisionWarning(warning)).filter((entry) => entry !== null).sort((left, right) => `${left.code}:${left.surface}:${left.winner.name}:${left.displaced.name}`.localeCompare(`${right.code}:${right.surface}:${right.winner.name}:${right.displaced.name}`));
-  if (collisions.length === 0) {
-    return void 0;
-  }
-  const scopeFlag = scope === "global" ? "--global" : "--project";
-  const deactivatePrefix = lifecycleFlagCommand(options, "deactivate");
-  const doctorCommand = `${lifecycleFlagCommand(options, "doctor")} ${scopeFlag} --detail deep --trace`;
-  const extensionByName = new Map(extensions.map((entry) => [normalizeExtensionNameForMatch(entry.name), entry]));
-  const affectedByName = /* @__PURE__ */ new Map();
-  for (const collision of collisions) {
-    for (const name of [collision.winner.name, collision.displaced.name]) {
-      const normalizedName = normalizeExtensionNameForMatch(name);
-      affectedByName.set(normalizedName, (affectedByName.get(normalizedName) ?? 0) + 1);
-    }
-  }
-  const remediationCandidates = [...affectedByName.entries()].map(([normalizedName, affectedCollisions]) => {
-    const extension = extensionByName.get(normalizedName);
-    const extensionName = extension?.name ?? normalizedName;
-    const commandPaths = extension?.command_paths ?? [];
-    const actionPaths = extension?.action_paths ?? [];
-    return {
-      action: "deactivate",
-      extension: extensionName,
-      command: `${deactivatePrefix} ${extensionName} ${scopeFlag}`,
-      affected_collisions: affectedCollisions,
-      feature_loss: {
-        command_paths: [...commandPaths].sort((left, right) => left.localeCompare(right)),
-        action_paths: [...actionPaths].sort((left, right) => left.localeCompare(right))
-      }
-    };
-  }).sort((left, right) => {
-    const affectedDelta = right.affected_collisions - left.affected_collisions;
-    if (affectedDelta !== 0) {
-      return affectedDelta;
-    }
-    const leftSurfaceCount = left.feature_loss.command_paths.length + left.feature_loss.action_paths.length;
-    const rightSurfaceCount = right.feature_loss.command_paths.length + right.feature_loss.action_paths.length;
-    if (leftSurfaceCount !== rightSurfaceCount) {
-      return leftSurfaceCount - rightSurfaceCount;
-    }
-    return left.extension.localeCompare(right.extension);
-  });
-  return {
-    status: "conflicts_detected",
-    collision_count: collisions.length,
-    extension_count: affectedByName.size,
-    next_best_command: doctorCommand,
-    collisions,
-    remediation_candidates: remediationCandidates
-  };
-}
-function classifyDoctorLoadFailureWarnings(loadFailures) {
-  const warnings = [];
-  for (const failure of loadFailures) {
-    const normalizedError = failure.error.toLowerCase();
-    if (normalizedError.includes("cannot find package '@unbrained/pm-cli'") || normalizedError.includes('cannot find module "@unbrained/pm-cli"') || normalizedError.includes("cannot find module '@unbrained/pm-cli'")) {
-      warnings.push(`extension_load_failed_sdk_dependency_missing:${failure.name}`);
-    }
-    if (normalizedError.includes("cannot use import statement outside a module") || normalizedError.includes("to load an es module") || normalizedError.includes("must use import to load es module")) {
-      warnings.push(`extension_load_failed_module_mode_mismatch:${failure.name}`);
-    }
-  }
-  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
-}
-function classifyDoctorActivationFailureWarnings(activationFailures = []) {
-  const failures = Array.isArray(activationFailures) ? activationFailures : [];
-  const warnings = [];
-  for (const failure of failures) {
-    if (!failure || typeof failure.name !== "string") {
-      continue;
-    }
-    const missingCapability = failure.trace?.missing_capability ?? failure.trace?.capability;
-    if (typeof missingCapability === "string" && missingCapability.trim().length > 0) {
-      warnings.push(`extension_capability_missing:${failure.name}:${missingCapability.trim().toLowerCase()}`);
-    }
-  }
-  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
-}
-function classifyUnusedCapabilityWarnings(loadResult, activationResult) {
-  const warnings = [];
-  for (const entry of reconcileExtensionCapabilityUsage(loadResult.loaded, activationResult)) {
-    for (const capability of entry.unused) {
-      warnings.push(`extension_capability_unused:${entry.layer}:${entry.name}:${capability}`);
-    }
-  }
-  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
-}
-var TRIAGE_REMEDIATION_RULES = [
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_manifest_")),
-    build: (ctx) => `Run ${lifecycleFlagCommand(ctx.options, "explore")} ${ctx.scopeFlag} to inspect discovered manifests and directories.`
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_capability_unknown:")),
-    build: () => `Unknown extension capabilities detected. Allowed capabilities: ${KNOWN_EXTENSION_CAPABILITIES.join(", ")}. Review extension_capability_unknown warning details for suggested replacements.`
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_capability_legacy_alias:")),
-    build: () => "Legacy extension capability aliases were auto-remapped to canonical capabilities. Update manifests to canonical names (migration/validation -> schema)."
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_capability_missing:")),
-    build: (ctx) => `Extension activation failed because code registered a surface missing from manifest capabilities. Run ${lifecycleFlagCommand(ctx.options, "doctor")} ${ctx.scopeFlag} --detail deep --trace and add the reported missing_capability to manifest.json before publishing.`
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_capability_unused:")),
-    build: (ctx) => `Extension manifests declare capabilities that are never registered against. Remove each reported unused capability from manifest.json to keep least privilege, or add the matching registration. Run ${lifecycleFlagCommand(ctx.options, "doctor")} ${ctx.scopeFlag} --detail deep --trace for per-extension registration counts.`
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_command_definition_legacy_handler_alias:")),
-    build: () => "Extension command definitions using legacy handler were auto-remapped. Update command definitions to use run: (context) => ... for forward compatibility."
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_output_service_override_global:") || warning.startsWith("extension_output_renderer_override_global:")),
-    build: () => "Global output service/renderer overrides are active. For output_format, return context.payload/null/undefined unless the extension owns the command. For renderers, return null for unrelated payloads so pm falls back to native rendering."
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_schema_narrow_activation:")),
-    build: () => "A package registers custom item types/fields (a GLOBAL schema contribution) but also declares narrow activation.commands, so it never activates for built-in commands like pm create <type> and the custom type silently fails to register. Remove activation.commands from manifest.json so pm activates the package for every command, or \u2014 if the schema is intentionally command-scoped \u2014 knowingly ignore this advisory."
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_load_failed_sdk_dependency_missing:")),
-    build: (ctx) => `Detected extension load failures caused by missing SDK dependency resolution. Ensure extension package dependencies include "@unbrained/pm-cli" and reinstall dependencies before running ${lifecycleFlagCommand(ctx.options, "doctor")} ${ctx.scopeFlag}.`
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_load_failed_module_mode_mismatch:")),
-    build: (ctx) => `Detected extension module-mode mismatches. For ESM-based extension entries/imports, set package.json "type": "module" or use an explicit .mjs entry and rerun ${lifecycleFlagCommand(ctx.options, "doctor")} ${ctx.scopeFlag}.`
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_pm_min_version_") || warning.startsWith("extension_pm_max_version_")),
-    build: (ctx) => `Extension pm version-bound warnings detected. Align each package manifest's pm_min_version/pm_max_version with the installed pm CLI version (see the warning's required/allowed=...:current=... details), or upgrade/downgrade the pm CLI to satisfy the declared bounds, then rerun ${lifecycleFlagCommand(ctx.options, "doctor")} ${ctx.scopeFlag}.`
-  },
-  {
-    matches: (_warnings, ctx) => ctx.updateCheckFailedTotal > 0,
-    build: (ctx) => `Run ${lifecycleFlagCommand(ctx.options, "manage")} ${ctx.scopeFlag} after validating network and repository access.`
-  },
-  {
-    matches: (warnings) => warnings.some((warning) => warning.startsWith("extension_manager_state_")),
-    build: (ctx) => `Review and repair ${ctx.scope} managed extension state file if schema/read warnings persist.`
-  },
-  {
-    matches: (_warnings, ctx) => ctx.policyWarningCount > 0,
-    build: () => "Extension governance policy warnings detected. Review settings.extensions.policy mode and allow/block lists to confirm intended capabilities and registration surfaces."
-  }
-];
-function buildExtensionTriageRemediation(params) {
-  const { normalizedWarnings, options, scope, scopeFlag, updateCheckFailedTotal, policyWarningCount, updateHealthPartial, skippedUnmanagedTotal, skippedNonGithubTotal, updateAvailableTotal } = params;
-  const remediation = [];
-  const ctx = { options, scope, scopeFlag, updateCheckFailedTotal, policyWarningCount };
-  if (normalizedWarnings.length > 0) {
-    const registrationCollisionRemediation = buildRegistrationCollisionRemediation(normalizedWarnings, {
-      deactivate: `${lifecycleFlagCommand(options, "deactivate")} <name> ${scopeFlag}`,
-      doctor: `${lifecycleFlagCommand(options, "doctor")} ${scopeFlag} --detail deep --trace`
-    });
-    if (registrationCollisionRemediation) {
-      remediation.push(registrationCollisionRemediation);
-    }
-    for (const rule of TRIAGE_REMEDIATION_RULES) {
-      if (rule.matches(normalizedWarnings, ctx)) {
-        remediation.push(rule.build(ctx));
-      }
-    }
-  }
-  if (updateHealthPartial) {
-    remediation.push(`Update-check coverage is partial because unmanaged extensions need adoption. Adopt existing installs via ${lifecycleFlagCommand(options, "manage")} ${scopeFlag} --fix-managed-state (or ${lifecycleFlagCommand(options, "adopt-all")} ${scopeFlag}, ${lifecycleFlagCommand(options, "adopt")} <name> ${scopeFlag}, or reinstall via ${lifecycleFlagCommand(options, "install")} ${scopeFlag} <source>).`);
-  } else if (skippedUnmanagedTotal > 0) {
-    remediation.push(`Loaded unmanaged extensions are currently treated as informational. Use ${lifecycleFlagCommand(options, "manage")} ${scopeFlag} --fix-managed-state to adopt them for update checks.`);
-  }
-  if (skippedNonGithubTotal > 0) {
-    remediation.push(`Non-GitHub managed extensions are skipped by update checks. Use doctor output for non-update diagnostics.`);
-  }
-  if (updateAvailableTotal > 0) {
-    remediation.push(`Update available managed extensions via ${lifecycleFlagCommand(options, "install")} ${scopeFlag} <source>.`);
-  }
-  if (remediation.length === 0) {
-    remediation.push(`No immediate action required. Re-run ${lifecycleFlagCommand(options, "manage")} ${scopeFlag} after extension changes.`);
-  }
-  return remediation;
-}
-function buildExtensionTriageSummary(scope, warnings, extensions, options = {}) {
-  const normalizedWarnings = [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
-  const managedTotal = extensions.filter((entry) => entry.managed).length;
-  const enabledTotal = extensions.filter((entry) => entry.enabled).length;
-  const activeTotal = extensions.filter((entry) => entry.active).length;
-  const updateAvailableTotal = extensions.filter((entry) => entry.update_available === true).length;
-  const unmanagedExtensions = extensions.filter((entry) => entry.managed === false);
-  const unmanagedExpectedExtensions = unmanagedExtensions.filter((entry) => isExpectedUnmanagedExtension(entry)).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
-  const unmanagedActionRequiredExtensions = unmanagedExtensions.filter((entry) => !isExpectedUnmanagedExtension(entry)).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
-  const updateCheckStatusTotals = {
-    checked: 0,
-    skipped_unmanaged: 0,
-    skipped_non_github: 0,
-    failed: 0,
-    not_checked: 0
-  };
-  for (const entry of extensions) {
-    updateCheckStatusTotals[entry.update_check_status] += 1;
-  }
-  const updateCheckFailedTotal = updateCheckStatusTotals.failed;
-  const skippedUnmanagedTotal = updateCheckStatusTotals.skipped_unmanaged;
-  const skippedNonGithubTotal = updateCheckStatusTotals.skipped_non_github;
-  const updateHealthPartial = unmanagedActionRequiredExtensions.length > 0;
-  const updateHealthCoverage = updateHealthPartial ? "partial" : "full";
-  const partialCoverageWarnings = updateHealthPartial ? [`extension_update_health_partial_coverage:skipped_unmanaged:${unmanagedActionRequiredExtensions.length}`] : [];
-  const effectiveWarnings = [.../* @__PURE__ */ new Set([...normalizedWarnings, ...partialCoverageWarnings])].sort((left, right) => left.localeCompare(right));
-  const warningCodes = [...new Set(effectiveWarnings.map((value) => warningCode(value)))].sort((left, right) => left.localeCompare(right));
-  const policyWarnings = summarizePolicyWarnings(effectiveWarnings);
-  const scopeFlag = scope === "global" ? "--global" : "--project";
-  const collisionPlan = buildRegistrationCollisionPlan(scope, normalizedWarnings, extensions, options);
-  const remediation = buildExtensionTriageRemediation({
-    normalizedWarnings,
-    options,
-    scope,
-    scopeFlag,
-    updateCheckFailedTotal,
-    policyWarningCount: policyWarnings.warning_count,
-    updateHealthPartial,
-    skippedUnmanagedTotal,
-    skippedNonGithubTotal,
-    updateAvailableTotal
-  });
-  return {
-    status: effectiveWarnings.length === 0 ? "ok" : "warn",
-    warning_count: effectiveWarnings.length,
-    warning_codes: warningCodes,
-    warnings: effectiveWarnings,
-    policy_warning_count: policyWarnings.warning_count,
-    policy_violation_count: policyWarnings.violation_count,
-    policy_blocked_count: policyWarnings.blocked_count,
-    total_extensions: extensions.length,
-    managed_total: managedTotal,
-    enabled_total: enabledTotal,
-    active_total: activeTotal,
-    update_available_total: updateAvailableTotal,
-    update_health_coverage: updateHealthCoverage,
-    update_health_partial: updateHealthPartial,
-    unmanaged_loaded_extension_count: unmanagedExtensions.length,
-    unmanaged_loaded_extensions: unmanagedExtensions.map((entry) => entry.name).sort((left, right) => left.localeCompare(right)),
-    unmanaged_expected_extension_count: unmanagedExpectedExtensions.length,
-    unmanaged_expected_extensions: unmanagedExpectedExtensions,
-    unmanaged_action_required_extension_count: unmanagedActionRequiredExtensions.length,
-    unmanaged_action_required_extensions: unmanagedActionRequiredExtensions,
-    update_check_status_totals: updateCheckStatusTotals,
-    update_check_failed_total: updateCheckFailedTotal,
-    top_warnings: effectiveWarnings.slice(0, 8),
-    remediation,
-    ...collisionPlan ? { collision_plan: collisionPlan } : {}
-  };
-}
-function parseDoctorDetailMode(raw) {
-  if (!raw || raw.trim().length === 0) {
-    return "summary";
-  }
-  const normalized = raw.trim().toLowerCase();
-  if (normalized === "summary" || normalized === "deep") {
-    return normalized;
-  }
-  throw new PmCliError(`Invalid --detail value "${raw}". Expected summary or deep.`, EXIT_CODE.USAGE);
-}
-function warningCode(value) {
-  const normalized = value.trim();
-  const separator = normalized.indexOf(":");
-  if (separator === -1) {
-    return normalized;
-  }
-  return normalized.slice(0, separator);
-}
-function collectUnknownCapabilityGuidance(warnings) {
-  const seen = /* @__PURE__ */ new Set();
-  const guidance = [];
-  for (const warning of warnings) {
-    const parsedDetails = (() => {
-      const unknownWarning = parseUnknownExtensionCapabilityWarning(warning);
-      if (unknownWarning) {
-        return [unknownWarning];
-      }
-      return parseLegacyExtensionCapabilityAliasWarning(warning);
-    })();
-    for (const parsed of parsedDetails) {
-      const key = `${parsed.layer}:${parsed.name}:${parsed.capability}`;
-      if (seen.has(key)) {
-        continue;
-      }
-      seen.add(key);
-      guidance.push(parsed);
-    }
-  }
-  return guidance;
-}
-function buildCapabilityContractMetadata() {
-  return {
-    version: EXTENSION_CAPABILITY_CONTRACT.version,
-    capabilities: [...EXTENSION_CAPABILITY_CONTRACT.capabilities],
-    legacy_aliases: { ...EXTENSION_CAPABILITY_CONTRACT.legacy_aliases }
-  };
-}
-function isExpectedUnmanagedExtension(entry) {
-  const normalizedName = normalizeExtensionNameForMatch(entry.name);
-  const normalizedDirectory = normalizeExtensionNameForMatch(entry.directory);
-  if (normalizedName.startsWith("builtin-")) {
-    return true;
-  }
-  return normalizedDirectory === "beads" || normalizedDirectory === "todos";
-}
-function buildDoctorConsistencySummary(scope, installedExtensions, loadedExtensions, failedLoads, disabledByFlag) {
-  if (scope !== "project" || disabledByFlag) {
-    return {
-      warnings: [],
-      summary: {
-        active_project_count: 0,
-        loaded_project_count: 0,
-        active_project_names: [],
-        loaded_project_names: [],
-        missing_active_project_names: []
-      }
-    };
-  }
-  const activeProjectNames = [
-    ...new Set(installedExtensions.filter((entry) => entry.active).map((entry) => normalizeExtensionNameForMatch(entry.name)))
-  ].sort((left, right) => left.localeCompare(right));
-  const loadedProjectNames = [
-    ...new Set(loadedExtensions.filter((entry) => entry.layer === "project").map((entry) => normalizeExtensionNameForMatch(entry.name)))
-  ].sort((left, right) => left.localeCompare(right));
-  const failedLoadNames = new Set(failedLoads.map((entry) => normalizeExtensionNameForMatch(entry.name)));
-  const missingActiveProjectNames = activeProjectNames.filter((name) => !loadedProjectNames.includes(name) && !failedLoadNames.has(name)).sort((left, right) => left.localeCompare(right));
-  const warnings = missingActiveProjectNames.length > 0 ? [`extension_doctor_consistency_active_not_loaded:${missingActiveProjectNames.join(",")}`] : [];
-  return {
-    warnings,
-    summary: {
-      active_project_count: activeProjectNames.length,
-      loaded_project_count: loadedProjectNames.length,
-      active_project_names: activeProjectNames,
-      loaded_project_names: loadedProjectNames,
-      missing_active_project_names: missingActiveProjectNames
-    }
-  };
-}
-
-// dist/cli/commands/extension.js
-var execFileAsync2 = promisify2(execFile2);
-var EXTENSION_INSTALL_COPY_ATTEMPTS = 3;
-var EXTENSION_INSTALL_LOCK_ATTEMPTS = 120;
-var EXTENSION_INSTALL_LOCK_DELAY_MS = 250;
-var EXTENSION_INSTALL_LOCK_STALE_MS = 12e4;
-var LIFECYCLE_ACTION_TARGETS = [
-  ["install", "install", "--install"],
-  ["uninstall", "uninstall", "--uninstall"],
-  ["explore", "explore", "--explore"],
-  ["list", "explore", "--explore"],
-  ["manage", "manage", "--manage"],
-  ["describe", "describe", "--describe"],
-  ["reload", "reload", "--reload"],
-  ["doctor", "doctor", "--doctor"],
-  ["catalog", "catalog", "--catalog"],
-  ["init", "init", "--init"],
-  ["scaffold", "init", "--scaffold"],
-  ["adopt", "adopt", "--adopt"],
-  ["adopt-all", "adopt-all", "--adopt-all"],
-  ["activate", "activate", "--activate"],
-  ["deactivate", "deactivate", "--deactivate"]
-];
-var LIFECYCLE_ACTION_FLAG_HINT = LIFECYCLE_ACTION_TARGETS.map(([, , flag]) => flag).filter((flag, index, flags) => flags.indexOf(flag) === index).join(", ");
-var LIFECYCLE_ACTION_FLAGS = {
-  install: "--install",
-  uninstall: "--uninstall",
-  explore: "--explore",
-  manage: "--manage",
-  describe: "--describe",
-  reload: "--reload",
-  doctor: "--doctor",
-  catalog: "--catalog",
-  adopt: "--adopt",
-  "adopt-all": "--adopt-all",
-  activate: "--activate",
-  deactivate: "--deactivate",
-  init: "--init"
-};
-var NATIVE_OUTPUT_MARKER = "__pm_native_output";
-function buildExtensionPolicyDetails(policy) {
-  const overrides = (policy.extension_overrides ?? []).map((override) => ({
-    name: override.name.trim(),
-    disabled: override.disabled === true ? true : void 0,
-    require_trusted: override.require_trusted === true ? true : void 0,
-    require_provenance: override.require_provenance === true ? true : void 0,
-    sandbox_profile: override.sandbox_profile,
-    allowed_capabilities: normalizeStringList(override.allowed_capabilities ?? []),
-    blocked_capabilities: normalizeStringList(override.blocked_capabilities ?? []),
-    allowed_surfaces: normalizeStringList(override.allowed_surfaces ?? []),
-    blocked_surfaces: normalizeStringList(override.blocked_surfaces ?? []),
-    allowed_commands: normalizeStringList(override.allowed_commands ?? []),
-    blocked_commands: normalizeStringList(override.blocked_commands ?? []),
-    allowed_actions: normalizeStringList(override.allowed_actions ?? []),
-    blocked_actions: normalizeStringList(override.blocked_actions ?? []),
-    allowed_services: normalizeStringList(override.allowed_services ?? []),
-    blocked_services: normalizeStringList(override.blocked_services ?? [])
-  })).filter((override) => override.name.length > 0).sort((left, right) => left.name.localeCompare(right.name));
-  return {
-    mode: policy.mode,
-    trust_mode: policy.trust_mode,
-    require_provenance: policy.require_provenance === true,
-    trusted_extensions: normalizeStringList(policy.trusted_extensions ?? []),
-    default_sandbox_profile: policy.default_sandbox_profile ?? "none",
-    allowed_extensions: normalizeStringList(policy.allowed_extensions ?? []),
-    blocked_extensions: normalizeStringList(policy.blocked_extensions ?? []),
-    allowed_capabilities: normalizeStringList(policy.allowed_capabilities ?? []),
-    blocked_capabilities: normalizeStringList(policy.blocked_capabilities ?? []),
-    allowed_surfaces: normalizeStringList(policy.allowed_surfaces ?? []),
-    blocked_surfaces: normalizeStringList(policy.blocked_surfaces ?? []),
-    allowed_commands: normalizeStringList(policy.allowed_commands ?? []),
-    blocked_commands: normalizeStringList(policy.blocked_commands ?? []),
-    allowed_actions: normalizeStringList(policy.allowed_actions ?? []),
-    blocked_actions: normalizeStringList(policy.blocked_actions ?? []),
-    allowed_services: normalizeStringList(policy.allowed_services ?? []),
-    blocked_services: normalizeStringList(policy.blocked_services ?? []),
-    extension_overrides: overrides.map((override) => ({
-      name: override.name,
-      ...override.disabled === true ? { disabled: true } : {},
-      ...override.require_trusted === true ? { require_trusted: true } : {},
-      ...override.require_provenance === true ? { require_provenance: true } : {},
-      ...override.sandbox_profile ? { sandbox_profile: override.sandbox_profile } : {},
-      ...override.allowed_capabilities.length > 0 ? { allowed_capabilities: override.allowed_capabilities } : {},
-      ...override.blocked_capabilities.length > 0 ? { blocked_capabilities: override.blocked_capabilities } : {},
-      ...override.allowed_surfaces.length > 0 ? { allowed_surfaces: override.allowed_surfaces } : {},
-      ...override.blocked_surfaces.length > 0 ? { blocked_surfaces: override.blocked_surfaces } : {},
-      ...override.allowed_commands.length > 0 ? { allowed_commands: override.allowed_commands } : {},
-      ...override.blocked_commands.length > 0 ? { blocked_commands: override.blocked_commands } : {},
-      ...override.allowed_actions.length > 0 ? { allowed_actions: override.allowed_actions } : {},
-      ...override.blocked_actions.length > 0 ? { blocked_actions: override.blocked_actions } : {},
-      ...override.allowed_services.length > 0 ? { allowed_services: override.allowed_services } : {},
-      ...override.blocked_services.length > 0 ? { blocked_services: override.blocked_services } : {}
-    }))
-  };
-}
-function isRetriableExtensionInstallCopyError(error) {
-  if (typeof error !== "object" || error === null || !("code" in error)) {
-    return false;
-  }
-  const code = error.code;
-  return code === "EEXIST" || code === "ENOTEMPTY" || code === "ENOENT";
-}
-function isErrnoCode(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-async function ensureExtensionModuleTypeMarker(destinationDirectory) {
-  const markerPath = path5.join(destinationDirectory, "package.json");
-  if (await pathExists(markerPath)) {
-    return;
-  }
-  await fs5.writeFile(markerPath, `${JSON.stringify({ type: "module" }, null, 2)}
-`, "utf8");
-}
-async function copyExtensionDirectoryForInstall(sourceDirectory, destinationDirectory, copyDirectory = fs5.cp) {
-  for (let attempt = 1; attempt <= EXTENSION_INSTALL_COPY_ATTEMPTS; attempt += 1) {
-    try {
-      if (await pathExists(destinationDirectory)) {
-        await fs5.rm(destinationDirectory, { recursive: true, force: true });
-      }
-      await copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destinationDirectory, copyDirectory);
-      return;
-    } catch (error) {
-      if (!isRetriableExtensionInstallCopyError(error) || attempt === EXTENSION_INSTALL_COPY_ATTEMPTS) {
-        throw error;
-      }
-      await sleep(EXTENSION_INSTALL_LOCK_DELAY_MS);
-    }
-  }
-}
-async function copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destinationDirectory, copyDirectory) {
-  const resolvedSource = path5.resolve(sourceDirectory);
-  const resolvedDestination = path5.resolve(destinationDirectory);
-  if (resolvedSource === resolvedDestination) {
-    return;
-  }
-  if (!isPathWithinDirectory(resolvedSource, resolvedDestination)) {
-    await copyDirectory(sourceDirectory, destinationDirectory, { recursive: true, force: true });
-    return;
-  }
-  const stagingRoot = await fs5.mkdtemp(path5.join(os2.tmpdir(), "pm-extension-copy-"));
-  const stagedDirectory = path5.join(stagingRoot, "extension");
-  try {
-    await copyDirectory(sourceDirectory, stagedDirectory, { recursive: true, force: true });
-    await copyDirectory(stagedDirectory, destinationDirectory, { recursive: true, force: true });
-  } finally {
-    await fs5.rm(stagingRoot, { recursive: true, force: true });
-  }
-}
-async function withExtensionInstallLock(settingsRoot, destinationDirectoryName, run, options) {
-  const lockRoot = path5.join(settingsRoot, "runtime", "extension-install-locks");
-  const lockPath = path5.join(lockRoot, `${destinationDirectoryName}.lock`);
-  await fs5.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 <= attempts; attempt += 1) {
-    try {
-      await fs5.mkdir(lockPath);
-      acquired = true;
-      await fs5.writeFile(path5.join(lockPath, "owner.json"), `${JSON.stringify({ pid: process.pid, created_at: nowIso(), destination: destinationDirectoryName }, null, 2)}
-`, "utf8");
-      break;
-    } catch (error) {
-      if (!isErrnoCode(error, "EEXIST")) {
-        throw error;
-      }
-      let stat = null;
-      try {
-        stat = await fs5.stat(lockPath);
-      } catch {
-        stat = null;
-      }
-      if (stat && Date.now() - stat.mtimeMs > staleMs) {
-        await fs5.rm(lockPath, { recursive: true, force: true });
-        continue;
-      }
-      await sleep(delayMs);
-    }
-  }
-  if (!acquired) {
-    throw new PmCliError(`Timed out waiting for extension install lock for "${destinationDirectoryName}".`, EXIT_CODE.CONFLICT);
-  }
-  try {
-    return await run();
-  } finally {
-    await fs5.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
-  }
-}
-async function resolveInstalledExtensionCandidate(installed, extensionTarget) {
-  const lookupValues = [extensionTarget];
-  const bundledAliasManifestName = await resolveBundledAliasManifestName(extensionTarget);
-  if (bundledAliasManifestName) {
-    lookupValues.push(bundledAliasManifestName);
-  }
-  const normalizedLookups = [...new Set(lookupValues.map((value) => normalizeExtensionNameForMatch(value)).filter((value) => value.length > 0))];
-  for (const lookup of normalizedLookups) {
-    const byName = installed.find((entry) => normalizeExtensionNameForMatch(entry.name) === lookup);
-    if (byName) {
-      return byName;
-    }
-    const byDirectory = installed.find((entry) => normalizeExtensionNameForMatch(entry.directory) === lookup);
-    if (byDirectory) {
-      return byDirectory;
-    }
-  }
-  return void 0;
-}
-function isExtensionEnabled(settings, name) {
-  const normalizedName = name.trim();
-  const enabled = new Set(normalizeStringList(settings.extensions.enabled));
-  const disabled = new Set(normalizeStringList(settings.extensions.disabled));
-  if (disabled.has(normalizedName)) {
-    return false;
-  }
-  if (enabled.size === 0) {
-    return true;
-  }
-  return enabled.has(normalizedName);
-}
-function ensureActivated(settings, name) {
-  const normalizedName = name.trim();
-  const enabled = new Set(normalizeStringList(settings.extensions.enabled));
-  const disabled = new Set(normalizeStringList(settings.extensions.disabled));
-  const previousEnabled = [...enabled];
-  const previousDisabled = [...disabled];
-  disabled.delete(normalizedName);
-  if (enabled.size > 0) {
-    enabled.add(normalizedName);
-  }
-  settings.extensions.enabled = [...enabled].sort((left, right) => left.localeCompare(right));
-  settings.extensions.disabled = [...disabled].sort((left, right) => left.localeCompare(right));
-  return settings.extensions.enabled.join("\0") !== previousEnabled.join("\0") || settings.extensions.disabled.join("\0") !== previousDisabled.join("\0");
-}
-function ensureDeactivated(settings, name) {
-  const normalizedName = name.trim();
-  const enabled = new Set(normalizeStringList(settings.extensions.enabled));
-  const disabled = new Set(normalizeStringList(settings.extensions.disabled));
-  const previousEnabled = [...enabled];
-  const previousDisabled = [...disabled];
-  enabled.delete(normalizedName);
-  disabled.add(normalizedName);
-  settings.extensions.enabled = [...enabled].sort((left, right) => left.localeCompare(right));
-  settings.extensions.disabled = [...disabled].sort((left, right) => left.localeCompare(right));
-  return settings.extensions.enabled.join("\0") !== previousEnabled.join("\0") || settings.extensions.disabled.join("\0") !== previousDisabled.join("\0");
-}
-function clearExtensionState(settings, name) {
-  const normalizedName = name.trim();
-  const enabled = new Set(normalizeStringList(settings.extensions.enabled));
-  const disabled = new Set(normalizeStringList(settings.extensions.disabled));
-  const previousEnabled = [...enabled];
-  const previousDisabled = [...disabled];
-  enabled.delete(normalizedName);
-  disabled.delete(normalizedName);
-  settings.extensions.enabled = [...enabled].sort((left, right) => left.localeCompare(right));
-  settings.extensions.disabled = [...disabled].sort((left, right) => left.localeCompare(right));
-  return settings.extensions.enabled.join("\0") !== previousEnabled.join("\0") || settings.extensions.disabled.join("\0") !== previousDisabled.join("\0");
-}
-function suggestLifecycleActionTarget(target) {
-  const normalizedTarget = target.trim().toLowerCase();
-  const exactMatch = LIFECYCLE_ACTION_TARGETS.find(([candidate]) => candidate === normalizedTarget);
-  if (exactMatch) {
-    return { action: exactMatch[1], flag: exactMatch[2] };
-  }
-  const maxDistance = normalizedTarget.length <= 4 ? 1 : 2;
-  let nearest = null;
-  for (const [candidate, action, flag] of LIFECYCLE_ACTION_TARGETS) {
-    const distance = levenshteinDistanceWithinLimit(normalizedTarget, candidate, maxDistance);
-    if (distance === null) {
-      continue;
-    }
-    if (nearest === null) {
-      nearest = { action, flag, distance };
-      continue;
-    }
-    if (distance < nearest.distance) {
-      nearest = { action, flag, distance };
-    }
-  }
-  return nearest === null ? null : { action: nearest.action, flag: nearest.flag };
-}
-function buildUnknownLifecycleActionError(target, options) {
-  const noun = options.vocabulary === "package" ? "package" : "extension";
-  const suggestion = suggestLifecycleActionTarget(target);
-  if (!suggestion) {
-    return new PmCliError(`One action flag is required. Use one of: ${LIFECYCLE_ACTION_FLAG_HINT}. Bare \`pm package\` and \`pm extension\` default to --explore.`, EXIT_CODE.USAGE);
-  }
-  const command = `pm ${noun} ${suggestion.flag}`;
-  return new PmCliError(`Unknown ${noun} lifecycle action "${target}". Did you mean "${suggestion.flag}"?`, EXIT_CODE.USAGE, {
-    code: "unknown_lifecycle_action",
-    required: `Use one of: ${LIFECYCLE_ACTION_FLAG_HINT}.`,
-    examples: [command, `pm ${noun} --help`],
-    recovery: {
-      attempted_command: `pm ${noun} ${target}`,
-      suggested_retry: command,
-      fallback_candidates: [
-        {
-          source: "lifecycle_action",
-          command,
-          reason: `nearest lifecycle action for "${target}"`
-        }
-      ]
-    }
-  });
-}
-var EXTENSION_ACTION_FLAG_SELECTORS = [
-  ["install", "install"],
-  ["uninstall", "uninstall"],
-  ["explore", "explore"],
-  ["manage", "manage"],
-  ["describe", "describe"],
-  ["reload", "reload"],
-  ["doctor", "doctor"],
-  ["catalog", "catalog"],
-  ["init", "init"],
-  ["scaffold", "init"],
-  ["adopt", "adopt"],
-  ["adoptAll", "adopt-all"],
-  ["activate", "activate"],
-  ["deactivate", "deactivate"]
-];
-function resolveImplicitActionFromTarget(normalizedTarget) {
-  if (normalizedTarget === "doctor") {
-    return "doctor";
-  }
-  if (normalizedTarget === "reload") {
-    return "reload";
-  }
-  if (normalizedTarget === "catalog") {
-    return "catalog";
-  }
-  if (normalizedTarget === "init" || normalizedTarget === "scaffold") {
-    return "init";
-  }
-  if (normalizedTarget === "explore") {
-    return "explore";
-  }
-  if (normalizedTarget === "manage") {
-    return "manage";
-  }
-  if (normalizedTarget === "list" || normalizedTarget === "") {
-    return "explore";
-  }
-  return null;
-}
-function resolveAction(target, options) {
-  const selected = [
-    ...new Set(EXTENSION_ACTION_FLAG_SELECTORS.filter(([flag]) => options[flag] === true).map(([, mappedAction]) => mappedAction))
-  ];
-  if (selected.length === 0) {
-    if (target === void 0) {
-      return "explore";
-    }
-    const implicitAction = resolveImplicitActionFromTarget(target.trim().toLowerCase());
-    if (implicitAction) {
-      return implicitAction;
-    }
-    throw buildUnknownLifecycleActionError(target, options);
-  }
-  if (selected.length > 1) {
-    throw new PmCliError("Extension action flags are mutually exclusive.", EXIT_CODE.USAGE);
-  }
-  return selected[0];
-}
-function resolveScope(options) {
-  const projectLike = options.project === true || options.local === true;
-  const global = options.global === true;
-  if (projectLike && global) {
-    throw new PmCliError('Options "--project/--local" and "--global" are mutually exclusive.', EXIT_CODE.USAGE);
-  }
-  return global ? "global" : "project";
-}
-function resolveUpdateCheckResolution(managedEntry) {
-  if (!managedEntry) {
-    return {
-      status: "skipped_unmanaged",
-      reason: "extension_not_managed"
-    };
-  }
-  if (managedEntry.source.kind !== "github") {
-    return {
-      status: "skipped_non_github",
-      reason: `managed_source_kind_${managedEntry.source.kind}`
-    };
-  }
-  const updateError = typeof managedEntry.update_error === "string" ? managedEntry.update_error.trim() : "";
-  if (updateError.length > 0) {
-    return {
-      status: "failed",
-      reason: updateError
-    };
-  }
-  if (typeof managedEntry.last_update_check_at === "string" && managedEntry.last_update_check_at.trim().length > 0) {
-    if (managedEntry.update_available === true) {
-      return {
-        status: "checked",
-        reason: "update_available"
-      };
-    }
-    if (managedEntry.update_available === false) {
-      return {
-        status: "checked",
-        reason: "up_to_date"
-      };
-    }
-    return {
-      status: "checked",
-      reason: "checked_without_commit_baseline"
-    };
-  }
-  return {
-    status: "not_checked",
-    reason: "no_update_check_recorded"
-  };
-}
-function buildInstalledExtensionSummary(identity, scope, managedEntry, updateCheck) {
-  return {
-    name: identity.name,
-    directory: identity.directory,
-    version: identity.version,
-    entry: identity.entry,
-    scope,
-    active: identity.enabled,
-    enabled: identity.enabled,
-    runtime_active: null,
-    activation_status: "unknown",
-    managed: Boolean(managedEntry),
-    source: managedEntry?.source,
-    update_available: managedEntry?.update_available,
-    last_update_check_at: managedEntry?.last_update_check_at,
-    last_update_remote_commit: managedEntry?.last_update_remote_commit,
-    update_error: managedEntry?.update_error,
-    update_check_status: updateCheck.status,
-    update_check_reason: updateCheck.reason
-  };
-}
-async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
-  if (!await pathExists(extensionsRoot)) {
-    return {
-      extensions: [],
-      warnings: []
-    };
-  }
-  const entries = await fs5.readdir(extensionsRoot, { withFileTypes: true });
-  const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
-  const managedByName = /* @__PURE__ */ new Map();
-  const managedByDirectory = /* @__PURE__ */ new Map();
-  for (const managedEntry of state.entries) {
-    managedByName.set(normalizeExtensionNameForMatch(managedEntry.name), managedEntry);
-    managedByDirectory.set(normalizeExtensionNameForMatch(managedEntry.directory), managedEntry);
-  }
-  const warnings = [];
-  const summaries = [];
-  for (const directoryName of directories) {
-    const extensionDirectory = path5.join(extensionsRoot, directoryName);
-    const manifestPath = path5.join(extensionDirectory, "manifest.json");
-    if (!await pathExists(manifestPath)) {
-      warnings.push(`extension_manifest_missing:${scope}:${directoryName}`);
-      const managedEntry2 = managedByDirectory.get(normalizeExtensionNameForMatch(directoryName));
-      summaries.push(buildInstalledExtensionSummary({
-        name: managedEntry2?.name ?? directoryName,
-        directory: directoryName,
-        version: managedEntry2?.manifest_version ?? "unknown",
-        entry: managedEntry2?.manifest_entry ?? "unknown",
-        enabled: managedEntry2 ? isExtensionEnabled(settings, managedEntry2.name) : false
-      }, scope, managedEntry2, resolveUpdateCheckResolution(managedEntry2)));
-      continue;
-    }
-    let rawManifest;
-    try {
-      rawManifest = JSON.parse(await fs5.readFile(manifestPath, "utf8"));
-    } catch {
-      warnings.push(`extension_manifest_invalid_json:${scope}:${directoryName}`);
-      continue;
-    }
-    const manifest = parseExtensionManifest(rawManifest);
-    if (!manifest) {
-      warnings.push(`extension_manifest_invalid:${scope}:${directoryName}`);
-      continue;
-    }
-    const managedEntry = managedByName.get(normalizeExtensionNameForMatch(manifest.name)) ?? managedByDirectory.get(normalizeExtensionNameForMatch(directoryName));
-    summaries.push(buildInstalledExtensionSummary({
-      name: manifest.name,
-      directory: directoryName,
-      version: manifest.version,
-      entry: manifest.entry,
-      enabled: isExtensionEnabled(settings, manifest.name)
-    }, scope, managedEntry, resolveUpdateCheckResolution(managedEntry)));
-  }
-  return {
-    extensions: summaries.sort((left, right) => left.name.localeCompare(right.name)),
-    warnings: warnings.sort((left, right) => left.localeCompare(right))
-  };
-}
-function summarizeRuntimeCommandPathsForExtension(extensionName, installed) {
-  const normalizedName = normalizeExtensionNameForMatch(extensionName);
-  const entry = installed.find((candidate) => normalizeExtensionNameForMatch(candidate.name) === normalizedName);
-  return {
-    command_paths: [...entry?.command_paths ?? []].sort((left, right) => left.localeCompare(right)),
-    action_paths: [...entry?.action_paths ?? []].sort((left, right) => left.localeCompare(right))
-  };
-}
-function resolveCommandDiscoveryPackageName(extensionName, source) {
-  if (typeof source.package === "string" && source.package.trim().length > 0) {
-    return source.package.trim();
-  }
-  if (source.kind === "builtin" && typeof source.name === "string" && source.name.trim().length > 0) {
-    return source.name.trim();
-  }
-  return extensionName;
-}
-function buildInstallCommandDiscovery(extensionName, source, commandSummary) {
-  const helpCommands = commandSummary.command_paths.map((commandPath) => `pm ${commandPath} --help`);
-  return {
-    package_name: resolveCommandDiscoveryPackageName(extensionName, source),
-    extension_name: extensionName,
-    command_paths: commandSummary.command_paths,
-    action_paths: commandSummary.action_paths,
-    help_commands: helpCommands,
-    next_steps: commandSummary.command_paths.length > 0 ? helpCommands : ["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 } : {}
-  } : void 0;
-  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 === void 0 || 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,
-    settings,
-    cwd: process.cwd(),
-    noExtensions: global.noExtensions === true,
-    reload_token: nextExtensionReloadToken(),
-    cache_bust: true
-  });
-  const activationResult = await activateExtensions({
-    ...loadResult,
-    loaded: loadResult.loaded
-  });
-  return {
-    installed: applyDoctorRuntimeActivationState(refreshedInstalled, loadResult, activationResult),
-    warnings: [...loadResult.warnings, ...activationResult.warnings],
-    activation_failures: collectActivationFailureDiagnostics(activationResult.failed),
-    item_type_registrations: activationResult.registrations.item_types
-  };
-}
-async function checkGithubUpdate(source, gitCommandRunner = runGitCommand) {
-  const checkedAt = nowIso();
-  if (source.kind !== "github" || !source.repository) {
-    return {
-      checked_at: checkedAt,
-      available: null,
-      error: "not_a_github_managed_source"
-    };
-  }
-  try {
-    const ref = source.ref && source.ref.trim().length > 0 ? source.ref.trim() : "HEAD";
-    const output = await gitCommandRunner(["ls-remote", source.repository, ref]);
-    const firstLine = output.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
-    if (!firstLine) {
-      return {
-        checked_at: checkedAt,
-        available: null,
-        error: "no_remote_reference_found"
-      };
-    }
-    const [remoteCommit] = firstLine.split(/\s+/);
-    if (typeof remoteCommit !== "string" || remoteCommit.length === 0) {
-      return {
-        checked_at: checkedAt,
-        available: null,
-        error: "invalid_remote_reference"
-      };
-    }
-    if (typeof source.commit === "string" && source.commit.trim().length > 0) {
-      return {
-        checked_at: checkedAt,
-        remote_commit: remoteCommit,
-        available: remoteCommit !== source.commit.trim()
-      };
-    }
-    return {
-      checked_at: checkedAt,
-      remote_commit: remoteCommit,
-      available: null,
-      error: "missing_installed_commit"
-    };
-  } catch (error) {
-    return {
-      checked_at: checkedAt,
-      available: null,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function adoptUnmanagedExtensions(extensionsRoot, scope, installedExtensions, state) {
-  const unmanagedCandidates = installedExtensions.filter((entry) => !entry.managed);
-  const sortedCandidates = [...unmanagedCandidates].sort((left, right) => {
-    const byName = left.name.localeCompare(right.name);
-    if (byName !== 0) {
-      return byName;
-    }
-    return left.directory.localeCompare(right.directory);
-  });
-  let nextState = state;
-  const adoptedEntries = [];
-  for (const candidate of sortedCandidates) {
-    const extensionDirectory = path5.join(extensionsRoot, candidate.directory);
-    const validated = await validateExtensionDirectory(extensionDirectory);
-    const now = nowIso();
-    const sourceRecord = {
-      kind: "local",
-      input: candidate.name,
-      location: extensionDirectory
-    };
-    nextState = upsertManagedEntry(nextState, {
-      name: validated.manifest.name,
-      directory: candidate.directory,
-      scope,
-      manifest_version: validated.manifest.version,
-      manifest_entry: validated.manifest.entry,
-      capabilities: [...validated.manifest.capabilities],
-      installed_at: now,
-      updated_at: now,
-      source: sourceRecord
-    });
-    adoptedEntries.push({
-      name: validated.manifest.name,
-      directory: candidate.directory,
-      version: validated.manifest.version,
-      entry: validated.manifest.entry,
-      source: sourceRecord
-    });
-  }
-  if (adoptedEntries.length > 0) {
-    await writeManagedExtensionState(extensionsRoot, nextState);
-  }
-  return {
-    state: nextState,
-    adopted_entries: adoptedEntries,
-    unmanaged_candidates: sortedCandidates,
-    already_managed_count: installedExtensions.length - unmanagedCandidates.length
-  };
-}
-function resolveExtensionRootsForScope(scope, global) {
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  const roots = resolveExtensionRoots(pmRoot, process.cwd());
-  const settingsRoot = scope === "global" ? resolveGlobalPmRoot(process.cwd()) : pmRoot;
-  const selectedRoot = scope === "global" ? roots.global : roots.project;
-  return {
-    pm_root: pmRoot,
-    scope,
-    settings_root: settingsRoot,
-    selected_root: selectedRoot,
-    roots
-  };
-}
-function resolveGithubOption(options) {
-  if (typeof options.gh === "string" && typeof options.github === "string" && options.gh.trim() !== options.github.trim()) {
-    throw new PmCliError('Options "--gh" and "--github" must match when both are provided.', EXIT_CODE.USAGE);
-  }
-  if (typeof options.gh === "string" && options.gh.trim().length > 0) {
-    return options.gh.trim();
-  }
-  if (typeof options.github === "string" && options.github.trim().length > 0) {
-    return options.github.trim();
-  }
-  return void 0;
-}
-function getLifecycleActionFlag(action) {
-  return LIFECYCLE_ACTION_FLAGS[action];
-}
-function requireTarget(target, action, options = {}) {
-  const normalized = target?.trim();
-  if (!normalized) {
-    if (action === "init") {
-      throw new PmCliError('Action "init" requires a scaffold target path (for example: pm package init ./my-package or pm extension init ./my-extension).', EXIT_CODE.USAGE);
-    }
-    const noun = options.vocabulary === "package" ? "package" : "extension";
-    const targetName = action === "install" ? "source" : "name";
-    const targetLabel = `${noun} ${targetName}`;
-    const actionFlag = getLifecycleActionFlag(action);
-    const commandTarget = `<${targetName}>`;
-    const command = `pm ${noun} ${actionFlag} ${commandTarget}`;
-    throw new PmCliError(`Action "${action}" requires ${targetLabel} input.`, EXIT_CODE.USAGE, {
-      code: "missing_lifecycle_target",
-      required: `Provide a ${targetName} target for ${action}.`,
-      examples: [`pm ${noun} ${action} ${commandTarget}`, command, `pm ${noun} --help`],
-      recovery: {
-        attempted_command: `pm ${noun} ${action}`,
-        suggested_retry: command,
-        fallback_candidates: [
-          {
-            source: "lifecycle_action",
-            command,
-            reason: `flag-form ${action} command with required ${targetName} target`
-          }
-        ]
-      }
-    });
-  }
-  return normalized;
-}
-function collectGlobalOutputOverrideDoctorWarnings(activationResult) {
-  const warnings = [];
-  for (const entry of activationResult.services.overrides) {
-    if (entry.service !== "output_format") {
-      continue;
-    }
-    warnings.push(`extension_output_service_override_global:${entry.service}:${entry.layer}:${entry.name}`);
-  }
-  for (const entry of activationResult.renderers.overrides) {
-    warnings.push(`extension_output_renderer_override_global:${entry.format}:${entry.layer}:${entry.name}`);
-  }
-  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
-}
-function collectSchemaNarrowActivationDoctorWarnings(loadResult, activationResult) {
-  const schemaContributors = /* @__PURE__ */ new Set();
-  for (const entry of activationResult.registrations.item_types) {
-    if (entry.types.length > 0) {
-      schemaContributors.add(`${entry.layer}:${normalizeExtensionNameForMatch(entry.name)}`);
-    }
-  }
-  for (const entry of activationResult.registrations.item_fields) {
-    if (entry.fields.length > 0) {
-      schemaContributors.add(`${entry.layer}:${normalizeExtensionNameForMatch(entry.name)}`);
-    }
-  }
-  const warnings = [];
-  for (const extension of loadResult.loaded) {
-    if ((extension.activation?.commands ?? []).length === 0) {
-      continue;
-    }
-    if (schemaContributors.has(`${extension.layer}:${normalizeExtensionNameForMatch(extension.name)}`)) {
-      warnings.push(`extension_schema_narrow_activation:${extension.layer}:${extension.name}`);
-    }
-  }
-  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
-}
-function assertExtensionActionOptionScope(action, options) {
-  const guards = [
-    {
-      triggered: options.strictExit === true || options.failOnWarn === true,
-      allowed: action === "doctor",
-      message: "--strict-exit and --fail-on-warn are only valid with --doctor."
-    },
-    { triggered: options.trace === true, allowed: action === "doctor", message: "--trace is only valid with --doctor." },
-    { triggered: options.watch === true, allowed: action === "reload", message: "--watch is only valid with --reload." },
-    {
-      triggered: options.runtimeProbe === true,
-      allowed: action === "manage",
-      message: "--runtime-probe is only valid with --manage."
-    },
-    {
-      triggered: options.fixManagedState === true,
-      allowed: action === "manage" || action === "doctor",
-      message: "--fix-managed-state is only valid with --manage or --doctor."
-    },
-    {
-      triggered: options.capability !== void 0,
-      allowed: action === "init",
-      message: "--capability is only valid with --init/--scaffold."
-    },
-    {
-      triggered: options.declarative === true,
-      allowed: action === "init",
-      message: "--declarative is only valid with --init/--scaffold."
-    }
-  ];
-  for (const guard of guards) {
-    if (guard.triggered && !guard.allowed) {
-      throw new PmCliError(guard.message, EXIT_CODE.USAGE);
-    }
-  }
-}
-function resolveNormalizedExtensionTarget(target, action, options) {
-  const normalizedInput = target?.trim().toLowerCase();
-  if (action === "doctor" && normalizedInput === "doctor") {
-    return void 0;
-  }
-  if (action === "reload" && normalizedInput === "reload") {
-    return void 0;
-  }
-  if (action === "catalog" && normalizedInput === "catalog") {
-    return void 0;
-  }
-  const inferredInitAlias = action === "init" && options.init !== true && options.scaffold !== true && (normalizedInput === "init" || normalizedInput === "scaffold");
-  if (inferredInitAlias) {
-    return void 0;
-  }
-  return target;
-}
-async function runExtension(target, options, global) {
-  const action = resolveAction(target, options);
-  assertExtensionActionOptionScope(action, options);
-  const normalizedTarget = resolveNormalizedExtensionTarget(target, action, options);
-  const scope = resolveScope(options);
-  const resolvedRoots = resolveExtensionRootsForScope(scope, global);
-  const warnings = [];
-  const withResult = (details) => {
-    const result = {
-      ok: true,
-      action,
-      scope,
-      roots: action === "catalog" && typeof options.fields === "string" && options.fields.trim().length > 0 ? {
-        project: "project",
-        global: "global",
-        selected: scope,
-        settings_root: "project"
-      } : {
-        project: resolvedRoots.roots.project,
-        global: resolvedRoots.roots.global,
-        selected: resolvedRoots.selected_root,
-        settings_root: resolvedRoots.settings_root
-      },
-      warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-      details
-    };
-    if (action === "doctor") {
-      Object.defineProperty(result, NATIVE_OUTPUT_MARKER, {
-        value: true,
-        enumerable: false,
-        configurable: false
-      });
-    }
-    return result;
-  };
-  const ctx = {
-    action,
-    normalizedTarget,
-    scope,
-    resolvedRoots,
-    warnings,
-    options,
-    global,
-    withResult
-  };
-  return EXTENSION_ACTION_HANDLERS[action](ctx);
-}
-async function runExtensionInitAction(ctx) {
-  const { action, normalizedTarget, options, withResult } = ctx;
-  const githubOption = resolveGithubOption(options);
-  if (githubOption !== void 0 || typeof options.ref === "string" && options.ref.trim().length > 0) {
-    throw new PmCliError('Action "init" does not accept --gh/--github/--ref options.', EXIT_CODE.USAGE);
-  }
-  const scaffoldTarget = requireTarget(normalizedTarget, action, options);
-  const scaffold = await scaffoldExtensionProject(scaffoldTarget, options.vocabulary ?? "extension", options.capability, options.declarative === true);
-  const quotedTargetPath = JSON.stringify(scaffold.target_path);
-  const quotedShellTargetPath = JSON.stringify(scaffold.target_path.replace(/\\/g, "/"));
-  return withResult({
-    scaffolded: scaffold.created_directory || scaffold.files.some((entry) => entry.status === "created"),
-    extension: {
-      name: scaffold.extension_name,
-      command: scaffold.command_name
-    },
-    capability: scaffold.capability,
-    style: scaffold.style,
-    target_path: scaffold.target_path,
-    created_directory: scaffold.created_directory,
-    files: scaffold.files,
-    next_steps: [
-      // Extensions are authored AND loaded as TypeScript (ADR pm-2c28 / pm-m1uz):
-      // the manifest entry is ./index.ts and pm strips types on load (Node
-      // >=22.18), so there is no compile/build step — install dependencies, then
-      // install the scaffold directly.
-      ...options.vocabulary === "package" ? [`Install dependencies: cd ${quotedShellTargetPath}, then run "npm install"`] : [
-        `Install type-check dependencies: cd ${quotedShellTargetPath}, then run "npm install -D typescript @types/node @unbrained/pm-cli"`
-      ],
-      `Install the scaffold: ${options.vocabulary === "package" ? "pm install --project" : "pm extension --install --project"} ${quotedTargetPath}`,
-      `Smoke-test command path: pm ${scaffold.command_name}`,
-      ...options.vocabulary === "package" ? [`Validate the package: cd ${quotedShellTargetPath}, then run "npm run typecheck" and "npm test"`] : [`Type-check the source (optional): cd ${quotedShellTargetPath}, then run "npx tsc --noEmit"`],
-      `Run diagnostics: ${options.vocabulary === "package" ? "pm package doctor" : "pm extension --doctor"} --project --detail summary`
-    ]
-  });
-}
-async function runExtensionReloadAction(ctx) {
-  const { normalizedTarget, resolvedRoots, warnings, options, global, withResult } = ctx;
-  if (normalizedTarget !== void 0) {
-    throw new PmCliError('Action "reload" does not accept a target argument.', EXIT_CODE.USAGE);
-  }
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const reloadToken = nextExtensionReloadToken();
-  const reloaded = await loadExtensions({
-    pmRoot: resolvedRoots.settings_root,
-    settings,
-    cwd: process.cwd(),
-    noExtensions: global.noExtensions,
-    reload_token: reloadToken,
-    cache_bust: true
-  });
-  warnings.push(...reloaded.warnings);
-  const activation = await activateExtensions(reloaded);
-  warnings.push(...activation.warnings);
-  const details = {
-    reload: {
-      token: reloadToken,
-      cache_bust: true,
-      watch: options.watch === true
-    },
-    loaded_count: reloaded.loaded.length,
-    failed_count: reloaded.failed.length,
-    activated_count: Math.max(0, reloaded.loaded.length - activation.failed.length),
-    activation_failed_count: activation.failed.length,
-    loaded_extensions: reloaded.loaded.map((entry) => ({
-      name: entry.name,
-      layer: entry.layer,
-      version: entry.version
-    })),
-    failed_extensions: reloaded.failed.map((entry) => ({
-      name: entry.name,
-      layer: entry.layer,
-      error: entry.error
-    })),
-    activation_failures: activation.failed.map((entry) => ({
-      name: entry.name,
-      layer: entry.layer,
-      error: entry.error
-    }))
-  };
-  if (options.watch === true) {
-    warnings.push("extension_reload_watch_hint:watch_mode_requested_non_interactive_single_pass_only");
-  }
-  return withResult(details);
-}
-async function runExtensionCatalogAction(ctx) {
-  const { normalizedTarget, scope, options, global, withResult } = ctx;
-  if (typeof normalizedTarget === "string" && normalizedTarget.length > 0 && normalizedTarget !== "catalog") {
-    throw new PmCliError('Action "catalog" does not accept a package target.', EXIT_CODE.USAGE);
-  }
-  return withResult(await buildBundledPackageCatalog(scope, global, options));
-}
-function buildInstallManagedSource(bundledAliasName, bundledPackageName, installSource, resolvedSource) {
-  if (bundledAliasName) {
-    return {
-      kind: "builtin",
-      input: bundledAliasName,
-      location: bundledAliasName,
-      name: bundledAliasName,
-      ...bundledPackageName === null ? {} : { package: bundledPackageName }
-    };
-  }
-  if (installSource.kind === "local") {
-    return {
-      kind: "local",
-      input: installSource.input,
-      location: installSource.absolute_path
-    };
-  }
-  if (installSource.kind === "npm") {
-    return {
-      kind: "npm",
-      input: installSource.input,
-      location: resolvedSource.resolved_subpath ?? ".",
-      package: resolvedSource.npm_package,
-      version: resolvedSource.npm_version
-    };
-  }
-  return {
-    kind: "github",
-    input: installSource.input,
-    location: resolvedSource.resolved_subpath ?? installSource.subpath ?? ".",
-    repository: installSource.repository,
-    owner: installSource.owner,
-    repo: installSource.repo,
-    ref: installSource.ref,
-    subpath: resolvedSource.resolved_subpath ?? installSource.subpath,
-    commit: resolvedSource.commit
-  };
-}
-async function performExtensionInstallUnderLock(ctx, input) {
-  const { scope, resolvedRoots, warnings, global, withResult } = ctx;
-  const { validated, destinationDirectoryName, bundledAliasName, bundledPackageName, installSource, resolvedSource } = input;
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
-  warnings.push(...managedStateRead.warnings);
-  const destinationDirectory = path5.join(resolvedRoots.selected_root, destinationDirectoryName);
-  const destinationExists = await pathExists(destinationDirectory);
-  const installInPlace = await areDirectoriesEquivalent(validated.directory, destinationDirectory);
-  await fs5.mkdir(resolvedRoots.selected_root, { recursive: true });
-  if (!installInPlace) {
-    await copyExtensionDirectoryForInstall(validated.directory, destinationDirectory);
-  }
-  await ensureExtensionModuleTypeMarker(destinationDirectory);
-  const sourceRecord = buildInstallManagedSource(bundledAliasName, bundledPackageName, installSource, resolvedSource);
-  const now = nowIso();
-  const existingManagedEntry = managedStateRead.state.entries.find((entry) => normalizeExtensionNameForMatch(entry.name) === normalizeExtensionNameForMatch(validated.manifest.name));
-  const sourceUnchanged = existingManagedEntry !== void 0 && existingManagedEntry.manifest_version === validated.manifest.version && managedExtensionSourcesEquivalent(existingManagedEntry.source, sourceRecord);
-  const managedState = upsertManagedEntry(managedStateRead.state, {
-    name: validated.manifest.name,
-    directory: destinationDirectoryName,
-    scope,
-    manifest_version: validated.manifest.version,
-    manifest_entry: validated.manifest.entry,
-    capabilities: [...validated.manifest.capabilities],
-    installed_at: existingManagedEntry?.installed_at ?? now,
-    updated_at: sourceUnchanged ? existingManagedEntry.updated_at : now,
-    source: sourceRecord
-  });
-  await writeManagedExtensionState(resolvedRoots.selected_root, managedState);
-  const activationChanged = ensureActivated(settings, validated.manifest.name);
-  if (activationChanged) {
-    await writeSettings(resolvedRoots.settings_root, settings, "settings:write");
-  }
-  const refreshedInstalled = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedState);
-  warnings.push(...refreshedInstalled.warnings);
-  const runtimeProbe = await probeRuntimeCommandPathsForInstall(resolvedRoots.pm_root, settings, refreshedInstalled.extensions, global);
-  warnings.push(...runtimeProbe.warnings);
-  const installedItemTypeDefinitions = runtimeProbe.item_type_registrations.filter((entry) => normalizeExtensionNameForMatch(entry.name) === normalizeExtensionNameForMatch(validated.manifest.name)).flatMap((entry) => entry.types.map((type) => ({ name: type.name, folder: type.folder })));
-  if (scope === "project" && installedItemTypeDefinitions.length > 0) {
-    await ensureTypeFolderScaffold(resolvedRoots.pm_root, installedItemTypeDefinitions, warnings, "install:type-folder");
-  }
-  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,
-      version: validated.manifest.version,
-      entry: validated.manifest.entry,
-      capabilities: validated.manifest.capabilities,
-      directory: destinationDirectoryName
-    },
-    source: sourceRecord,
-    destination_path: destinationDirectory,
-    overwritten: destinationExists && !installInPlace,
-    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
-    }
-  });
-}
-async function runExtensionInstallAction(ctx) {
-  const { action, normalizedTarget, resolvedRoots, warnings, options, global, withResult } = ctx;
-  const githubOption = resolveGithubOption(options);
-  const explicitSourceInput = githubOption ?? requireTarget(normalizedTarget, action, options);
-  if (typeof githubOption !== "string" && isBundledPackageInstallAllTarget(explicitSourceInput)) {
-    if (typeof options.ref === "string" && options.ref.trim().length > 0) {
-      throw new PmCliError('Action "install all" does not accept --ref.', EXIT_CODE.USAGE);
-    }
-    const aliases = await listBundledPackageAliases();
-    const packages = [];
-    for (const alias of aliases) {
-      packages.push({
-        alias,
-        result: await runExtension(alias, { ...options, install: true }, global)
-      });
-    }
-    for (const entry of packages) {
-      warnings.push(...entry.result.warnings);
-    }
-    return withResult({
-      installed_all: true,
-      installed_count: packages.length,
-      packages: packages.map((entry) => ({
-        alias: entry.alias,
-        ok: entry.result.ok,
-        extension: entry.result.details.extension,
-        source: entry.result.details.source,
-        destination_path: entry.result.details.destination_path,
-        activated: entry.result.details.activated,
-        settings_changed: entry.result.details.settings_changed,
-        command_paths: entry.result.details.command_paths,
-        action_paths: entry.result.details.action_paths,
-        command_discovery: entry.result.details.command_discovery,
-        warnings: entry.result.warnings
-      }))
-    });
-  }
-  const bundledAliasSource = typeof githubOption === "string" ? null : await resolveBundledExtensionAliasSource(explicitSourceInput);
-  const bundledAliasName = bundledAliasSource === null ? null : explicitSourceInput.trim().toLowerCase();
-  const bundledPackageName = bundledAliasName === null ? null : await resolveBundledPackageNpmName(bundledAliasName);
-  const sourceInput = bundledAliasSource ?? explicitSourceInput;
-  const installSource = parseExtensionInstallSource(sourceInput, {
-    forceGithub: typeof githubOption === "string",
-    ref: options.ref
-  });
-  const resolvedSource = await resolveInstallSource(installSource);
-  try {
-    const validated = await validateExtensionDirectory(resolvedSource.directory);
-    const destinationDirectoryName = normalizeManagedDirectoryName(validated.manifest.name);
-    return await withExtensionInstallLock(resolvedRoots.settings_root, destinationDirectoryName, () => performExtensionInstallUnderLock(ctx, {
-      validated,
-      destinationDirectoryName,
-      bundledAliasName,
-      bundledPackageName,
-      installSource,
-      resolvedSource
-    }));
-  } finally {
-    if (resolvedSource.cleanup) {
-      await resolvedSource.cleanup();
-    }
-  }
-}
-async function runExtensionAdoptAllAction(ctx) {
-  const { normalizedTarget, scope, resolvedRoots, warnings, options, withResult } = ctx;
-  if (normalizedTarget !== void 0) {
-    throw new PmCliError('Action "adopt-all" does not accept a target argument.', EXIT_CODE.USAGE);
-  }
-  const githubOption = resolveGithubOption(options);
-  if (githubOption !== void 0 || typeof options.ref === "string" && options.ref.trim().length > 0) {
-    throw new PmCliError('Action "adopt-all" does not accept --gh/--github/--ref options.', EXIT_CODE.USAGE);
-  }
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
-  warnings.push(...managedStateRead.warnings);
-  const installed = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedStateRead.state);
-  warnings.push(...installed.warnings);
-  const adoption = await adoptUnmanagedExtensions(resolvedRoots.selected_root, scope, installed.extensions, managedStateRead.state);
-  const refreshedInstalled = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, adoption.state);
-  warnings.push(...refreshedInstalled.warnings);
-  const triage = buildExtensionTriageSummary(scope, warnings, refreshedInstalled.extensions, options);
-  warnings.push(...triage.warnings);
-  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,
-      update_check_status: refreshedEntry?.update_check_status ?? null,
-      update_check_reason: refreshedEntry?.update_check_reason ?? null
-    };
-  });
-  return withResult({
-    adopted_all: adoptedDetails.length > 0,
-    adopted_count: adoptedDetails.length,
-    already_managed_count: adoption.already_managed_count,
-    extensions: adoptedDetails,
-    triage,
-    warning_codes: triage.warning_codes,
-    update_health_partial: triage.update_health_partial,
-    update_health_coverage: triage.update_health_coverage
-  });
-}
-async function runExtensionAdoptAction(ctx) {
-  const { action, normalizedTarget, scope, resolvedRoots, warnings, options, withResult } = ctx;
-  const extensionTarget = requireTarget(normalizedTarget, action, options);
-  const githubOption = resolveGithubOption(options);
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
-  warnings.push(...managedStateRead.warnings);
-  const installed = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedStateRead.state);
-  warnings.push(...installed.warnings);
-  const candidate = await resolveInstalledExtensionCandidate(installed.extensions, extensionTarget);
-  if (!candidate) {
-    throw new PmCliError(`Installed extension "${extensionTarget}" was not found in ${scope} scope.`, EXIT_CODE.NOT_FOUND);
-  }
-  if (candidate.managed) {
-    return withResult({
-      adopted: false,
-      already_managed: true,
-      extension: {
-        name: candidate.name,
-        directory: candidate.directory
-      }
-    });
-  }
-  const extensionDirectory = path5.join(resolvedRoots.selected_root, candidate.directory);
-  const validated = await validateExtensionDirectory(extensionDirectory);
-  const now = nowIso();
-  const sourceRecord = githubOption === void 0 ? {
-    kind: "local",
-    input: extensionTarget,
-    location: extensionDirectory
-  } : (() => {
-    const parsed = parseExtensionInstallSource(githubOption, {
-      forceGithub: true,
-      ref: options.ref
-    });
-    if (parsed.kind !== "github") {
-      throw new PmCliError(`Invalid GitHub shorthand "${githubOption}".`, EXIT_CODE.USAGE);
-    }
-    return {
-      kind: "github",
-      input: parsed.input,
-      location: parsed.subpath ?? ".",
-      repository: parsed.repository,
-      owner: parsed.owner,
-      repo: parsed.repo,
-      ref: parsed.ref,
-      subpath: parsed.subpath
-    };
-  })();
-  const managedState = upsertManagedEntry(managedStateRead.state, {
-    name: validated.manifest.name,
-    directory: candidate.directory,
-    scope,
-    manifest_version: validated.manifest.version,
-    manifest_entry: validated.manifest.entry,
-    capabilities: [...validated.manifest.capabilities],
-    installed_at: now,
-    updated_at: now,
-    source: sourceRecord
-  });
-  await writeManagedExtensionState(resolvedRoots.selected_root, managedState);
-  const refreshedInstalled = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedState);
-  warnings.push(...refreshedInstalled.warnings);
-  const refreshedEntry = refreshedInstalled.extensions.find((entry) => normalizeExtensionNameForMatch(entry.name) === normalizeExtensionNameForMatch(validated.manifest.name)) ?? refreshedInstalled.extensions.find((entry) => normalizeExtensionNameForMatch(entry.directory) === normalizeExtensionNameForMatch(candidate.directory));
-  return withResult({
-    adopted: true,
-    extension: {
-      name: validated.manifest.name,
-      directory: candidate.directory,
-      version: validated.manifest.version,
-      entry: validated.manifest.entry
-    },
-    source: sourceRecord,
-    update_check_status: refreshedEntry?.update_check_status ?? null,
-    update_check_reason: refreshedEntry?.update_check_reason ?? null
-  });
-}
-async function runExtensionUninstallAction(ctx) {
-  const { action, normalizedTarget, scope, resolvedRoots, warnings, options, withResult } = ctx;
-  const extensionTarget = requireTarget(normalizedTarget, action, options);
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
-  warnings.push(...managedStateRead.warnings);
-  const installed = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedStateRead.state);
-  warnings.push(...installed.warnings);
-  const candidate = await resolveInstalledExtensionCandidate(installed.extensions, extensionTarget);
-  if (!candidate) {
-    throw new PmCliError(`Installed extension "${extensionTarget}" was not found in ${scope} scope.`, EXIT_CODE.NOT_FOUND);
-  }
-  const destinationDirectory = path5.join(resolvedRoots.selected_root, candidate.directory);
-  await fs5.rm(destinationDirectory, { recursive: true, force: true });
-  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);
-  if (stateChanged) {
-    await writeSettings(resolvedRoots.settings_root, settings, "settings:write");
-  }
-  return withResult({
-    removed: true,
-    extension: {
-      name: candidate.name,
-      directory: candidate.directory
-    },
-    destination_path: destinationDirectory,
-    settings_changed: stateChanged
-  });
-}
-async function runExtensionActivateDeactivateAction(ctx) {
-  const { action, normalizedTarget, scope, resolvedRoots, warnings, options, withResult } = ctx;
-  const extensionTarget = requireTarget(normalizedTarget, action, options);
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
-  warnings.push(...managedStateRead.warnings);
-  const installed = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedStateRead.state);
-  warnings.push(...installed.warnings);
-  const candidate = await resolveInstalledExtensionCandidate(installed.extensions, extensionTarget);
-  if (!candidate) {
-    throw new PmCliError(`Installed extension "${extensionTarget}" was not found in ${scope} scope.`, EXIT_CODE.NOT_FOUND);
-  }
-  const settingsChanged = action === "activate" ? ensureActivated(settings, candidate.name) : ensureDeactivated(settings, candidate.name);
-  if (settingsChanged) {
-    await writeSettings(resolvedRoots.settings_root, settings, "settings:write");
-  }
-  return withResult({
-    extension: {
-      name: candidate.name,
-      directory: candidate.directory
-    },
-    active: action === "activate",
-    settings_changed: settingsChanged,
-    settings: {
-      enabled: [...settings.extensions.enabled],
-      disabled: [...settings.extensions.disabled]
-    }
-  });
-}
-function buildDoctorRemediation(baseRemediation, loadFailureCount, activationFailureCount, vocabulary, managedStateFix) {
-  return [
-    ...new Set([
-      ...baseRemediation,
-      /* c8 ignore start -- vocabulary-specific remediation branches are copy-only variants */
-      ...loadFailureCount > 0 ? [
-        vocabulary === "package" ? "Run pm package explore --project and pm package explore --global to inspect load failures." : "Run pm extension --explore --project and pm extension --explore --global to inspect load failures."
-      ] : [],
-      ...activationFailureCount > 0 ? [
-        vocabulary === "package" ? "Review activation failures in pm package doctor --detail deep output." : "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).`] : []
-    ].map((entry) => entry.trim()).filter((entry) => entry.length > 0))
-  ];
-}
-async function runExtensionDoctorAction(ctx) {
-  const { normalizedTarget, scope, resolvedRoots, warnings, options, global, withResult } = ctx;
-  if (normalizedTarget && normalizedTarget.trim().length > 0) {
-    throw new PmCliError('Action "doctor" does not accept a target argument.', EXIT_CODE.USAGE);
-  }
-  const detailMode = parseDoctorDetailMode(options.detail);
-  const includeTrace = options.trace === true;
-  if (includeTrace && detailMode !== "deep") {
-    throw new PmCliError("--trace requires --detail deep with --doctor.", EXIT_CODE.USAGE);
-  }
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
-  warnings.push(...managedStateRead.warnings);
-  const installed = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedStateRead.state);
-  warnings.push(...installed.warnings);
-  let managedState = managedStateRead.state;
-  const managedStateFix = options.fixManagedState === true ? await adoptUnmanagedExtensions(resolvedRoots.selected_root, scope, installed.extensions, managedStateRead.state) : null;
-  if (managedStateFix) {
-    managedState = managedStateFix.state;
-  }
-  const refreshedInstalled = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedState);
-  warnings.push(...refreshedInstalled.warnings);
-  const loadResult = await loadExtensions({
-    pmRoot: resolvedRoots.pm_root,
-    settings,
-    cwd: process.cwd(),
-    noExtensions: global.noExtensions === true
-  });
-  const activationResult = await activateExtensions({
-    ...loadResult,
-    loaded: loadResult.loaded
-  });
-  warnings.push(...loadResult.warnings);
-  warnings.push(...classifyDoctorLoadFailureWarnings(loadResult.failed));
-  warnings.push(...activationResult.warnings);
-  warnings.push(...classifyDoctorActivationFailureWarnings(activationResult.failed));
-  warnings.push(...classifyUnusedCapabilityWarnings(loadResult, activationResult));
-  warnings.push(...collectGlobalOutputOverrideDoctorWarnings(activationResult));
-  warnings.push(...collectSchemaNarrowActivationDoctorWarnings(loadResult, activationResult));
-  const runtimeInstalledExtensions = applyDoctorRuntimeActivationState(refreshedInstalled.extensions, loadResult, activationResult);
-  const doctorConsistency = buildDoctorConsistencySummary(scope, runtimeInstalledExtensions, loadResult.loaded.map((entry) => ({ layer: entry.layer, name: entry.name })), loadResult.failed.map((entry) => ({ name: entry.name })), loadResult.disabled_by_flag);
-  warnings.push(...doctorConsistency.warnings);
-  const updateCheckWarnings = runtimeInstalledExtensions.filter((entry) => entry.update_check_status === "failed").map((entry) => `extension_update_check_failed:${entry.name}`);
-  warnings.push(...updateCheckWarnings);
-  const triage = buildExtensionTriageSummary(scope, warnings, runtimeInstalledExtensions, options);
-  warnings.push(...triage.warnings);
-  const normalizedWarnings = [...triage.warnings];
-  const policySummary = {
-    mode: loadResult.policy.mode,
-    trust_mode: loadResult.policy.trust_mode,
-    require_provenance: loadResult.policy.require_provenance,
-    default_sandbox_profile: loadResult.policy.default_sandbox_profile,
-    // Honest trust model (ADR pm-6ef3): keep this caveat to one concise line.
-    sandbox_enforcement: "advisory: sandbox_profile/permissions are declaration-based load gates, not runtime isolation (ADR pm-6ef3)",
-    trusted_extensions_count: loadResult.policy.trusted_extensions.length,
-    allowed_extensions_count: loadResult.policy.allowed_extensions.length,
-    blocked_extensions_count: loadResult.policy.blocked_extensions.length,
-    allowed_capabilities_count: loadResult.policy.allowed_capabilities.length,
-    blocked_capabilities_count: loadResult.policy.blocked_capabilities.length,
-    allowed_surfaces_count: loadResult.policy.allowed_surfaces.length,
-    blocked_surfaces_count: loadResult.policy.blocked_surfaces.length,
-    allowed_commands_count: loadResult.policy.allowed_commands.length,
-    blocked_commands_count: loadResult.policy.blocked_commands.length,
-    allowed_actions_count: loadResult.policy.allowed_actions.length,
-    blocked_actions_count: loadResult.policy.blocked_actions.length,
-    allowed_services_count: loadResult.policy.allowed_services.length,
-    blocked_services_count: loadResult.policy.blocked_services.length,
-    extension_override_count: loadResult.policy.extension_overrides.length
-  };
-  const capabilityGuidance = collectUnknownCapabilityGuidance(normalizedWarnings);
-  const capabilityContract = buildCapabilityContractMetadata();
-  const warningCodes = triage.warning_codes;
-  const remediation = buildDoctorRemediation(triage.remediation, loadResult.failed.length, activationResult.failed.length, options.vocabulary, managedStateFix);
-  const summary = {
-    status: triage.status,
-    scope,
-    warning_count: triage.warning_count,
-    warning_codes: warningCodes,
-    total_extensions: runtimeInstalledExtensions.length,
-    managed_total: runtimeInstalledExtensions.filter((entry) => entry.managed).length,
-    enabled_total: runtimeInstalledExtensions.filter((entry) => entry.enabled).length,
-    active_total: runtimeInstalledExtensions.filter((entry) => entry.active).length,
-    unmanaged_loaded_extension_count: triage.unmanaged_loaded_extension_count,
-    unmanaged_action_required_extension_count: triage.unmanaged_action_required_extension_count,
-    unmanaged_expected_extension_count: triage.unmanaged_expected_extension_count,
-    runtime_active_total: runtimeInstalledExtensions.filter((entry) => entry.runtime_active === true).length,
-    activation_status_totals: {
-      ok: runtimeInstalledExtensions.filter((entry) => entry.activation_status === "ok").length,
-      failed: runtimeInstalledExtensions.filter((entry) => entry.activation_status === "failed").length,
-      not_loaded: runtimeInstalledExtensions.filter((entry) => entry.activation_status === "not_loaded").length,
-      unknown: runtimeInstalledExtensions.filter((entry) => entry.activation_status === "unknown").length
-    },
-    unknown_capability_count: capabilityGuidance.length,
-    capability_contract_version: capabilityContract.version,
-    update_available_total: runtimeInstalledExtensions.filter((entry) => entry.update_available === true).length,
-    update_health_coverage: triage.update_health_coverage,
-    update_health_partial: triage.update_health_partial,
-    update_check_failed_total: runtimeInstalledExtensions.filter((entry) => entry.update_check_status === "failed").length,
-    load_failure_count: loadResult.failed.length,
-    activation_failure_count: activationResult.failed.length,
-    blocking_failure_count: loadResult.failed.length + activationResult.failed.length,
-    has_blocking_failures: loadResult.failed.length + activationResult.failed.length > 0,
-    consistency_warning_count: doctorConsistency.warnings.length,
-    trace_enabled: includeTrace,
-    policy: policySummary,
-    remediation
-  };
-  const managedStateFixSummary = managedStateFix ? {
-    requested: true,
-    applied: managedStateFix.adopted_entries.length > 0,
-    adopted_count: managedStateFix.adopted_entries.length,
-    already_managed_count: managedStateFix.already_managed_count,
-    adopted_extensions: managedStateFix.adopted_entries.map((entry) => entry.name)
-  } : {
-    requested: false,
-    applied: false,
-    adopted_count: 0,
-    already_managed_count: refreshedInstalled.extensions.filter((entry) => entry.managed).length,
-    adopted_extensions: []
-  };
-  const details = {
-    mode: detailMode,
-    summary,
-    triage,
-    trace_enabled: includeTrace,
-    capability_contract: capabilityContract,
-    capability_guidance: capabilityGuidance,
-    managed_state_fix: managedStateFixSummary,
-    policy: loadResult.policy
-  };
-  if (detailMode === "deep") {
-    const activationFailedDetails = includeTrace ? activationResult.failed : activationResult.failed.map((entry) => {
-      const { trace: _trace, ...rest } = entry;
-      return rest;
-    });
-    details.deep = {
-      warnings: normalizedWarnings,
-      warning_codes: warningCodes,
-      capability_contract: capabilityContract,
-      capability_guidance: capabilityGuidance,
-      trace_enabled: includeTrace,
-      managed_state: {
-        path: managedStateRead.path,
-        count: managedState.entries.length,
-        entries: managedState.entries
-      },
-      installed_extensions: runtimeInstalledExtensions,
-      load: {
-        roots: loadResult.roots,
-        policy: loadResult.policy,
-        warnings: loadResult.warnings,
-        failed: loadResult.failed,
-        loaded: loadResult.loaded.map((entry) => ({
-          layer: entry.layer,
-          directory: entry.directory,
-          name: entry.name,
-          version: entry.version,
-          entry: entry.entry,
-          priority: entry.priority
-        }))
-      },
-      activation: {
-        failed: activationFailedDetails,
-        warnings: activationResult.warnings,
-        hook_counts: activationResult.hook_counts,
-        registration_counts: activationResult.registration_counts,
-        parser_override_count: activationResult.parser_override_count,
-        preflight_override_count: activationResult.preflight_override_count,
-        service_override_count: activationResult.service_override_count,
-        renderer_override_count: activationResult.renderer_override_count
-      },
-      consistency: doctorConsistency.summary
-    };
-    if (includeTrace) {
-      details.deep.trace = {
-        activation_failures: activationResult.failed.filter((entry) => entry.trace !== void 0).map((entry) => ({
-          layer: entry.layer,
-          name: entry.name,
-          entry_path: entry.entry_path,
-          error: entry.error,
-          method: entry.trace?.method,
-          command: entry.trace?.command,
-          capability: entry.trace?.capability,
-          missing_capability: entry.trace?.missing_capability,
-          registration_index: entry.trace?.registration_index,
-          expected_schema: entry.trace?.expected_schema,
-          hint: entry.trace?.hint,
-          received: entry.trace?.received
-        }))
-      };
-    }
-  }
-  return withResult(details);
-}
-async function runExtensionDescribeAction(ctx) {
-  const { normalizedTarget, scope, resolvedRoots, warnings, options, global, withResult } = ctx;
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const loadResult = await loadExtensions({
-    pmRoot: resolvedRoots.pm_root,
-    settings,
-    cwd: process.cwd(),
-    noExtensions: global.noExtensions === true
-  });
-  const activationResult = await activateExtensions(loadResult);
-  warnings.push(...loadResult.warnings);
-  warnings.push(...activationResult.warnings);
-  const describeResult = buildExtensionDescribeResult(normalizedTarget, loadResult, activationResult);
-  if (normalizedTarget !== void 0 && describeResult.extensions.length === 0) {
-    const noun = options.vocabulary === "package" ? "package" : "extension";
-    const loadedNames = [
-      ...new Set(loadResult.loaded.map((entry) => options.vocabulary === "package" && typeof entry.source_package === "string" && entry.source_package.trim().length > 0 ? entry.source_package.trim() : entry.name))
-    ].sort((left, right) => left.localeCompare(right));
-    const loadedHint = loadedNames.length > 0 ? ` Loaded ${noun} names: ${loadedNames.join(", ")}.` : "";
-    throw new PmCliError(`No loaded ${noun} named "${normalizedTarget}" was found in ${scope} scope.${loadedHint} Run pm ${noun} explore to list discovered ${noun}s.`, EXIT_CODE.NOT_FOUND);
-  }
-  return withResult({
-    target: describeResult.target,
-    total: describeResult.total,
-    extensions: describeResult.extensions,
-    union: describeResult.union
-  });
-}
-async function runExtensionExploreManageAction(ctx) {
-  const { action, scope, resolvedRoots, warnings, options, global, withResult } = ctx;
-  const settings = await readSettings(resolvedRoots.settings_root);
-  const configuredPolicy = buildExtensionPolicyDetails(settings.extensions.policy);
-  const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
-  warnings.push(...managedStateRead.warnings);
-  const installed = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedStateRead.state);
-  warnings.push(...installed.warnings);
-  let managedState = managedStateRead.state;
-  const managedStateFix = action === "manage" && options.fixManagedState === true ? await adoptUnmanagedExtensions(resolvedRoots.selected_root, scope, installed.extensions, managedStateRead.state) : null;
-  if (managedStateFix) {
-    managedState = managedStateFix.state;
-  }
-  if (action === "manage") {
-    const updates = await Promise.all(managedState.entries.map(async (entry) => {
-      if (entry.source.kind !== "github") {
-        return entry;
-      }
-      const updateStatus = await checkGithubUpdate(entry.source);
-      return {
-        ...entry,
-        last_update_check_at: updateStatus.checked_at,
-        last_update_remote_commit: updateStatus.remote_commit,
-        update_available: updateStatus.available,
-        update_error: updateStatus.error
-      };
-    }));
-    managedState = {
-      ...managedState,
-      updated_at: nowIso(),
-      entries: sortManagedEntries(updates)
-    };
-    await writeManagedExtensionState(resolvedRoots.selected_root, managedState);
-  }
-  const refreshedInstalled = await listInstalledExtensions(resolvedRoots.selected_root, scope, settings, managedState);
-  warnings.push(...refreshedInstalled.warnings);
-  if (action === "manage") {
-    const updateWarnings = refreshedInstalled.extensions.filter((entry) => entry.update_check_status === "failed").map((entry) => `extension_update_check_failed:${entry.name}`);
-    warnings.push(...updateWarnings);
-  }
-  let runtimeProbeSummary;
-  let runtimeInstalledExtensions = refreshedInstalled.extensions;
-  let runtimeActivationFailures;
-  if (action === "explore" || options.runtimeProbe === true) {
-    const loadResult = await loadExtensions({
-      pmRoot: resolvedRoots.pm_root,
-      settings,
-      cwd: process.cwd(),
-      noExtensions: global.noExtensions === true
-    });
-    const activationResult = await activateExtensions({
-      ...loadResult,
-      loaded: loadResult.loaded
-    });
-    warnings.push(...loadResult.warnings);
-    warnings.push(...activationResult.warnings);
-    runtimeInstalledExtensions = applyDoctorRuntimeActivationState(refreshedInstalled.extensions, loadResult, activationResult);
-    runtimeActivationFailures = collectActivationFailureDiagnostics(activationResult.failed);
-    runtimeProbeSummary = {
-      requested: true,
-      executed: true,
-      reason: action === "explore" ? "explore_defaults_to_runtime_probe" : "runtime_probe_requested",
-      load_failure_count: loadResult.failed.length,
-      activation_failure_count: activationResult.failed.length,
-      warning_count: [.../* @__PURE__ */ new Set([...loadResult.warnings, ...activationResult.warnings])].length,
-      policy: loadResult.policy
-    };
-  } else if (action === "manage") {
-    runtimeProbeSummary = {
-      requested: false,
-      executed: false
-    };
-  }
-  const triage = buildExtensionTriageSummary(scope, warnings, runtimeInstalledExtensions, options);
-  warnings.push(...triage.warnings);
-  const details = {
-    total: runtimeInstalledExtensions.length,
-    managed_total: runtimeInstalledExtensions.filter((entry) => entry.managed).length,
-    enabled_total: runtimeInstalledExtensions.filter((entry) => entry.enabled).length,
-    active_total: runtimeInstalledExtensions.filter((entry) => entry.active).length,
-    extensions: runtimeInstalledExtensions,
-    triage,
-    policy: configuredPolicy
-  };
-  if (runtimeActivationFailures !== void 0) {
-    details.activation_diagnostics = {
-      failed_count: runtimeActivationFailures.length,
-      failed: runtimeActivationFailures
-    };
-  }
-  if (action === "explore") {
-    details.runtime_probe = runtimeProbeSummary;
-  }
-  if (action === "manage") {
-    details.runtime_probe = runtimeProbeSummary;
-    details.managed_state_fix = managedStateFix !== null ? {
-      requested: true,
-      applied: managedStateFix.adopted_entries.length > 0,
-      adopted_count: managedStateFix.adopted_entries.length,
-      adopted_extensions: managedStateFix.adopted_entries.map((entry) => entry.name),
-      already_managed_count: managedStateFix.already_managed_count
-    } : {
-      requested: false,
-      applied: false,
-      adopted_count: 0,
-      adopted_extensions: [],
-      already_managed_count: runtimeInstalledExtensions.filter((entry) => entry.managed).length
-    };
-  }
-  return withResult(details);
-}
-var EXTENSION_ACTION_HANDLERS = {
-  init: runExtensionInitAction,
-  install: runExtensionInstallAction,
-  uninstall: runExtensionUninstallAction,
-  explore: runExtensionExploreManageAction,
-  manage: runExtensionExploreManageAction,
-  describe: runExtensionDescribeAction,
-  reload: runExtensionReloadAction,
-  doctor: runExtensionDoctorAction,
-  catalog: runExtensionCatalogAction,
-  adopt: runExtensionAdoptAction,
-  "adopt-all": runExtensionAdoptAllAction,
-  activate: runExtensionActivateDeactivateAction,
-  deactivate: runExtensionActivateDeactivateAction
-};
-var _testOnly = {
-  adoptUnmanagedExtensions,
-  buildExtensionPolicyDetails,
-  buildInstallCommandDiscovery,
-  checkGithubUpdate,
-  clearExtensionState,
-  collectActivationFailureDiagnostics,
-  findActivationFailureByName,
-  resolveInstallRuntimeActivationStatus,
-  collectGlobalOutputOverrideDoctorWarnings,
-  collectSchemaNarrowActivationDoctorWarnings,
-  copyExtensionDirectoryWithoutSelfNesting,
-  isErrnoCode,
-  isRetriableExtensionInstallCopyError,
-  listInstalledExtensions,
-  requireTarget,
-  resolveAction,
-  resolveCommandDiscoveryPackageName,
-  resolveGithubOption,
-  resolveInstalledExtensionCandidate,
-  resolveScope,
-  resolveUpdateCheckResolution,
-  withExtensionInstallLock
-};
-
-export {
-  resolveManagedExtensionStatePath,
-  readManagedExtensionState,
-  writeManagedExtensionState,
-  PM_PACKAGE_RESOURCE_KINDS,
-  PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS,
-  readPmPackageManifest,
-  collectPackageExtensionDirectories,
-  parseExtensionInstallSource,
-  buildRegistrationCollisionRemediation,
-  collectUnknownCapabilityGuidance,
-  buildCapabilityContractMetadata,
-  copyExtensionDirectoryForInstall,
-  runExtension,
-  _testOnly
-};
-//# sourceMappingURL=chunk-WG34ZNQQ.js.map
-
-//# debugId=40f0d0e2-0ce8-5774-a5dc-06db389b346f