@unbrained/pm-cli 2026.5.29 → 2026.5.31

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

@@ -0,0 +1,2929 @@
+import {
+  resolvePmPackageRootFromModule
+} from "./chunk-EGUGFSNX.js";
+import {
+  splitCommaList
+} from "./chunk-3HUE7XOF.js";
+import {
+  nowIso
+} from "./chunk-PVNQLCIS.js";
+import {
+  EXIT_CODE,
+  EXTENSION_CAPABILITY_CONTRACT,
+  KNOWN_EXTENSION_CAPABILITIES,
+  PmCliError,
+  activateExtensions,
+  isPathWithinDirectory,
+  loadExtensions,
+  nextExtensionReloadToken,
+  parseLegacyExtensionCapabilityAliasWarning,
+  parseUnknownExtensionCapabilityWarning,
+  pathExists,
+  readSettings,
+  resolveExtensionRoots,
+  resolveGlobalPmRoot,
+  resolvePmRoot,
+  writeSettings
+} from "./chunk-LSXGH6NE.js";
+
+// dist/cli/commands/extension.js
+import { execFile as execFile2 } from "node:child_process";
+import fs7 from "node:fs/promises";
+import os2 from "node:os";
+import path7 from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+// dist/cli/commands/extension/shared.js
+import fs from "node:fs/promises";
+import path from "node:path";
+!(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] = "cb831def-7a8a-55f8-85e2-7749a5591bfe");
+  } catch (e2) {
+  }
+})();
+var DEFAULT_EXTENSION_PRIORITY = 100;
+function normalizeStringList(values) {
+  return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function normalizeExtensionNameForMatch(value) {
+  return value.trim().toLowerCase();
+}
+function normalizeManagedDirectoryName(name) {
+  const normalized = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (normalized.length === 0) {
+    throw new PmCliError("Extension manifest name must resolve to a non-empty directory name.", EXIT_CODE.USAGE);
+  }
+  if (normalized === "." || normalized === "..") {
+    throw new PmCliError('Extension manifest name must not resolve to "." or "..".', EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseExtensionManifest(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return null;
+  }
+  const candidate = raw;
+  if (typeof candidate.name !== "string" || candidate.name.trim().length === 0) {
+    return null;
+  }
+  if (typeof candidate.version !== "string" || candidate.version.trim().length === 0) {
+    return null;
+  }
+  if (typeof candidate.entry !== "string" || candidate.entry.trim().length === 0) {
+    return null;
+  }
+  let priority = DEFAULT_EXTENSION_PRIORITY;
+  if (candidate.priority !== void 0 && candidate.priority !== null) {
+    if (typeof candidate.priority !== "number" || !Number.isInteger(candidate.priority)) {
+      return null;
+    }
+    priority = candidate.priority;
+  }
+  let capabilities = [];
+  if (candidate.capabilities !== void 0 && candidate.capabilities !== null) {
+    if (!Array.isArray(candidate.capabilities) || candidate.capabilities.some((value) => typeof value !== "string")) {
+      return null;
+    }
+    capabilities = normalizeStringList(candidate.capabilities.map((value) => String(value).toLowerCase()));
+  }
+  return {
+    name: candidate.name.trim(),
+    version: candidate.version.trim(),
+    entry: candidate.entry.trim(),
+    priority,
+    capabilities
+  };
+}
+async function isCanonicalPathWithinDirectory(directory, targetPath) {
+  const [resolvedDirectory, resolvedTargetPath] = await Promise.all([fs.realpath(directory), fs.realpath(targetPath)]);
+  return isPathWithinDirectory(resolvedDirectory, resolvedTargetPath);
+}
+async function validateExtensionDirectory(directory) {
+  const manifestPath = path.join(directory, "manifest.json");
+  if (!await pathExists(manifestPath)) {
+    throw new PmCliError(`Extension manifest is missing at "${manifestPath}".`, EXIT_CODE.USAGE);
+  }
+  let parsedManifest;
+  try {
+    parsedManifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+  } catch (error) {
+    throw new PmCliError(`Failed to parse extension manifest at "${manifestPath}": ${error instanceof Error ? error.message : String(error)}`, EXIT_CODE.USAGE);
+  }
+  const manifest = parseExtensionManifest(parsedManifest);
+  if (!manifest) {
+    throw new PmCliError(`Extension manifest at "${manifestPath}" is invalid.`, EXIT_CODE.USAGE);
+  }
+  const entryPath = path.resolve(directory, manifest.entry);
+  if (!isPathWithinDirectory(directory, entryPath)) {
+    throw new PmCliError(`Extension entry "${manifest.entry}" resolves outside extension directory "${directory}".`, EXIT_CODE.USAGE);
+  }
+  if (!await pathExists(entryPath)) {
+    throw new PmCliError(`Extension entry file is missing at "${entryPath}".`, EXIT_CODE.USAGE);
+  }
+  if (!await isCanonicalPathWithinDirectory(directory, entryPath)) {
+    throw new PmCliError(`Extension entry "${manifest.entry}" resolves outside extension directory after symlink resolution.`, EXIT_CODE.USAGE);
+  }
+  return {
+    directory,
+    manifest_path: manifestPath,
+    entry_path: entryPath,
+    manifest
+  };
+}
+
+// dist/cli/commands/extension/managed-state.js
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+!(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] = "f7dc1712-641e-52f3-bbd9-7f20eafddd5f");
+  } catch (e2) {
+  }
+})();
+var MANAGED_EXTENSION_STATE_FILENAME = ".managed-extensions.json";
+var MANAGED_EXTENSION_STATE_VERSION = 1;
+function resolveManagedExtensionStatePath(extensionsRoot) {
+  return path2.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 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) {
+    if (typeof rawEntry !== "object" || rawEntry === null) {
+      continue;
+    }
+    const entry = rawEntry;
+    if (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.some((value) => typeof value !== "string") || typeof entry.installed_at !== "string" || typeof entry.updated_at !== "string" || typeof entry.source !== "object" || entry.source === null) {
+      continue;
+    }
+    const source = entry.source;
+    if (source.kind !== "local" && source.kind !== "github" && source.kind !== "npm" && source.kind !== "builtin" || typeof source.input !== "string" || typeof source.location !== "string") {
+      continue;
+    }
+    entries.push({
+      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: {
+        kind: source.kind,
+        input: source.input,
+        location: source.location,
+        name: typeof source.name === "string" ? source.name : void 0,
+        package: typeof source.package === "string" ? source.package : void 0,
+        version: typeof source.version === "string" ? source.version : void 0,
+        repository: typeof source.repository === "string" ? source.repository : void 0,
+        owner: typeof source.owner === "string" ? source.owner : void 0,
+        repo: typeof source.repo === "string" ? source.repo : void 0,
+        ref: typeof source.ref === "string" ? source.ref : void 0,
+        subpath: typeof source.subpath === "string" ? source.subpath : void 0,
+        commit: typeof source.commit === "string" ? source.commit : void 0
+      },
+      last_update_check_at: typeof entry.last_update_check_at === "string" ? entry.last_update_check_at : void 0,
+      last_update_remote_commit: typeof entry.last_update_remote_commit === "string" ? entry.last_update_remote_commit : void 0,
+      update_available: typeof entry.update_available === "boolean" || entry.update_available === null ? entry.update_available : void 0,
+      update_error: typeof entry.update_error === "string" ? entry.update_error : void 0
+    });
+  }
+  return {
+    version: MANAGED_EXTENSION_STATE_VERSION,
+    updated_at: typeof candidate.updated_at === "string" ? candidate.updated_at : nowIso(),
+    entries: sortManagedEntries(entries)
+  };
+}
+async function readManagedExtensionState(extensionsRoot) {
+  const statePath = resolveManagedExtensionStatePath(extensionsRoot);
+  const fallback = createEmptyManagedExtensionState();
+  try {
+    const raw = await fs2.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 fs2.mkdir(extensionsRoot, { recursive: true });
+  await fs2.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 fs4 from "node:fs/promises";
+import os from "node:os";
+import path4 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+
+// dist/core/packages/manifest.js
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+!(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] = "84dfbdeb-902c-58a1-a6c4-9411f5c2293e");
+  } catch (e2) {
+  }
+})();
+var PM_PACKAGE_RESOURCE_KINDS = [
+  "extensions",
+  "docs",
+  "examples"
+];
+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"
+  ])
+});
+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 = path3.join(packageRoot, "package.json");
+  if (!await pathExists(packageJsonPath)) {
+    return {
+      source: "convention",
+      resources: {}
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await fs3.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 fs3.readdir(parentDirectory, { withFileTypes: true });
+  const candidates = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const directory = path3.join(parentDirectory, entry.name);
+    if (await pathExists(path3.join(directory, "manifest.json"))) {
+      candidates.push(directory);
+    }
+  }
+  return candidates.sort((left, right) => left.localeCompare(right));
+}
+async function collectPackageExtensionDirectories(packageRoot) {
+  if (await pathExists(path3.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 = path3.resolve(packageRoot, entry);
+    if (!isPathWithinDirectory(packageRoot, absolute)) {
+      throw new PmCliError(`Package extension entry "${entry}" resolves outside package root.`, EXIT_CODE.USAGE);
+    }
+    if (await pathExists(path3.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(path3.join(packageRoot, root))) {
+        discovered.add(child);
+      }
+    }
+  }
+  return [...discovered].sort((left, right) => left.localeCompare(right));
+}
+
+// dist/cli/commands/extension/install-sources.js
+!(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] = "eaa543ef-b644-5b26-9eb4-dcb40aaa8a53");
+  } catch (e2) {
+  }
+})();
+var execFileAsync = promisify(execFile);
+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: path4.resolve(process.cwd(), normalizedInput)
+  };
+}
+async function runGitCommand(args) {
+  try {
+    const result = await execFileAsync("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) {
+  const npmCommand = resolveNpmCommandName();
+  try {
+    const result = await execFileAsync(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);
+  }
+}
+async function resolveLocalNpmPackagePath(spec) {
+  if (path4.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..")) {
+    const absolutePath = path4.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 = path4.resolve(process.cwd(), spec);
+    if (await pathExists(absolutePath)) {
+      return absolutePath;
+    }
+  }
+  return null;
+}
+async function resolveNpmPackSpec(spec) {
+  const localPath = await resolveLocalNpmPackagePath(spec);
+  if (localPath) {
+    return pathToFileURL(localPath).href;
+  }
+  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 || target.startsWith("//")) {
+    return spec;
+  }
+  const absolutePath = path4.isAbsolute(target) || path4.win32.isAbsolute(target) ? target : path4.resolve(cwd, target);
+  return `${packageName}@${pathToFileURL(absolutePath).href}`;
+}
+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: path4.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: path4.resolve(packDirectory, lastLine)
+  };
+}
+async function resolveNpmSourceDirectory(source) {
+  const localPackageRoot = await resolveLocalNpmPackagePath(source.spec);
+  if (localPackageRoot) {
+    const packageJsonPath = path4.join(localPackageRoot, "package.json");
+    const packageJson = await pathExists(packageJsonPath) ? JSON.parse(await fs4.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 fs4.mkdtemp(path4.join(os.tmpdir(), "pm-npm-package-source-"));
+  const packDirectory = path4.join(tempRoot, "pack");
+  const extractDirectory = path4.join(tempRoot, "extract");
+  await fs4.mkdir(packDirectory, { recursive: true });
+  await fs4.mkdir(extractDirectory, { recursive: true });
+  try {
+    const packSpec = await resolveNpmPackSpec(source.spec);
+    const packStdout = await runNpmCommand(["pack", packSpec, "--json", "--pack-destination", packDirectory]);
+    const packed = parsePackedNpmPackage(packStdout, packDirectory);
+    await execFileAsync("tar", ["-xzf", packed.tarball, "-C", extractDirectory], { encoding: "utf8" });
+    const packageRoot = path4.join(extractDirectory, "package");
+    await installNpmPackageRuntimeDependencies(packageRoot);
+    const directory = await resolvePackageExtensionDirectory(packageRoot, source.input);
+    return {
+      directory,
+      package: packed.package,
+      version: packed.version,
+      cleanup: async () => {
+        await fs4.rm(tempRoot, { recursive: true, force: true });
+      }
+    };
+  } catch (error) {
+    await fs4.rm(tempRoot, { recursive: true, force: true });
+    throw error;
+  }
+}
+async function installNpmPackageRuntimeDependencies(packageRoot) {
+  const packageJsonPath = path4.join(packageRoot, "package.json");
+  if (!await pathExists(packageJsonPath)) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await fs4.readFile(packageJsonPath, "utf8"));
+  } catch {
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return;
+  }
+  const manifest = parsed;
+  const dependencySpecs = runtimeDependencyInstallSpecs(manifest);
+  if (dependencySpecs.length === 0) {
+    return;
+  }
+  const runtimeOnlyManifest = { ...parsed };
+  delete runtimeOnlyManifest.devDependencies;
+  await fs4.writeFile(packageJsonPath, `${JSON.stringify(runtimeOnlyManifest, null, 2)}
+`, "utf8");
+  await Promise.all([
+    fs4.rm(path4.join(packageRoot, "package-lock.json"), { force: true }),
+    fs4.rm(path4.join(packageRoot, "npm-shrinkwrap.json"), { force: true })
+  ]);
+  await runNpmCommand(["install", "--ignore-scripts", "--no-audit", "--fund=false", "--package-lock=false", "--no-save", ...dependencySpecs], packageRoot);
+}
+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 (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) => path4.relative(packageRoot, entry).replaceAll(path4.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(path4.posix.join(".agents/pm/extensions", source.subpath));
+    candidatePaths.push(path4.posix.join(".custom/pm-extensions", source.subpath));
+    candidatePaths.push(path4.posix.join(".custom/pm-extension", source.subpath));
+  }
+  for (const candidate of candidatePaths) {
+    const absolute = path4.resolve(cloneDirectory, candidate);
+    if (!isPathWithinDirectory(cloneDirectory, absolute)) {
+      continue;
+    }
+    if (await pathExists(path4.join(absolute, "manifest.json"))) {
+      return { directory: absolute, resolved_subpath: candidate };
+    }
+  }
+  if (await pathExists(path4.join(cloneDirectory, "manifest.json"))) {
+    return { directory: cloneDirectory, resolved_subpath: "." };
+  }
+  const discoveredDirectory = await resolvePackageExtensionDirectory(cloneDirectory, source.input);
+  return {
+    directory: discoveredDirectory,
+    resolved_subpath: path4.relative(cloneDirectory, discoveredDirectory).replaceAll(path4.sep, "/")
+  };
+}
+async function resolveInstallSource(source) {
+  if (source.kind === "local") {
+    let localStats;
+    try {
+      localStats = await fs4.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: path4.relative(path4.dirname(resolved.directory), resolved.directory).replaceAll(path4.sep, "/"),
+      npm_package: resolved.package,
+      npm_version: resolved.version
+    };
+  }
+  const cloneDirectory = await fs4.mkdtemp(path4.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 fs4.rm(cloneDirectory, { recursive: true, force: true });
+      }
+    };
+  } catch (error) {
+    await fs4.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([fs4.realpath(left), fs4.realpath(right)]);
+  return leftRealPath === rightRealPath;
+}
+
+// dist/cli/commands/extension/bundled-catalog.js
+import fs5 from "node:fs/promises";
+import path5 from "node:path";
+!(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] = "778dfce2-07e1-50c3-8e47-2c43f61a9a0f");
+  } catch (e2) {
+  }
+})();
+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(path5.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 = path5.join(packageRoot2, ".agents", "pm", "extensions", alias.legacy_extension_directory);
+    if (await pathExists(path5.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 = path5.join(packageRoot, "packages");
+    if (!await pathExists(packagesRoot)) {
+      continue;
+    }
+    const entries = await fs5.readdir(packagesRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !entry.name.startsWith("pm-")) {
+        continue;
+      }
+      const candidateRoot = path5.join(packagesRoot, entry.name);
+      if (!await pathExists(path5.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 = path5.join(packageRoot, "packages", legacy.package_directory);
+      if (await pathExists(path5.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 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;
+  }
+}
+async function buildBundledPackageCatalog(scope, global2, options = {}) {
+  const roots = resolveExtensionRoots(resolvePmRoot(process.cwd(), global2.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) => path5.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 alias of await listBundledPackageAliases()) {
+    const packageRoot = await resolveBundledPackageRoot(alias);
+    const installScopeFlag = scope === "global" ? "--global" : "--project";
+    if (!packageRoot) {
+      packages.push({
+        alias,
+        bundled: true,
+        available: false,
+        installed: false,
+        install_target: alias,
+        install_command: `pm install ${alias} ${installScopeFlag}`
+      });
+      continue;
+    }
+    const manifest = await readPmPackageManifest(packageRoot);
+    const repository = manifest.catalog?.links?.repository ?? manifest.package_repository_url;
+    const report = manifest.catalog?.links?.report ?? manifest.package_bugs_url;
+    const docs = manifest.catalog?.links?.docs ?? manifest.package_homepage;
+    const npm = manifest.catalog?.links?.npm ?? (manifest.package_name && manifest.package_private !== true ? `https://www.npmjs.com/package/${encodeURIComponent(manifest.package_name)}` : void 0);
+    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));
+    packages.push({
+      alias,
+      bundled: true,
+      available: true,
+      installed: installedBuiltinAliases.has(alias) || installedLocations.has(path5.resolve(packageRoot)),
+      install_target: alias,
+      install_command: `pm install ${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: {
+          docs,
+          npm,
+          repository,
+          report
+        },
+        media: manifest.catalog?.media
+      }
+    });
+  }
+  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/scaffold.js
+import fs6 from "node:fs/promises";
+import path6 from "node:path";
+!(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] = "6ba6d57e-c873-51ad-b55d-3f35c6f9ef55");
+  } catch (e2) {
+  }
+})();
+function buildStarterExtensionScaffoldFiles(extensionName, commandName, vocabulary) {
+  const packageName = `pm-${extensionName}`;
+  const manifest = `${JSON.stringify({
+    name: extensionName,
+    version: "0.1.0",
+    entry: "./index.js",
+    capabilities: ["commands"]
+  }, null, 2)}
+`;
+  const entrypoint = vocabulary === "package" ? [
+    'import { defineExtension } from "@unbrained/pm-cli/sdk";',
+    "",
+    "export default defineExtension({",
+    "  activate(api) {",
+    "    api.registerCommand({",
+    `      name: ${JSON.stringify(commandName)},`,
+    '      description: "Starter scaffold command. Replace with your own behavior.",',
+    "      run: async (context) => ({",
+    "        ok: true,",
+    `        source: ${JSON.stringify(extensionName)},`,
+    "        command: context.command,",
+    '        message: "Starter extension scaffold is active.",',
+    "      }),",
+    "    });",
+    "  },",
+    "});",
+    ""
+  ].join("\n") : [
+    '/** @param {import("@unbrained/pm-cli/sdk").ExtensionApi} api */',
+    "export function activate(api) {",
+    "  api.registerCommand({",
+    `    name: ${JSON.stringify(commandName)},`,
+    '    description: "Starter scaffold command. Replace with your own behavior.",',
+    "    run: async (context) => ({",
+    "      ok: true,",
+    `      source: ${JSON.stringify(extensionName)},`,
+    "      command: context.command,",
+    '      message: "Starter extension scaffold is active.",',
+    "    }),",
+    "  });",
+    "}",
+    "",
+    "export default {",
+    "  activate,",
+    "};",
+    ""
+  ].join("\n");
+  if (vocabulary === "package") {
+    const packageJson = `${JSON.stringify({
+      name: packageName,
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      keywords: ["pm-package"],
+      peerDependencies: {
+        "@unbrained/pm-cli": "*"
+      },
+      pm: {
+        aliases: [extensionName],
+        extensions: [`extensions/${extensionName}`],
+        docs: ["README.md"],
+        examples: ["README.md"],
+        catalog: {
+          display_name: extensionName,
+          category: "workflow",
+          summary: "Starter pm package scaffold.",
+          tags: ["starter"]
+        }
+      }
+    }, null, 2)}
+`;
+    const packageReadme = [
+      `# ${packageName}`,
+      "",
+      "Generated by `pm package init`.",
+      "",
+      "## Included Files",
+      "- `package.json`: package metadata and `pm` resource manifest.",
+      `- \`extensions/${extensionName}/manifest.json\`: extension metadata and capabilities.`,
+      `- \`extensions/${extensionName}/index.js\`: starter command registration using the \`commands\` capability.`,
+      "",
+      "## Quick Start",
+      "```bash",
+      "pm install --project <package-path>",
+      `pm ${commandName}`,
+      "pm package doctor --project --detail summary",
+      "```",
+      "",
+      "## Notes",
+      "- Keep package metadata in `package.json` and runtime behavior under `extensions/`.",
+      "- Add capabilities to the extension manifest only when the entrypoint uses the matching SDK API.",
+      "- Use `@unbrained/pm-cli/sdk` as the public SDK import for richer package runtimes.",
+      ""
+    ].join("\n");
+    return {
+      "package.json": packageJson,
+      [`extensions/${extensionName}/manifest.json`]: manifest,
+      [`extensions/${extensionName}/index.js`]: entrypoint,
+      "README.md": packageReadme
+    };
+  }
+  const readme = [
+    `# ${extensionName}`,
+    "",
+    "Generated by `pm extension init`.",
+    "",
+    "## Included Files",
+    "- `manifest.json`: extension metadata and capabilities.",
+    "- `index.js`: starter command registration using the `commands` capability.",
+    "",
+    "## Quick Start",
+    "```bash",
+    "pm extension --install --project <scaffold-path>",
+    `pm ${commandName}`,
+    "pm extension --doctor --project --detail summary",
+    "```",
+    "",
+    "## Notes",
+    "- This scaffold uses ESM exports so it works in package scopes with `type: module`.",
+    "- Update `manifest.json` capabilities and `index.js` command behavior as your extension evolves.",
+    ""
+  ].join("\n");
+  return {
+    "manifest.json": manifest,
+    "index.js": entrypoint,
+    "README.md": readme
+  };
+}
+async function scaffoldExtensionProject(target, vocabulary = "extension") {
+  const normalizedTarget = target.trim();
+  const targetPath = path6.resolve(process.cwd(), normalizedTarget);
+  const extensionName = normalizeManagedDirectoryName(path6.basename(targetPath));
+  const commandName = `${extensionName} ping`;
+  const scaffoldFiles = buildStarterExtensionScaffoldFiles(extensionName, commandName, vocabulary);
+  let createdDirectory = false;
+  if (await pathExists(targetPath)) {
+    const existingTargetStats = await fs6.stat(targetPath);
+    if (!existingTargetStats.isDirectory()) {
+      throw new PmCliError(`Scaffold target "${targetPath}" exists and is not a directory.`, EXIT_CODE.CONFLICT);
+    }
+  } else {
+    await fs6.mkdir(targetPath, { recursive: true });
+    createdDirectory = true;
+  }
+  for (const [relativePath, content] of Object.entries(scaffoldFiles)) {
+    const absolutePath = path6.join(targetPath, relativePath);
+    if (!await pathExists(absolutePath)) {
+      continue;
+    }
+    const existingContent = await fs6.readFile(absolutePath, "utf8");
+    if (existingContent !== content) {
+      throw new PmCliError(`Scaffold file "${relativePath}" already exists with different content in "${targetPath}". Choose a new target path or remove conflicting files.`, EXIT_CODE.CONFLICT);
+    }
+  }
+  const files = [];
+  for (const [relativePath, content] of Object.entries(scaffoldFiles)) {
+    const absolutePath = path6.join(targetPath, relativePath);
+    if (await pathExists(absolutePath)) {
+      files.push({
+        path: relativePath,
+        status: "unchanged"
+      });
+      continue;
+    }
+    await fs6.mkdir(path6.dirname(absolutePath), { recursive: true });
+    await fs6.writeFile(absolutePath, content, "utf8");
+    files.push({
+      path: relativePath,
+      status: "created"
+    });
+  }
+  return {
+    extension_name: extensionName,
+    command_name: commandName,
+    target_path: targetPath,
+    created_directory: createdDirectory,
+    files
+  };
+}
+
+// dist/cli/commands/extension/doctor.js
+!(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] = "71448117-1b4c-5c35-8233-433f32151c95");
+  } catch (e2) {
+  }
+})();
+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 = /* @__PURE__ */ new Map();
+  const actionPathsByExtension = /* @__PURE__ */ new Map();
+  const addCommandPath = (extensionName, commandPath) => {
+    const normalizedName = normalizeExtensionNameForMatch(extensionName);
+    const normalizedCommandPath = commandPath.trim();
+    if (normalizedName.length === 0 || normalizedCommandPath.length === 0) {
+      return;
+    }
+    const existing = commandPathsByExtension.get(normalizedName) ?? /* @__PURE__ */ new Set();
+    existing.add(normalizedCommandPath);
+    commandPathsByExtension.set(normalizedName, existing);
+  };
+  const addActionPath = (extensionName, actionPath) => {
+    const normalizedName = normalizeExtensionNameForMatch(extensionName);
+    const normalizedActionPath = actionPath.trim();
+    if (normalizedName.length === 0 || normalizedActionPath.length === 0) {
+      return;
+    }
+    const existing = actionPathsByExtension.get(normalizedName) ?? /* @__PURE__ */ new Set();
+    existing.add(normalizedActionPath);
+    actionPathsByExtension.set(normalizedName, existing);
+  };
+  for (const registration of activationResult.registrations.commands) {
+    addCommandPath(registration.name, registration.command);
+    addActionPath(registration.name, registration.action);
+  }
+  for (const handler of activationResult.commands.handlers) {
+    addCommandPath(handler.name, handler.command);
+  }
+  for (const override of activationResult.commands.overrides) {
+    addCommandPath(override.name, override.command);
+  }
+  const sortedPaths = (values) => {
+    if (!values || values.size === 0) {
+      return void 0;
+    }
+    return [...values].sort((left, right) => left.localeCompare(right));
+  };
+  return extensions.map((entry) => {
+    const normalizedName = normalizeExtensionNameForMatch(entry.name);
+    const commandPaths = sortedPaths(commandPathsByExtension.get(normalizedName));
+    const actionPaths = sortedPaths(actionPathsByExtension.get(normalizedName));
+    const runtimeMetadata = {
+      ...commandPaths ? { command_paths: commandPaths } : {},
+      ...actionPaths ? { action_paths: actionPaths } : {}
+    };
+    if (!entry.enabled) {
+      return {
+        ...entry,
+        runtime_active: false,
+        activation_status: "not_loaded",
+        ...runtimeMetadata
+      };
+    }
+    if (loadFailedNames.has(normalizedName) || activationFailedNames.has(normalizedName)) {
+      return {
+        ...entry,
+        runtime_active: false,
+        activation_status: "failed",
+        ...runtimeMetadata
+      };
+    }
+    if (loadedNames.has(normalizedName)) {
+      return {
+        ...entry,
+        runtime_active: true,
+        activation_status: "ok",
+        ...runtimeMetadata
+      };
+    }
+    return {
+      ...entry,
+      runtime_active: false,
+      activation_status: "not_loaded",
+      ...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}`;
+}
+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 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 remediation = [];
+  if (normalizedWarnings.length > 0) {
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_manifest_"))) {
+      remediation.push(`Run ${lifecycleFlagCommand(options, "explore")} ${scopeFlag} to inspect discovered manifests and directories.`);
+    }
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_capability_unknown:"))) {
+      remediation.push(`Unknown extension capabilities detected. Allowed capabilities: ${KNOWN_EXTENSION_CAPABILITIES.join(", ")}. Review extension_capability_unknown warning details for suggested replacements.`);
+    }
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_capability_legacy_alias:"))) {
+      remediation.push("Legacy extension capability aliases were auto-remapped to canonical capabilities. Update manifests to canonical names (migration/validation -> schema).");
+    }
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_command_definition_legacy_handler_alias:"))) {
+      remediation.push("Extension command definitions using legacy handler were auto-remapped. Update command definitions to use run: (context) => ... for forward compatibility.");
+    }
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_load_failed_sdk_dependency_missing:"))) {
+      remediation.push(`Detected extension load failures caused by missing SDK dependency resolution. Ensure extension package dependencies include "@unbrained/pm-cli" and reinstall dependencies before running ${lifecycleFlagCommand(options, "doctor")} ${scopeFlag}.`);
+    }
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_load_failed_module_mode_mismatch:"))) {
+      remediation.push(`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(options, "doctor")} ${scopeFlag}.`);
+    }
+    if (updateCheckFailedTotal > 0) {
+      remediation.push(`Run ${lifecycleFlagCommand(options, "manage")} ${scopeFlag} after validating network and repository access.`);
+    }
+    if (normalizedWarnings.some((warning) => warning.startsWith("extension_manager_state_"))) {
+      remediation.push(`Review and repair ${scope} managed extension state file if schema/read warnings persist.`);
+    }
+    if (policyWarnings.warning_count > 0) {
+      remediation.push("Extension governance policy warnings detected. Review settings.extensions.policy mode and allow/block lists to confirm intended capabilities and registration surfaces.");
+    }
+  }
+  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 {
+    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
+  };
+}
+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
+!(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] = "dc0411c0-3d3c-5495-9be5-d221c8a9498d");
+  } catch (e2) {
+  }
+})();
+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;
+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 copyExtensionDirectoryForInstall(sourceDirectory, destinationDirectory, copyDirectory = fs7.cp) {
+  for (let attempt = 1; attempt <= EXTENSION_INSTALL_COPY_ATTEMPTS; attempt += 1) {
+    try {
+      if (await pathExists(destinationDirectory)) {
+        await fs7.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 = path7.resolve(sourceDirectory);
+  const resolvedDestination = path7.resolve(destinationDirectory);
+  if (resolvedSource === resolvedDestination) {
+    return;
+  }
+  if (!isPathWithinDirectory(resolvedSource, resolvedDestination)) {
+    await copyDirectory(sourceDirectory, destinationDirectory, { recursive: true, force: true });
+    return;
+  }
+  const stagingRoot = await fs7.mkdtemp(path7.join(os2.tmpdir(), "pm-extension-copy-"));
+  const stagedDirectory = path7.join(stagingRoot, "extension");
+  try {
+    await copyDirectory(sourceDirectory, stagedDirectory, { recursive: true, force: true });
+    await copyDirectory(stagedDirectory, destinationDirectory, { recursive: true, force: true });
+  } finally {
+    await fs7.rm(stagingRoot, { recursive: true, force: true });
+  }
+}
+async function withExtensionInstallLock(settingsRoot, destinationDirectoryName, run) {
+  const lockRoot = path7.join(settingsRoot, "runtime", "extension-install-locks");
+  const lockPath = path7.join(lockRoot, `${destinationDirectoryName}.lock`);
+  await fs7.mkdir(lockRoot, { recursive: true });
+  let acquired = false;
+  for (let attempt = 1; attempt <= EXTENSION_INSTALL_LOCK_ATTEMPTS; attempt += 1) {
+    try {
+      await fs7.mkdir(lockPath);
+      acquired = true;
+      await fs7.writeFile(path7.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;
+      }
+      const stat = await fs7.stat(lockPath).catch(() => null);
+      if (stat && Date.now() - stat.mtimeMs > EXTENSION_INSTALL_LOCK_STALE_MS) {
+        await fs7.rm(lockPath, { recursive: true, force: true });
+        continue;
+      }
+      await sleep(EXTENSION_INSTALL_LOCK_DELAY_MS);
+    }
+  }
+  if (!acquired) {
+    throw new PmCliError(`Timed out waiting for extension install lock for "${destinationDirectoryName}".`, EXIT_CODE.CONFLICT);
+  }
+  try {
+    return await run();
+  } finally {
+    await fs7.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 resolveAction(target, options) {
+  const selected = [...new Set([
+    options.install ? "install" : null,
+    options.uninstall ? "uninstall" : null,
+    options.explore ? "explore" : null,
+    options.manage ? "manage" : null,
+    options.reload ? "reload" : null,
+    options.doctor ? "doctor" : null,
+    options.catalog ? "catalog" : null,
+    options.init ? "init" : null,
+    options.scaffold ? "init" : null,
+    options.adopt ? "adopt" : null,
+    options.adoptAll ? "adopt-all" : null,
+    options.activate ? "activate" : null,
+    options.deactivate ? "deactivate" : null
+  ].filter((value) => value !== null))];
+  if (selected.length === 0) {
+    if (typeof target === "string" && target.trim().toLowerCase() === "doctor") {
+      return "doctor";
+    }
+    if (typeof target === "string" && target.trim().toLowerCase() === "reload") {
+      return "reload";
+    }
+    if (typeof target === "string" && target.trim().toLowerCase() === "catalog") {
+      return "catalog";
+    }
+    if (typeof target === "string" && (target.trim().toLowerCase() === "init" || target.trim().toLowerCase() === "scaffold")) {
+      return "init";
+    }
+    if (typeof target === "string" && target.trim().toLowerCase() === "explore") {
+      return "explore";
+    }
+    if (typeof target === "string" && target.trim().toLowerCase() === "manage") {
+      return "manage";
+    }
+    if (typeof target === "string" && (target.trim().toLowerCase() === "list" || target.trim() === "")) {
+      return "explore";
+    }
+    if (target === void 0) {
+      return "explore";
+    }
+    throw new PmCliError("One action flag is required. Use one of: --install, --uninstall, --explore, --manage, --reload, --doctor, --catalog, --init/--scaffold, --adopt, --adopt-all, --activate, --deactivate. Bare `pm package` and `pm extension` default to --explore.", EXIT_CODE.USAGE);
+  }
+  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 global2 = options.global === true;
+  if (projectLike && global2) {
+    throw new PmCliError('Options "--project/--local" and "--global" are mutually exclusive.', EXIT_CODE.USAGE);
+  }
+  return global2 ? "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"
+  };
+}
+async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
+  if (!await pathExists(extensionsRoot)) {
+    return {
+      extensions: [],
+      warnings: []
+    };
+  }
+  const entries = await fs7.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 = path7.join(extensionsRoot, directoryName);
+    const manifestPath = path7.join(extensionDirectory, "manifest.json");
+    if (!await pathExists(manifestPath)) {
+      warnings.push(`extension_manifest_missing:${scope}:${directoryName}`);
+      const managedEntry2 = managedByDirectory.get(normalizeExtensionNameForMatch(directoryName));
+      const updateCheck2 = resolveUpdateCheckResolution(managedEntry2);
+      const enabled2 = managedEntry2 ? isExtensionEnabled(settings, managedEntry2.name) : false;
+      summaries.push({
+        name: managedEntry2?.name ?? directoryName,
+        directory: directoryName,
+        version: managedEntry2?.manifest_version ?? "unknown",
+        entry: managedEntry2?.manifest_entry ?? "unknown",
+        scope,
+        active: enabled2,
+        enabled: enabled2,
+        runtime_active: null,
+        activation_status: "unknown",
+        managed: Boolean(managedEntry2),
+        source: managedEntry2?.source,
+        update_available: managedEntry2?.update_available,
+        last_update_check_at: managedEntry2?.last_update_check_at,
+        last_update_remote_commit: managedEntry2?.last_update_remote_commit,
+        update_error: managedEntry2?.update_error,
+        update_check_status: updateCheck2.status,
+        update_check_reason: updateCheck2.reason
+      });
+      continue;
+    }
+    let rawManifest;
+    try {
+      rawManifest = JSON.parse(await fs7.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));
+    const updateCheck = resolveUpdateCheckResolution(managedEntry);
+    const enabled = isExtensionEnabled(settings, manifest.name);
+    summaries.push({
+      name: manifest.name,
+      directory: directoryName,
+      version: manifest.version,
+      entry: manifest.entry,
+      scope,
+      active: enabled,
+      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
+    });
+  }
+  return {
+    extensions: summaries.sort((left, right) => left.name.localeCompare(right.name)),
+    warnings: warnings.sort((left, right) => left.localeCompare(right))
+  };
+}
+async function checkGithubUpdate(source) {
+  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 runGitCommand(["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 = path7.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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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 requireTarget(target, action) {
+  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);
+    }
+    throw new PmCliError(`Action "${action}" requires an extension name or source target argument.`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+async function runExtension(target, options, global2) {
+  const action = resolveAction(target, options);
+  if ((options.strictExit === true || options.failOnWarn === true) && action !== "doctor") {
+    throw new PmCliError("--strict-exit and --fail-on-warn are only valid with --doctor.", EXIT_CODE.USAGE);
+  }
+  if (options.trace === true && action !== "doctor") {
+    throw new PmCliError("--trace is only valid with --doctor.", EXIT_CODE.USAGE);
+  }
+  if (options.watch === true && action !== "reload") {
+    throw new PmCliError("--watch is only valid with --reload.", EXIT_CODE.USAGE);
+  }
+  if (options.runtimeProbe === true && action !== "manage") {
+    throw new PmCliError("--runtime-probe is only valid with --manage.", EXIT_CODE.USAGE);
+  }
+  if (options.fixManagedState === true && action !== "manage" && action !== "doctor") {
+    throw new PmCliError("--fix-managed-state is only valid with --manage or --doctor.", EXIT_CODE.USAGE);
+  }
+  const normalizedTarget = (() => {
+    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;
+  })();
+  const scope = resolveScope(options);
+  const resolvedRoots = resolveExtensionRootsForScope(scope, global2);
+  const warnings = [];
+  const withResult = (details) => ({
+    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 === "init") {
+    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);
+    const scaffold = await scaffoldExtensionProject(scaffoldTarget, options.vocabulary ?? "extension");
+    const quotedTargetPath = JSON.stringify(scaffold.target_path);
+    return withResult({
+      scaffolded: scaffold.created_directory || scaffold.files.some((entry) => entry.status === "created"),
+      extension: {
+        name: scaffold.extension_name,
+        command: scaffold.command_name
+      },
+      target_path: scaffold.target_path,
+      created_directory: scaffold.created_directory,
+      files: scaffold.files,
+      next_steps: [
+        `Install the scaffold: ${options.vocabulary === "package" ? "pm install --project" : "pm extension --install --project"} ${quotedTargetPath}`,
+        `Smoke-test command path: pm ${scaffold.command_name}`,
+        `Run diagnostics: ${options.vocabulary === "package" ? "pm package doctor" : "pm extension --doctor"} --project --detail summary`
+      ]
+    });
+  }
+  if (action === "reload") {
+    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: global2.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);
+  }
+  if (action === "catalog") {
+    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, global2, options));
+  }
+  if (action === "install") {
+    const githubOption = resolveGithubOption(options);
+    const explicitSourceInput = githubOption ?? requireTarget(normalizedTarget, action);
+    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 }, global2)
+        });
+      }
+      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,
+          warnings: entry.result.warnings
+        }))
+      });
+    }
+    const bundledAliasSource = typeof githubOption === "string" ? null : await resolveBundledExtensionAliasSource(explicitSourceInput);
+    const bundledAliasName = bundledAliasSource === null ? null : explicitSourceInput.trim().toLowerCase();
+    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, async () => {
+        const settings = await readSettings(resolvedRoots.settings_root);
+        const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
+        warnings.push(...managedStateRead.warnings);
+        const destinationDirectory = path7.join(resolvedRoots.selected_root, destinationDirectoryName);
+        const destinationExists = await pathExists(destinationDirectory);
+        const installInPlace = await areDirectoriesEquivalent(validated.directory, destinationDirectory);
+        await fs7.mkdir(resolvedRoots.selected_root, { recursive: true });
+        if (!installInPlace) {
+          await copyExtensionDirectoryForInstall(validated.directory, destinationDirectory);
+        }
+        const sourceRecord = bundledAliasName ? {
+          kind: "builtin",
+          input: bundledAliasName,
+          location: bundledAliasName,
+          name: bundledAliasName
+        } : installSource.kind === "local" ? {
+          kind: "local",
+          input: installSource.input,
+          location: installSource.absolute_path
+        } : installSource.kind === "npm" ? {
+          kind: "npm",
+          input: installSource.input,
+          location: resolvedSource.resolved_subpath ?? ".",
+          package: resolvedSource.npm_package,
+          version: resolvedSource.npm_version
+        } : {
+          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
+        };
+        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");
+        }
+        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
+        });
+      });
+    } finally {
+      if (resolvedSource.cleanup) {
+        await resolvedSource.cleanup();
+      }
+    }
+  }
+  if (action === "adopt-all") {
+    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)) ?? 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
+    });
+  }
+  if (action === "adopt") {
+    const extensionTarget = requireTarget(normalizedTarget, action);
+    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 = path7.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
+    });
+  }
+  if (action === "uninstall") {
+    const extensionTarget = requireTarget(normalizedTarget, action);
+    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 = path7.join(resolvedRoots.selected_root, candidate.directory);
+    await fs7.rm(destinationDirectory, { recursive: true, force: true });
+    const updatedState = {
+      ...managedStateRead.state,
+      updated_at: nowIso(),
+      entries: managedStateRead.state.entries.filter((entry) => normalizeExtensionNameForMatch(entry.name) !== normalizeExtensionNameForMatch(candidate.name) && normalizeExtensionNameForMatch(entry.directory) !== normalizeExtensionNameForMatch(candidate.directory))
+    };
+    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
+    });
+  }
+  if (action === "activate" || action === "deactivate") {
+    const extensionTarget = requireTarget(normalizedTarget, action);
+    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]
+      }
+    });
+  }
+  if (action === "doctor") {
+    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: global2.noExtensions === true
+    });
+    const activationResult = await activateExtensions({
+      ...loadResult,
+      loaded: loadResult.loaded
+    });
+    warnings.push(...loadResult.warnings);
+    warnings.push(...classifyDoctorLoadFailureWarnings(loadResult.failed));
+    warnings.push(...activationResult.warnings);
+    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,
+      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 = [
+      ...new Set([
+        ...triage.remediation,
+        ...loadResult.failed.length > 0 ? [
+          options.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."
+        ] : [],
+        ...activationResult.failed.length > 0 ? [
+          options.vocabulary === "package" ? "Review activation failures in pm package doctor --detail deep output." : "Review activation failures in pm extension --doctor --detail deep output."
+        ] : [],
+        ...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))
+    ];
+    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,
+            registration_index: entry.trace?.registration_index,
+            expected_schema: entry.trace?.expected_schema,
+            hint: entry.trace?.hint,
+            received: entry.trace?.received
+          }))
+        };
+      }
+    }
+    return withResult(details);
+  }
+  if (action === "explore" || action === "manage") {
+    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;
+    if (action === "explore" || options.runtimeProbe === true) {
+      const loadResult = await loadExtensions({
+        pmRoot: resolvedRoots.pm_root,
+        settings,
+        cwd: process.cwd(),
+        noExtensions: global2.noExtensions === true
+      });
+      const activationResult = await activateExtensions({
+        ...loadResult,
+        loaded: loadResult.loaded
+      });
+      warnings.push(...loadResult.warnings);
+      warnings.push(...activationResult.warnings);
+      runtimeInstalledExtensions = applyDoctorRuntimeActivationState(refreshedInstalled.extensions, loadResult, activationResult);
+      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 (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);
+  }
+  throw new PmCliError(`Unsupported extension action "${action}".`, EXIT_CODE.USAGE);
+}
+
+export {
+  parseExtensionManifest,
+  validateExtensionDirectory,
+  resolveManagedExtensionStatePath,
+  readManagedExtensionState,
+  writeManagedExtensionState,
+  parseExtensionInstallSource,
+  copyExtensionDirectoryForInstall,
+  runExtension
+};
+//# sourceMappingURL=chunk-OGZEG5TT.js.map