@unbrained/pm-cli 2026.5.30 → 2026.6.5

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

@@ -0,0 +1,2988 @@
+
+!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]="e39bfbe4-484e-5544-affb-f1f6fbd63030")}catch(e){}}();
+import {
+  splitCommaList
+} from "./chunk-LXYVKYMQ.js";
+import {
+  nowIso
+} from "./chunk-NQP3ECKF.js";
+import {
+  EXIT_CODE,
+  EXTENSION_CAPABILITY_CONTRACT,
+  KNOWN_EXTENSION_CAPABILITIES,
+  PmCliError,
+  activateExtensions,
+  isPathWithinDirectory,
+  loadExtensions,
+  nextExtensionReloadToken,
+  parseLegacyExtensionCapabilityAliasWarning,
+  parseUnknownExtensionCapabilityWarning,
+  pathExists,
+  readSettings,
+  resolveExtensionRoots,
+  resolveGlobalPmRoot,
+  resolvePmPackageRootFromModule,
+  resolvePmRoot,
+  writeSettings
+} from "./chunk-4LTBNUYT.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";
+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";
+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";
+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
+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";
+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, global, options = {}) {
+  const roots = resolveExtensionRoots(resolvePmRoot(process.cwd(), global.path), process.cwd());
+  const selectedRoot = scope === "global" ? roots.global : roots.project;
+  const managedStateRead = await readManagedExtensionState(selectedRoot);
+  const installedLocations = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope).filter((entry) => entry.source.kind !== "builtin").map((entry) => 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";
+var SCAFFOLD_MANIFEST_VERSION = 1;
+var SCAFFOLD_PM_MIN_VERSION = "2026.5.0";
+function buildStarterExtensionScaffoldFiles(extensionName, commandName, vocabulary) {
+  const packageName = `pm-${extensionName}`;
+  const manifest = `${JSON.stringify({
+    name: extensionName,
+    version: "0.1.0",
+    entry: "./index.js",
+    capabilities: ["commands"],
+    manifest_version: SCAFFOLD_MANIFEST_VERSION,
+    pm_min_version: SCAFFOLD_PM_MIN_VERSION
+  }, null, 2)}
+`;
+  const entrypoint = [
+    '/** @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: ["."],
+        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.",
+      "- `manifest.json`: extension metadata and capabilities.",
+      "- `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",
+      "```",
+      "",
+      "## Compatibility Bounds",
+      "`manifest.json` cannot hold comments, so the version-compatibility fields are documented here:",
+      `- \`manifest_version\` (integer): manifest schema generation. Leave at \`${SCAFFOLD_MANIFEST_VERSION}\` unless you adopt a newer manifest schema.`,
+      `- \`pm_min_version\` (string): lowest pm CLI version that may load this package. Scaffolded as \`${SCAFFOLD_PM_MIN_VERSION}\`. The loader blocks the package on older CLIs.`,
+      "- `pm_max_version` (string, optional): highest pm CLI version that may load this package. Add it to block CLIs that are newer than the version you have validated against. The loader blocks the package when the CLI exceeds this bound.",
+      "",
+      "## Notes",
+      "- Keep simple starter runtime behavior at the package root so local installs work without dependency bootstrapping.",
+      "- Move larger runtimes into subdirectories only after adding package dependencies and validating `pm package doctor`.",
+      "- 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,
+      "manifest.json": manifest,
+      "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",
+    "```",
+    "",
+    "## Compatibility Bounds",
+    "`manifest.json` cannot hold comments, so the version-compatibility fields are documented here:",
+    `- \`manifest_version\` (integer): manifest schema generation. Leave at \`${SCAFFOLD_MANIFEST_VERSION}\` unless you adopt a newer manifest schema.`,
+    `- \`pm_min_version\` (string): lowest pm CLI version that may load this extension. Scaffolded as \`${SCAFFOLD_PM_MIN_VERSION}\`. The loader blocks the extension on older CLIs.`,
+    "- `pm_max_version` (string, optional): highest pm CLI version that may load this extension. Add it to block CLIs that are newer than the version you have validated against. The loader blocks the extension when the CLI exceeds this bound.",
+    "",
+    "## 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 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}`;
+}
+var REGISTRATION_COLLISION_WARNING_CODES = /* @__PURE__ */ new Set([
+  "extension_command_handler_collision",
+  "extension_command_override_collision",
+  "extension_command_override_handler_overlap",
+  "extension_parser_override_collision",
+  "extension_preflight_override_collision",
+  "extension_renderer_collision",
+  "extension_service_override_collision"
+]);
+function isRegistrationCollisionWarning(warning) {
+  return REGISTRATION_COLLISION_WARNING_CODES.has(warningCode(warning));
+}
+function isExtensionLayer(value) {
+  return value === "project" || value === "global";
+}
+function parseRegistrationCollisionWarning(warning) {
+  const parts = warning.split(":");
+  const code = parts[0];
+  if (!code || !REGISTRATION_COLLISION_WARNING_CODES.has(code)) {
+    return null;
+  }
+  const winnerLayer = parts.at(-4);
+  const winnerName = parts.at(-3)?.trim();
+  const displacedLayer = parts.at(-2);
+  const displacedName = parts.at(-1)?.trim();
+  if (!isExtensionLayer(winnerLayer) || !isExtensionLayer(displacedLayer) || !winnerName || !displacedName) {
+    return null;
+  }
+  return {
+    code,
+    winner: { layer: winnerLayer, name: winnerName },
+    displaced: { layer: displacedLayer, name: displacedName }
+  };
+}
+function collectRegistrationCollisionExtensionNames(warnings) {
+  const names = /* @__PURE__ */ new Set();
+  for (const warning of warnings) {
+    const parsed = parseRegistrationCollisionWarning(warning);
+    if (!parsed) {
+      continue;
+    }
+    names.add(parsed.winner.name);
+    names.add(parsed.displaced.name);
+  }
+  return [...names].sort((left, right) => left.localeCompare(right));
+}
+function buildRegistrationCollisionRemediation(warnings, commands) {
+  const registrationCollisionWarnings = warnings.filter(isRegistrationCollisionWarning);
+  if (registrationCollisionWarnings.length === 0) {
+    return null;
+  }
+  const collisionNames = collectRegistrationCollisionExtensionNames(registrationCollisionWarnings);
+  const collisionNameText = collisionNames.length > 0 ? ` Conflicting extensions: ${collisionNames.join(", ")}.` : "";
+  return `Extension registration collisions or handler/override overlaps detected.${collisionNameText} Single-winner surfaces can hide earlier package behavior. Deactivate one conflicting package with ${commands.deactivate}, or scope registration surfaces in extensions.policy.extension_overrides, then rerun ${commands.doctor}.`;
+}
+function classifyDoctorLoadFailureWarnings(loadFailures) {
+  const warnings = [];
+  for (const failure of loadFailures) {
+    const normalizedError = failure.error.toLowerCase();
+    if (normalizedError.includes("cannot find package '@unbrained/pm-cli'") || normalizedError.includes('cannot find module "@unbrained/pm-cli"') || normalizedError.includes("cannot find module '@unbrained/pm-cli'")) {
+      warnings.push(`extension_load_failed_sdk_dependency_missing:${failure.name}`);
+    }
+    if (normalizedError.includes("cannot use import statement outside a module") || normalizedError.includes("to load an es module") || normalizedError.includes("must use import to load es module")) {
+      warnings.push(`extension_load_failed_module_mode_mismatch:${failure.name}`);
+    }
+  }
+  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+}
+function classifyDoctorActivationFailureWarnings(activationFailures = []) {
+  const failures = Array.isArray(activationFailures) ? activationFailures : [];
+  const warnings = [];
+  for (const failure of failures) {
+    if (!failure || typeof failure.name !== "string") {
+      continue;
+    }
+    const missingCapability = failure.trace?.missing_capability ?? failure.trace?.capability;
+    if (typeof missingCapability === "string" && missingCapability.trim().length > 0) {
+      warnings.push(`extension_capability_missing:${failure.name}:${missingCapability.trim().toLowerCase()}`);
+    }
+  }
+  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+}
+function 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) {
+    const registrationCollisionRemediation = buildRegistrationCollisionRemediation(normalizedWarnings, {
+      deactivate: `${lifecycleFlagCommand(options, "deactivate")} <name> ${scopeFlag}`,
+      doctor: `${lifecycleFlagCommand(options, "doctor")} ${scopeFlag} --detail deep --trace`
+    });
+    if (registrationCollisionRemediation) {
+      remediation.push(registrationCollisionRemediation);
+    }
+    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_capability_missing:"))) {
+      remediation.push(`Extension activation failed because code registered a surface missing from manifest capabilities. Run ${lifecycleFlagCommand(options, "doctor")} ${scopeFlag} --detail deep --trace and add the reported missing_capability to manifest.json before publishing.`);
+    }
+    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_output_service_override_global:") || warning.startsWith("extension_output_renderer_override_global:"))) {
+      remediation.push("Global output service/renderer overrides are active. For output_format, return context.payload/null/undefined unless the extension owns the command. For renderers, return null for unrelated payloads so pm falls back to native rendering.");
+    }
+    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 (normalizedWarnings.some((warning) => warning.startsWith("extension_pm_min_version_") || warning.startsWith("extension_pm_max_version_"))) {
+      remediation.push(`Extension pm version-bound warnings detected. Align each package manifest's pm_min_version/pm_max_version with the installed pm CLI version (see the warning's required/allowed=...:current=... details), or upgrade/downgrade the pm CLI to satisfy the declared bounds, then rerun ${lifecycleFlagCommand(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
+var execFileAsync2 = promisify2(execFile2);
+var EXTENSION_INSTALL_COPY_ATTEMPTS = 3;
+var EXTENSION_INSTALL_LOCK_ATTEMPTS = 120;
+var EXTENSION_INSTALL_LOCK_DELAY_MS = 250;
+var EXTENSION_INSTALL_LOCK_STALE_MS = 12e4;
+var NATIVE_OUTPUT_MARKER = "__pm_native_output";
+function buildExtensionPolicyDetails(policy) {
+  const overrides = (policy.extension_overrides ?? []).map((override) => ({
+    name: override.name.trim(),
+    disabled: override.disabled === true ? true : void 0,
+    require_trusted: override.require_trusted === true ? true : void 0,
+    require_provenance: override.require_provenance === true ? true : void 0,
+    sandbox_profile: override.sandbox_profile,
+    allowed_capabilities: normalizeStringList(override.allowed_capabilities ?? []),
+    blocked_capabilities: normalizeStringList(override.blocked_capabilities ?? []),
+    allowed_surfaces: normalizeStringList(override.allowed_surfaces ?? []),
+    blocked_surfaces: normalizeStringList(override.blocked_surfaces ?? []),
+    allowed_commands: normalizeStringList(override.allowed_commands ?? []),
+    blocked_commands: normalizeStringList(override.blocked_commands ?? []),
+    allowed_actions: normalizeStringList(override.allowed_actions ?? []),
+    blocked_actions: normalizeStringList(override.blocked_actions ?? []),
+    allowed_services: normalizeStringList(override.allowed_services ?? []),
+    blocked_services: normalizeStringList(override.blocked_services ?? [])
+  })).filter((override) => override.name.length > 0).sort((left, right) => left.name.localeCompare(right.name));
+  return {
+    mode: policy.mode,
+    trust_mode: policy.trust_mode,
+    require_provenance: policy.require_provenance === true,
+    trusted_extensions: normalizeStringList(policy.trusted_extensions ?? []),
+    default_sandbox_profile: policy.default_sandbox_profile ?? "none",
+    allowed_extensions: normalizeStringList(policy.allowed_extensions ?? []),
+    blocked_extensions: normalizeStringList(policy.blocked_extensions ?? []),
+    allowed_capabilities: normalizeStringList(policy.allowed_capabilities ?? []),
+    blocked_capabilities: normalizeStringList(policy.blocked_capabilities ?? []),
+    allowed_surfaces: normalizeStringList(policy.allowed_surfaces ?? []),
+    blocked_surfaces: normalizeStringList(policy.blocked_surfaces ?? []),
+    allowed_commands: normalizeStringList(policy.allowed_commands ?? []),
+    blocked_commands: normalizeStringList(policy.blocked_commands ?? []),
+    allowed_actions: normalizeStringList(policy.allowed_actions ?? []),
+    blocked_actions: normalizeStringList(policy.blocked_actions ?? []),
+    allowed_services: normalizeStringList(policy.allowed_services ?? []),
+    blocked_services: normalizeStringList(policy.blocked_services ?? []),
+    extension_overrides: overrides.map((override) => ({
+      name: override.name,
+      ...override.disabled === true ? { disabled: true } : {},
+      ...override.require_trusted === true ? { require_trusted: true } : {},
+      ...override.require_provenance === true ? { require_provenance: true } : {},
+      ...override.sandbox_profile ? { sandbox_profile: override.sandbox_profile } : {},
+      ...override.allowed_capabilities.length > 0 ? { allowed_capabilities: override.allowed_capabilities } : {},
+      ...override.blocked_capabilities.length > 0 ? { blocked_capabilities: override.blocked_capabilities } : {},
+      ...override.allowed_surfaces.length > 0 ? { allowed_surfaces: override.allowed_surfaces } : {},
+      ...override.blocked_surfaces.length > 0 ? { blocked_surfaces: override.blocked_surfaces } : {},
+      ...override.allowed_commands.length > 0 ? { allowed_commands: override.allowed_commands } : {},
+      ...override.blocked_commands.length > 0 ? { blocked_commands: override.blocked_commands } : {},
+      ...override.allowed_actions.length > 0 ? { allowed_actions: override.allowed_actions } : {},
+      ...override.blocked_actions.length > 0 ? { blocked_actions: override.blocked_actions } : {},
+      ...override.allowed_services.length > 0 ? { allowed_services: override.allowed_services } : {},
+      ...override.blocked_services.length > 0 ? { blocked_services: override.blocked_services } : {}
+    }))
+  };
+}
+function isRetriableExtensionInstallCopyError(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === "EEXIST" || code === "ENOTEMPTY" || code === "ENOENT";
+}
+function isErrnoCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function 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 global = options.global === true;
+  if (projectLike && global) {
+    throw new PmCliError('Options "--project/--local" and "--global" are mutually exclusive.', EXIT_CODE.USAGE);
+  }
+  return global ? "global" : "project";
+}
+function resolveUpdateCheckResolution(managedEntry) {
+  if (!managedEntry) {
+    return {
+      status: "skipped_unmanaged",
+      reason: "extension_not_managed"
+    };
+  }
+  if (managedEntry.source.kind !== "github") {
+    return {
+      status: "skipped_non_github",
+      reason: `managed_source_kind_${managedEntry.source.kind}`
+    };
+  }
+  const updateError = typeof managedEntry.update_error === "string" ? managedEntry.update_error.trim() : "";
+  if (updateError.length > 0) {
+    return {
+      status: "failed",
+      reason: updateError
+    };
+  }
+  if (typeof managedEntry.last_update_check_at === "string" && managedEntry.last_update_check_at.trim().length > 0) {
+    if (managedEntry.update_available === true) {
+      return {
+        status: "checked",
+        reason: "update_available"
+      };
+    }
+    if (managedEntry.update_available === false) {
+      return {
+        status: "checked",
+        reason: "up_to_date"
+      };
+    }
+    return {
+      status: "checked",
+      reason: "checked_without_commit_baseline"
+    };
+  }
+  return {
+    status: "not_checked",
+    reason: "no_update_check_recorded"
+  };
+}
+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, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  const roots = resolveExtensionRoots(pmRoot, process.cwd());
+  const settingsRoot = scope === "global" ? resolveGlobalPmRoot(process.cwd()) : pmRoot;
+  const selectedRoot = scope === "global" ? roots.global : roots.project;
+  return {
+    pm_root: pmRoot,
+    scope,
+    settings_root: settingsRoot,
+    selected_root: selectedRoot,
+    roots
+  };
+}
+function resolveGithubOption(options) {
+  if (typeof options.gh === "string" && typeof options.github === "string" && options.gh.trim() !== options.github.trim()) {
+    throw new PmCliError('Options "--gh" and "--github" must match when both are provided.', EXIT_CODE.USAGE);
+  }
+  if (typeof options.gh === "string" && options.gh.trim().length > 0) {
+    return options.gh.trim();
+  }
+  if (typeof options.github === "string" && options.github.trim().length > 0) {
+    return options.github.trim();
+  }
+  return void 0;
+}
+function 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;
+}
+function collectGlobalOutputOverrideDoctorWarnings(activationResult) {
+  const warnings = [];
+  for (const entry of activationResult.services.overrides) {
+    if (entry.service !== "output_format") {
+      continue;
+    }
+    warnings.push(`extension_output_service_override_global:${entry.service}:${entry.layer}:${entry.name}`);
+  }
+  for (const entry of activationResult.renderers.overrides) {
+    warnings.push(`extension_output_renderer_override_global:${entry.format}:${entry.layer}:${entry.name}`);
+  }
+  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+}
+async function runExtension(target, options, global) {
+  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, global);
+  const warnings = [];
+  const withResult = (details) => {
+    const result = {
+      ok: true,
+      action,
+      scope,
+      roots: action === "catalog" && typeof options.fields === "string" && options.fields.trim().length > 0 ? {
+        project: "project",
+        global: "global",
+        selected: scope,
+        settings_root: "project"
+      } : {
+        project: resolvedRoots.roots.project,
+        global: resolvedRoots.roots.global,
+        selected: resolvedRoots.selected_root,
+        settings_root: resolvedRoots.settings_root
+      },
+      warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
+      details
+    };
+    if (action === "doctor") {
+      Object.defineProperty(result, NATIVE_OUTPUT_MARKER, {
+        value: true,
+        enumerable: false,
+        configurable: false
+      });
+    }
+    return result;
+  };
+  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: global.noExtensions,
+      reload_token: reloadToken,
+      cache_bust: true
+    });
+    warnings.push(...reloaded.warnings);
+    const activation = await activateExtensions(reloaded);
+    warnings.push(...activation.warnings);
+    const details = {
+      reload: {
+        token: reloadToken,
+        cache_bust: true,
+        watch: options.watch === true
+      },
+      loaded_count: reloaded.loaded.length,
+      failed_count: reloaded.failed.length,
+      activated_count: Math.max(0, reloaded.loaded.length - activation.failed.length),
+      activation_failed_count: activation.failed.length,
+      loaded_extensions: reloaded.loaded.map((entry) => ({
+        name: entry.name,
+        layer: entry.layer,
+        version: entry.version
+      })),
+      failed_extensions: reloaded.failed.map((entry) => ({
+        name: entry.name,
+        layer: entry.layer,
+        error: entry.error
+      })),
+      activation_failures: activation.failed.map((entry) => ({
+        name: entry.name,
+        layer: entry.layer,
+        error: entry.error
+      }))
+    };
+    if (options.watch === true) {
+      warnings.push("extension_reload_watch_hint:watch_mode_requested_non_interactive_single_pass_only");
+    }
+    return withResult(details);
+  }
+  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, global, 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 }, global)
+        });
+      }
+      for (const entry of packages) {
+        warnings.push(...entry.result.warnings);
+      }
+      return withResult({
+        installed_all: true,
+        installed_count: packages.length,
+        packages: packages.map((entry) => ({
+          alias: entry.alias,
+          ok: entry.result.ok,
+          extension: entry.result.details.extension,
+          source: entry.result.details.source,
+          destination_path: entry.result.details.destination_path,
+          activated: entry.result.details.activated,
+          settings_changed: entry.result.details.settings_changed,
+          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: global.noExtensions === true
+    });
+    const activationResult = await activateExtensions({
+      ...loadResult,
+      loaded: loadResult.loaded
+    });
+    warnings.push(...loadResult.warnings);
+    warnings.push(...classifyDoctorLoadFailureWarnings(loadResult.failed));
+    warnings.push(...activationResult.warnings);
+    warnings.push(...classifyDoctorActivationFailureWarnings(activationResult.failed));
+    warnings.push(...collectGlobalOutputOverrideDoctorWarnings(activationResult));
+    const runtimeInstalledExtensions = applyDoctorRuntimeActivationState(refreshedInstalled.extensions, loadResult, activationResult);
+    const doctorConsistency = buildDoctorConsistencySummary(scope, runtimeInstalledExtensions, loadResult.loaded.map((entry) => ({ layer: entry.layer, name: entry.name })), loadResult.failed.map((entry) => ({ name: entry.name })), loadResult.disabled_by_flag);
+    warnings.push(...doctorConsistency.warnings);
+    const updateCheckWarnings = runtimeInstalledExtensions.filter((entry) => entry.update_check_status === "failed").map((entry) => `extension_update_check_failed:${entry.name}`);
+    warnings.push(...updateCheckWarnings);
+    const triage = buildExtensionTriageSummary(scope, warnings, runtimeInstalledExtensions, options);
+    warnings.push(...triage.warnings);
+    const normalizedWarnings = [...triage.warnings];
+    const policySummary = {
+      mode: loadResult.policy.mode,
+      trust_mode: loadResult.policy.trust_mode,
+      require_provenance: loadResult.policy.require_provenance,
+      default_sandbox_profile: loadResult.policy.default_sandbox_profile,
+      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,
+            capability: entry.trace?.capability,
+            missing_capability: entry.trace?.missing_capability,
+            registration_index: entry.trace?.registration_index,
+            expected_schema: entry.trace?.expected_schema,
+            hint: entry.trace?.hint,
+            received: entry.trace?.received
+          }))
+        };
+      }
+    }
+    return withResult(details);
+  }
+  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: global.noExtensions === true
+      });
+      const activationResult = await activateExtensions({
+        ...loadResult,
+        loaded: loadResult.loaded
+      });
+      warnings.push(...loadResult.warnings);
+      warnings.push(...activationResult.warnings);
+      runtimeInstalledExtensions = applyDoctorRuntimeActivationState(refreshedInstalled.extensions, loadResult, activationResult);
+      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,
+  buildRegistrationCollisionRemediation,
+  copyExtensionDirectoryForInstall,
+  runExtension
+};
+//# sourceMappingURL=chunk-EHXPIKKP.js.map
+
+//# debugId=e39bfbe4-484e-5544-affb-f1f6fbd63030