@unbrained/pm-cli 2026.7.4 → 2026.7.5

package/dist/cli-bundle/chunks/{chunk-J4KNRDI3.js → chunk-JFCVQXZX.js}

@@ -1,30 +1,41 @@
 
-!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]="cf15ae81-2815-5bb4-99ed-f5da84702f95")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="470b447f-8000-5489-b56e-3bbefd5e828d")}catch(e){}}();
 import {
-  splitCommaList
-} from "./chunk-P4SESZGT.js";
+  buildExtensionDescribeResult
+} from "./chunk-K32L7HZO.js";
 import {
-  ensureTypeFolderScaffold
-} from "./chunk-YZWXMDNH.js";
+  PM_PACKAGE_RESOURCE_KINDS,
+  collectPackageExtensionDirectories,
+  readPmPackageManifest
+} from "./chunk-OK5NXCZB.js";
 import {
-  buildExtensionDescribeResult,
   scaffoldExtensionProject
-} from "./chunk-M34MVAOP.js";
+} from "./chunk-53BTLLAF.js";
+import {
+  splitCommaList
+} from "./chunk-P4SESZGT.js";
 import {
   normalizeExtensionNameForMatch,
   normalizeManagedDirectoryName,
   normalizeStringList,
   parseExtensionManifest,
   validateExtensionDirectory
-} from "./chunk-6QY2NA2M.js";
+} from "./chunk-FUM6UMY4.js";
+import {
+  ensureTypeFolderScaffold
+} from "./chunk-PJ3A56YF.js";
 import {
   nowIso
-} from "./chunk-FMWQRMHS.js";
+} from "./chunk-FJRKQREY.js";
+import {
+  PmCliError,
+  readSettings,
+  writeSettings
+} from "./chunk-US3T3W5J.js";
 import {
   EXIT_CODE,
   EXTENSION_CAPABILITY_CONTRACT,
   KNOWN_EXTENSION_CAPABILITIES,
-  PmCliError,
   activateExtensions,
   isPathWithinDirectory,
   levenshteinDistanceWithinLimit,
@@ -33,20 +44,18 @@ import {
   parseLegacyExtensionCapabilityAliasWarning,
   parseUnknownExtensionCapabilityWarning,
   pathExists,
-  readSettings,
   reconcileExtensionCapabilityUsage,
   resolveExtensionRoots,
   resolveGlobalPmRoot,
   resolvePmPackageRootFromModule,
-  resolvePmRoot,
-  writeSettings
-} from "./chunk-SL2ANJSV.js";
+  resolvePmRoot
+} from "./chunk-YD5FML7K.js";
 
 // dist/cli/commands/extension.js
 import { execFile as execFile2 } from "node:child_process";
-import fs5 from "node:fs/promises";
+import fs4 from "node:fs/promises";
 import os2 from "node:os";
-import path5 from "node:path";
+import path4 from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // dist/cli/commands/extension/managed-state.js
@@ -222,231 +231,11 @@ function upsertManagedEntry(state, entry) {
 
 // dist/cli/commands/extension/install-sources.js
 import { execFile } from "node:child_process";
-import fs3 from "node:fs/promises";
+import fs2 from "node:fs/promises";
 import os from "node:os";
-import path3 from "node:path";
+import path2 from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-
-// dist/core/packages/manifest.js
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
-var PM_PACKAGE_RESOURCE_KINDS = [
-  "extensions",
-  "docs",
-  "examples",
-  "assets",
-  "prompts"
-];
-var PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS = Object.freeze({
-  extensions: Object.freeze([
-    ".agents/pm/extensions",
-    "extensions",
-    ".custom/pm-extensions",
-    ".custom/pm-extension"
-  ]),
-  docs: Object.freeze([
-    "docs",
-    "documentation"
-  ]),
-  examples: Object.freeze([
-    "examples",
-    "docs/examples"
-  ]),
-  assets: Object.freeze([
-    "assets",
-    ".agents/pm/assets"
-  ]),
-  prompts: Object.freeze([
-    "prompts",
-    ".agents/pm/prompts"
-  ])
-});
-function isKnownPackageResourceKind(value) {
-  return PM_PACKAGE_RESOURCE_KINDS.includes(value);
-}
-function normalizePackageResourceEntries(kind, raw) {
-  if (raw === void 0 || raw === null) {
-    return [];
-  }
-  const entries = Array.isArray(raw) ? raw : [raw];
-  const normalized = [];
-  for (const entry of entries) {
-    if (typeof entry !== "string" || entry.trim().length === 0) {
-      throw new PmCliError(`Package manifest field pm.${kind} must contain string paths.`, EXIT_CODE.USAGE);
-    }
-    normalized.push(entry.trim());
-  }
-  return [...new Set(normalized)].sort((left, right) => left.localeCompare(right));
-}
-function normalizePackageResourceMap(raw) {
-  if (raw === void 0 || raw === null) {
-    return {};
-  }
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new PmCliError("Package manifest field pm must be an object.", EXIT_CODE.USAGE);
-  }
-  const resources = {};
-  const candidate = raw;
-  for (const [key, value] of Object.entries(candidate)) {
-    if (!isKnownPackageResourceKind(key)) {
-      continue;
-    }
-    const entries = normalizePackageResourceEntries(key, value);
-    if (entries.length > 0) {
-      resources[key] = entries;
-    }
-  }
-  return resources;
-}
-function readStringField(source, key) {
-  const value = source[key];
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-}
-function normalizeStringArray(raw) {
-  if (!Array.isArray(raw)) {
-    return void 0;
-  }
-  const values = raw.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0);
-  return values.length > 0 ? [...new Set(values)].sort((left, right) => left.localeCompare(right)) : void 0;
-}
-function readUrlLikeField(raw) {
-  if (typeof raw === "string" && raw.trim().length > 0) {
-    return raw.trim();
-  }
-  if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
-    const value = raw.url;
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-  }
-  return void 0;
-}
-function normalizeCatalogLinks(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return void 0;
-  }
-  const source = raw;
-  const links = {
-    docs: readStringField(source, "docs"),
-    npm: readStringField(source, "npm"),
-    repository: readStringField(source, "repository"),
-    report: readStringField(source, "report")
-  };
-  return Object.values(links).some((value) => typeof value === "string") ? links : void 0;
-}
-function normalizeCatalogMedia(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return void 0;
-  }
-  const source = raw;
-  const media = {
-    image: readStringField(source, "image"),
-    video: readStringField(source, "video")
-  };
-  return Object.values(media).some((value) => typeof value === "string") ? media : void 0;
-}
-function normalizePackageCatalogMetadata(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return void 0;
-  }
-  const source = raw;
-  const catalog = {
-    display_name: readStringField(source, "display_name") ?? readStringField(source, "displayName"),
-    category: readStringField(source, "category"),
-    summary: readStringField(source, "summary"),
-    links: normalizeCatalogLinks(source.links),
-    media: normalizeCatalogMedia(source.media),
-    tags: normalizeStringArray(source.tags)
-  };
-  return Object.values(catalog).some((value) => value !== void 0) ? catalog : void 0;
-}
-async function readPmPackageManifest(packageRoot) {
-  const packageJsonPath = path2.join(packageRoot, "package.json");
-  if (!await pathExists(packageJsonPath)) {
-    return {
-      source: "convention",
-      resources: {}
-    };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(await fs2.readFile(packageJsonPath, "utf8"));
-  } catch (error) {
-    throw new PmCliError(`Failed to parse package manifest at "${packageJsonPath}": ${String(error)}`, EXIT_CODE.USAGE);
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new PmCliError(`Package manifest at "${packageJsonPath}" must be a JSON object.`, EXIT_CODE.USAGE);
-  }
-  const packageJson = parsed;
-  const pmManifest = packageJson.pm;
-  const hasPmManifest = pmManifest !== void 0 && pmManifest !== null;
-  const pmManifestRecord = typeof pmManifest === "object" && pmManifest !== null && !Array.isArray(pmManifest) ? pmManifest : {};
-  return {
-    source: hasPmManifest ? "pm" : "convention",
-    package_json_path: packageJsonPath,
-    package_name: typeof packageJson.name === "string" ? packageJson.name : void 0,
-    package_version: typeof packageJson.version === "string" ? packageJson.version : void 0,
-    package_private: packageJson.private === true,
-    package_description: typeof packageJson.description === "string" ? packageJson.description : void 0,
-    package_keywords: normalizeStringArray(packageJson.keywords),
-    package_homepage: typeof packageJson.homepage === "string" ? packageJson.homepage : void 0,
-    package_repository_url: readUrlLikeField(packageJson.repository),
-    package_bugs_url: readUrlLikeField(packageJson.bugs),
-    aliases: normalizeStringArray(pmManifestRecord.aliases),
-    resources: normalizePackageResourceMap(pmManifest),
-    catalog: normalizePackageCatalogMetadata(pmManifestRecord.catalog)
-  };
-}
-async function listExtensionManifestDirectories(parentDirectory) {
-  if (!await pathExists(parentDirectory)) {
-    return [];
-  }
-  const entries = await fs2.readdir(parentDirectory, { withFileTypes: true });
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const directory = path2.join(parentDirectory, entry.name);
-    if (await pathExists(path2.join(directory, "manifest.json"))) {
-      candidates.push(directory);
-    }
-  }
-  return candidates.sort((left, right) => left.localeCompare(right));
-}
-async function collectPackageExtensionDirectories(packageRoot) {
-  if (await pathExists(path2.join(packageRoot, "manifest.json"))) {
-    return [packageRoot];
-  }
-  const manifest = await readPmPackageManifest(packageRoot);
-  const manifestEntries = manifest.resources.extensions ?? [];
-  const discovered = /* @__PURE__ */ new Set();
-  for (const entry of manifestEntries) {
-    if (entry.includes("*") || entry.startsWith("!")) {
-      throw new PmCliError(`Package extension entry "${entry}" uses a glob/exclusion pattern. pm package installs currently require concrete extension paths or directories.`, EXIT_CODE.USAGE);
-    }
-    const absolute = path2.resolve(packageRoot, entry);
-    if (!isPathWithinDirectory(packageRoot, absolute)) {
-      throw new PmCliError(`Package extension entry "${entry}" resolves outside package root.`, EXIT_CODE.USAGE);
-    }
-    if (await pathExists(path2.join(absolute, "manifest.json"))) {
-      discovered.add(absolute);
-      continue;
-    }
-    for (const child of await listExtensionManifestDirectories(absolute)) {
-      discovered.add(child);
-    }
-  }
-  if (manifestEntries.length === 0) {
-    for (const root of PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS.extensions) {
-      for (const child of await listExtensionManifestDirectories(path2.join(packageRoot, root))) {
-        discovered.add(child);
-      }
-    }
-  }
-  return [...discovered].sort((left, right) => left.localeCompare(right));
-}
-
-// dist/cli/commands/extension/install-sources.js
 var execFileAsync = promisify(execFile);
 var PM_CLI_PACKAGE_NAME = "@unbrained/pm-cli";
 function parseGithubPathSpec(pathSpec, input, refOverride) {
@@ -540,7 +329,7 @@ function parseExtensionInstallSource(input, options = {}) {
   return {
     kind: "local",
     input: normalizedInput,
-    absolute_path: path3.resolve(process.cwd(), normalizedInput)
+    absolute_path: path2.resolve(process.cwd(), normalizedInput)
   };
 }
 async function runGitCommand(args, execRunner = execFileAsync) {
@@ -641,8 +430,8 @@ function wrapNpmPackResolutionError(spec, error) {
   return new PmCliError(recovery.message, EXIT_CODE.NOT_FOUND, recovery.context);
 }
 async function resolveLocalNpmPackagePath(spec) {
-  if (path3.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..")) {
-    const absolutePath = path3.resolve(process.cwd(), spec);
+  if (path2.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..")) {
+    const absolutePath = path2.resolve(process.cwd(), spec);
     return await pathExists(absolutePath) ? absolutePath : null;
   }
   try {
@@ -654,7 +443,7 @@ async function resolveLocalNpmPackagePath(spec) {
   } catch {
   }
   if (!/^[a-z][a-z0-9+.-]*:/i.test(spec)) {
-    const absolutePath = path3.resolve(process.cwd(), spec);
+    const absolutePath = path2.resolve(process.cwd(), spec);
     if (await pathExists(absolutePath)) {
       return absolutePath;
     }
@@ -690,7 +479,7 @@ function normalizeNpmLocalFileAliasSpec(spec, cwd = process.cwd()) {
     return spec;
   }
   if (!target.startsWith("/")) {
-    return `${packageName}@${path3.resolve(cwd, target)}`;
+    return `${packageName}@${path2.resolve(cwd, target)}`;
   }
   let decodedPath;
   try {
@@ -707,7 +496,7 @@ function parsePackedNpmPackage(stdout, packDirectory) {
     const first = Array.isArray(parsed) ? parsed[0] : void 0;
     if (first && typeof first.filename === "string" && first.filename.trim().length > 0) {
       return {
-        tarball: path3.resolve(packDirectory, first.filename),
+        tarball: path2.resolve(packDirectory, first.filename),
         package: typeof first.name === "string" ? first.name : void 0,
         version: typeof first.version === "string" ? first.version : void 0
       };
@@ -719,7 +508,7 @@ function parsePackedNpmPackage(stdout, packDirectory) {
     throw new PmCliError("npm pack did not report a tarball filename.", EXIT_CODE.GENERIC_FAILURE);
   }
   return {
-    tarball: path3.resolve(packDirectory, lastLine)
+    tarball: path2.resolve(packDirectory, lastLine)
   };
 }
 async function resolveNpmSourceDirectory(source) {
@@ -728,8 +517,8 @@ async function resolveNpmSourceDirectory(source) {
 async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
   const localPackageRoot = await resolveLocalNpmPackagePath(source.spec);
   if (localPackageRoot) {
-    const packageJsonPath = path3.join(localPackageRoot, "package.json");
-    const packageJson = await pathExists(packageJsonPath) ? JSON.parse(await fs3.readFile(packageJsonPath, "utf8")) : {};
+    const packageJsonPath = path2.join(localPackageRoot, "package.json");
+    const packageJson = await pathExists(packageJsonPath) ? JSON.parse(await fs2.readFile(packageJsonPath, "utf8")) : {};
     return {
       directory: await resolvePackageExtensionDirectory(localPackageRoot, source.input),
       package: typeof packageJson.name === "string" ? packageJson.name : void 0,
@@ -738,17 +527,17 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
       }
     };
   }
-  const tempRoot = await fs3.mkdtemp(path3.join(os.tmpdir(), "pm-npm-package-source-"));
-  const packDirectory = path3.join(tempRoot, "pack");
-  const extractDirectory = path3.join(tempRoot, "extract");
-  await fs3.mkdir(packDirectory, { recursive: true });
-  await fs3.mkdir(extractDirectory, { recursive: true });
+  const tempRoot = await fs2.mkdtemp(path2.join(os.tmpdir(), "pm-npm-package-source-"));
+  const packDirectory = path2.join(tempRoot, "pack");
+  const extractDirectory = path2.join(tempRoot, "extract");
+  await fs2.mkdir(packDirectory, { recursive: true });
+  await fs2.mkdir(extractDirectory, { recursive: true });
   try {
     const packSpec = await resolveNpmPackSpec(source.spec);
     const packStdout = await npmRunner(["pack", packSpec, "--json", "--pack-destination", packDirectory]);
     const packed = parsePackedNpmPackage(packStdout, packDirectory);
     await execFileAsync("tar", ["-xzf", packed.tarball, "-C", extractDirectory], { encoding: "utf8" });
-    const packageRoot = path3.join(extractDirectory, "package");
+    const packageRoot = path2.join(extractDirectory, "package");
     await installNpmPackageRuntimeDependencies(packageRoot);
     const directory = await resolvePackageExtensionDirectory(packageRoot, source.input);
     return {
@@ -756,11 +545,11 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
       package: packed.package,
       version: packed.version,
       cleanup: async () => {
-        await fs3.rm(tempRoot, { recursive: true, force: true });
+        await fs2.rm(tempRoot, { recursive: true, force: true });
       }
     };
   } catch (error) {
-    await fs3.rm(tempRoot, { recursive: true, force: true });
+    await fs2.rm(tempRoot, { recursive: true, force: true });
     const wrappedError = wrapNpmPackResolutionError(source.spec, error);
     if (wrappedError) {
       throw wrappedError;
@@ -769,13 +558,13 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
   }
 }
 async function installNpmPackageRuntimeDependencies(packageRoot) {
-  const packageJsonPath = path3.join(packageRoot, "package.json");
+  const packageJsonPath = path2.join(packageRoot, "package.json");
   if (!await pathExists(packageJsonPath)) {
     return;
   }
   let parsed;
   try {
-    parsed = JSON.parse(await fs3.readFile(packageJsonPath, "utf8"));
+    parsed = JSON.parse(await fs2.readFile(packageJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -792,12 +581,12 @@ async function installNpmPackageRuntimeDependencies(packageRoot) {
   delete runtimeOnlyManifest.devDependencies;
   const installManifest = { ...runtimeOnlyManifest };
   removeHostedPmCliDependency(installManifest);
-  await fs3.writeFile(packageJsonPath, `${JSON.stringify(installManifest, null, 2)}
+  await fs2.writeFile(packageJsonPath, `${JSON.stringify(installManifest, null, 2)}
 `, "utf8");
   try {
     await Promise.all([
-      fs3.rm(path3.join(packageRoot, "package-lock.json"), { force: true }),
-      fs3.rm(path3.join(packageRoot, "npm-shrinkwrap.json"), { force: true })
+      fs2.rm(path2.join(packageRoot, "package-lock.json"), { force: true }),
+      fs2.rm(path2.join(packageRoot, "npm-shrinkwrap.json"), { force: true })
     ]);
     if (dependencySpecs.length > 0) {
       await runNpmCommand([
@@ -815,7 +604,7 @@ async function installNpmPackageRuntimeDependencies(packageRoot) {
       await linkHostedPmCliDependency(packageRoot);
     }
   } finally {
-    await fs3.writeFile(packageJsonPath, `${JSON.stringify(runtimeOnlyManifest, null, 2)}
+    await fs2.writeFile(packageJsonPath, `${JSON.stringify(runtimeOnlyManifest, null, 2)}
 `, "utf8");
   }
 }
@@ -845,11 +634,11 @@ function removeHostedPmCliDependency(manifest) {
 async function linkHostedPmCliDependency(packageRoot) {
   const hostPackageRoot = resolvePmPackageRootFromModule(import.meta.url, ["../../../.."]);
   const [scope, packageName] = PM_CLI_PACKAGE_NAME.split("/");
-  const scopedDirectory = path3.join(packageRoot, "node_modules", scope);
-  const linkPath = path3.join(scopedDirectory, packageName);
-  await fs3.mkdir(scopedDirectory, { recursive: true });
-  await fs3.rm(linkPath, { recursive: true, force: true });
-  await fs3.symlink(hostPackageRoot, linkPath, resolveDirectorySymlinkType(process.platform));
+  const scopedDirectory = path2.join(packageRoot, "node_modules", scope);
+  const linkPath = path2.join(scopedDirectory, packageName);
+  await fs2.mkdir(scopedDirectory, { recursive: true });
+  await fs2.rm(linkPath, { recursive: true, force: true });
+  await fs2.symlink(hostPackageRoot, linkPath, resolveDirectorySymlinkType(process.platform));
 }
 function resolveDirectorySymlinkType(platform) {
   return platform === "win32" ? "junction" : "dir";
@@ -875,7 +664,7 @@ async function resolvePackageExtensionDirectory(packageRoot, sourceLabel) {
     return discovered[0];
   }
   if (discovered.length > 1) {
-    const choices = discovered.map((entry) => path3.relative(packageRoot, entry).replaceAll(path3.sep, "/")).sort((left, right) => left.localeCompare(right));
+    const choices = discovered.map((entry) => path2.relative(packageRoot, entry).replaceAll(path2.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);
@@ -884,33 +673,33 @@ async function resolveGithubSourceDirectory(cloneDirectory, source) {
   const candidatePaths = [];
   if (source.subpath) {
     candidatePaths.push(source.subpath);
-    candidatePaths.push(path3.posix.join(".agents/pm/extensions", source.subpath));
-    candidatePaths.push(path3.posix.join(".custom/pm-extensions", source.subpath));
-    candidatePaths.push(path3.posix.join(".custom/pm-extension", source.subpath));
+    candidatePaths.push(path2.posix.join(".agents/pm/extensions", source.subpath));
+    candidatePaths.push(path2.posix.join(".custom/pm-extensions", source.subpath));
+    candidatePaths.push(path2.posix.join(".custom/pm-extension", source.subpath));
   }
   for (const candidate of candidatePaths) {
-    const absolute = path3.resolve(cloneDirectory, candidate);
+    const absolute = path2.resolve(cloneDirectory, candidate);
     if (!isPathWithinDirectory(cloneDirectory, absolute)) {
       continue;
     }
-    if (await pathExists(path3.join(absolute, "manifest.json"))) {
+    if (await pathExists(path2.join(absolute, "manifest.json"))) {
       return { directory: absolute, resolved_subpath: candidate };
     }
   }
-  if (await pathExists(path3.join(cloneDirectory, "manifest.json"))) {
+  if (await pathExists(path2.join(cloneDirectory, "manifest.json"))) {
     return { directory: cloneDirectory, resolved_subpath: "." };
   }
   const discoveredDirectory = await resolvePackageExtensionDirectory(cloneDirectory, source.input);
   return {
     directory: discoveredDirectory,
-    resolved_subpath: path3.relative(cloneDirectory, discoveredDirectory).replaceAll(path3.sep, "/")
+    resolved_subpath: path2.relative(cloneDirectory, discoveredDirectory).replaceAll(path2.sep, "/")
   };
 }
 async function resolveInstallSource(source) {
   if (source.kind === "local") {
     let localStats;
     try {
-      localStats = await fs3.stat(source.absolute_path);
+      localStats = await fs2.stat(source.absolute_path);
     } catch {
       throw new PmCliError(`Local extension source does not exist: "${source.absolute_path}".`, EXIT_CODE.NOT_FOUND);
     }
@@ -929,12 +718,12 @@ async function resolveInstallSource(source) {
       source,
       directory: resolved.directory,
       cleanup: resolved.cleanup,
-      resolved_subpath: path3.relative(path3.dirname(resolved.directory), resolved.directory).replaceAll(path3.sep, "/"),
+      resolved_subpath: path2.relative(path2.dirname(resolved.directory), resolved.directory).replaceAll(path2.sep, "/"),
       npm_package: resolved.package,
       npm_version: resolved.version
     };
   }
-  const cloneDirectory = await fs3.mkdtemp(path3.join(os.tmpdir(), "pm-extension-source-"));
+  const cloneDirectory = await fs2.mkdtemp(path2.join(os.tmpdir(), "pm-extension-source-"));
   const cloneArgs = ["clone", "--depth", "1"];
   if (source.ref) {
     cloneArgs.push("--branch", source.ref);
@@ -950,11 +739,11 @@ async function resolveInstallSource(source) {
       resolved_subpath: resolved.resolved_subpath,
       commit,
       cleanup: async () => {
-        await fs3.rm(cloneDirectory, { recursive: true, force: true });
+        await fs2.rm(cloneDirectory, { recursive: true, force: true });
       }
     };
   } catch (error) {
-    await fs3.rm(cloneDirectory, { recursive: true, force: true });
+    await fs2.rm(cloneDirectory, { recursive: true, force: true });
     throw error;
   }
 }
@@ -962,13 +751,13 @@ async function areDirectoriesEquivalent(left, right) {
   if (!await pathExists(left) || !await pathExists(right)) {
     return false;
   }
-  const [leftRealPath, rightRealPath] = await Promise.all([fs3.realpath(left), fs3.realpath(right)]);
+  const [leftRealPath, rightRealPath] = await Promise.all([fs2.realpath(left), fs2.realpath(right)]);
   return leftRealPath === rightRealPath;
 }
 
 // dist/cli/commands/extension/bundled-catalog.js
-import fs4 from "node:fs/promises";
-import path4 from "node:path";
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
 var PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
 var LEGACY_BUNDLED_PACKAGE_ALIASES = {
   beads: {
@@ -985,7 +774,7 @@ function resolvePackageRootCandidates() {
   const candidates = [];
   const envRoot = process.env[PM_PACKAGE_ROOT_ENV];
   if (typeof envRoot === "string" && envRoot.trim().length > 0) {
-    candidates.push(path4.resolve(envRoot.trim()));
+    candidates.push(path3.resolve(envRoot.trim()));
   }
   candidates.push(resolvePmPackageRootFromModule(import.meta.url, ["../../../.."]));
   return [...new Set(candidates)];
@@ -1001,8 +790,8 @@ async function resolveBundledExtensionAliasSource(input) {
     return null;
   }
   for (const packageRoot2 of resolvePackageRootCandidates()) {
-    const legacyExtensionPath = path4.join(packageRoot2, ".agents", "pm", "extensions", alias.legacy_extension_directory);
-    if (await pathExists(path4.join(legacyExtensionPath, "manifest.json"))) {
+    const legacyExtensionPath = path3.join(packageRoot2, ".agents", "pm", "extensions", alias.legacy_extension_directory);
+    if (await pathExists(path3.join(legacyExtensionPath, "manifest.json"))) {
       return legacyExtensionPath;
     }
   }
@@ -1017,17 +806,17 @@ function derivePackageAlias(packageDirectory) {
 async function collectBundledPackageEntries() {
   const entriesByAlias = /* @__PURE__ */ new Map();
   for (const packageRoot of resolvePackageRootCandidates()) {
-    const packagesRoot = path4.join(packageRoot, "packages");
+    const packagesRoot = path3.join(packageRoot, "packages");
     if (!await pathExists(packagesRoot)) {
       continue;
     }
-    const entries = await fs4.readdir(packagesRoot, { withFileTypes: true });
+    const entries = await fs3.readdir(packagesRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || !entry.name.startsWith("pm-")) {
         continue;
       }
-      const candidateRoot = path4.join(packagesRoot, entry.name);
-      if (!await pathExists(path4.join(candidateRoot, "package.json"))) {
+      const candidateRoot = path3.join(packagesRoot, entry.name);
+      if (!await pathExists(path3.join(candidateRoot, "package.json"))) {
         continue;
       }
       const manifest = await readPmPackageManifest(candidateRoot);
@@ -1050,8 +839,8 @@ async function collectBundledPackageEntries() {
       continue;
     }
     for (const packageRoot of resolvePackageRootCandidates()) {
-      const packagePath = path4.join(packageRoot, "packages", legacy.package_directory);
-      if (await pathExists(path4.join(packagePath, "package.json"))) {
+      const packagePath = path3.join(packageRoot, "packages", legacy.package_directory);
+      if (await pathExists(path3.join(packagePath, "package.json"))) {
         entriesByAlias.set(alias, {
           alias,
           package_directory: legacy.package_directory,
@@ -1071,6 +860,14 @@ async function resolveBundledPackageRoot(alias) {
   const entry = (await collectBundledPackageEntries()).find((candidate) => candidate.alias === normalized);
   return entry?.package_root ?? null;
 }
+async function resolveBundledPackageNpmName(alias) {
+  const packageRoot = await resolveBundledPackageRoot(alias);
+  if (!packageRoot) {
+    return null;
+  }
+  const manifest = await readPmPackageManifest(packageRoot);
+  return manifest.package_name ?? null;
+}
 async function resolveBundledAliasManifestName(input) {
   const bundledAliasSource = await resolveBundledExtensionAliasSource(input);
   if (!bundledAliasSource) {
@@ -1102,7 +899,7 @@ function buildBundledCatalogPackageEntry(manifest, bundledEntry, scope, installe
     alias: bundledEntry.alias,
     bundled: true,
     available: true,
-    installed: installedBuiltinAliases.has(bundledEntry.alias) || installedLocations.has(path4.resolve(bundledEntry.package_root)),
+    installed: installedBuiltinAliases.has(bundledEntry.alias) || installedLocations.has(path3.resolve(bundledEntry.package_root)),
     install_target: bundledEntry.alias,
     install_command: `pm install ${bundledEntry.alias} ${installScopeFlag}`,
     package_name: manifest.package_name,
@@ -1127,7 +924,7 @@ async function buildBundledPackageCatalog(scope, global, options = {}) {
   const roots = resolveExtensionRoots(resolvePmRoot(process.cwd(), global.path), process.cwd());
   const selectedRoot = scope === "global" ? roots.global : roots.project;
   const managedStateRead = await readManagedExtensionState(selectedRoot);
-  const installedLocations = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope).filter((entry) => entry.source.kind !== "builtin").map((entry) => path4.resolve(entry.source.location)));
+  const installedLocations = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope).filter((entry) => entry.source.kind !== "builtin").map((entry) => path3.resolve(entry.source.location)));
   const installedBuiltinAliases = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope && entry.source.kind === "builtin").flatMap((entry) => [entry.source.name, entry.source.input, entry.source.location]).filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim().toLowerCase()));
   const packages = [];
   for (const bundledEntry of await collectBundledPackageEntries()) {
@@ -1798,11 +1595,19 @@ function sleep(ms) {
     setTimeout(resolve, ms);
   });
 }
-async function copyExtensionDirectoryForInstall(sourceDirectory, destinationDirectory, copyDirectory = fs5.cp) {
+async function ensureExtensionModuleTypeMarker(destinationDirectory) {
+  const markerPath = path4.join(destinationDirectory, "package.json");
+  if (await pathExists(markerPath)) {
+    return;
+  }
+  await fs4.writeFile(markerPath, `${JSON.stringify({ type: "module" }, null, 2)}
+`, "utf8");
+}
+async function copyExtensionDirectoryForInstall(sourceDirectory, destinationDirectory, copyDirectory = fs4.cp) {
   for (let attempt = 1; attempt <= EXTENSION_INSTALL_COPY_ATTEMPTS; attempt += 1) {
     try {
       if (await pathExists(destinationDirectory)) {
-        await fs5.rm(destinationDirectory, { recursive: true, force: true });
+        await fs4.rm(destinationDirectory, { recursive: true, force: true });
       }
       await copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destinationDirectory, copyDirectory);
       return;
@@ -1815,8 +1620,8 @@ async function copyExtensionDirectoryForInstall(sourceDirectory, destinationDire
   }
 }
 async function copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destinationDirectory, copyDirectory) {
-  const resolvedSource = path5.resolve(sourceDirectory);
-  const resolvedDestination = path5.resolve(destinationDirectory);
+  const resolvedSource = path4.resolve(sourceDirectory);
+  const resolvedDestination = path4.resolve(destinationDirectory);
   if (resolvedSource === resolvedDestination) {
     return;
   }
@@ -1824,28 +1629,28 @@ async function copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destina
     await copyDirectory(sourceDirectory, destinationDirectory, { recursive: true, force: true });
     return;
   }
-  const stagingRoot = await fs5.mkdtemp(path5.join(os2.tmpdir(), "pm-extension-copy-"));
-  const stagedDirectory = path5.join(stagingRoot, "extension");
+  const stagingRoot = await fs4.mkdtemp(path4.join(os2.tmpdir(), "pm-extension-copy-"));
+  const stagedDirectory = path4.join(stagingRoot, "extension");
   try {
     await copyDirectory(sourceDirectory, stagedDirectory, { recursive: true, force: true });
     await copyDirectory(stagedDirectory, destinationDirectory, { recursive: true, force: true });
   } finally {
-    await fs5.rm(stagingRoot, { recursive: true, force: true });
+    await fs4.rm(stagingRoot, { recursive: true, force: true });
   }
 }
 async function withExtensionInstallLock(settingsRoot, destinationDirectoryName, run, options) {
-  const lockRoot = path5.join(settingsRoot, "runtime", "extension-install-locks");
-  const lockPath = path5.join(lockRoot, `${destinationDirectoryName}.lock`);
-  await fs5.mkdir(lockRoot, { recursive: true });
+  const lockRoot = path4.join(settingsRoot, "runtime", "extension-install-locks");
+  const lockPath = path4.join(lockRoot, `${destinationDirectoryName}.lock`);
+  await fs4.mkdir(lockRoot, { recursive: true });
   const attempts = Math.max(1, Math.floor(options?.attempts ?? EXTENSION_INSTALL_LOCK_ATTEMPTS));
   const delayMs = Math.max(0, Math.floor(options?.delay_ms ?? EXTENSION_INSTALL_LOCK_DELAY_MS));
   const staleMs = Math.max(0, Math.floor(options?.stale_ms ?? EXTENSION_INSTALL_LOCK_STALE_MS));
   let acquired = false;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     try {
-      await fs5.mkdir(lockPath);
+      await fs4.mkdir(lockPath);
       acquired = true;
-      await fs5.writeFile(path5.join(lockPath, "owner.json"), `${JSON.stringify({ pid: process.pid, created_at: nowIso(), destination: destinationDirectoryName }, null, 2)}
+      await fs4.writeFile(path4.join(lockPath, "owner.json"), `${JSON.stringify({ pid: process.pid, created_at: nowIso(), destination: destinationDirectoryName }, null, 2)}
 `, "utf8");
       break;
     } catch (error) {
@@ -1854,12 +1659,12 @@ async function withExtensionInstallLock(settingsRoot, destinationDirectoryName,
       }
       let stat = null;
       try {
-        stat = await fs5.stat(lockPath);
+        stat = await fs4.stat(lockPath);
       } catch {
         stat = null;
       }
       if (stat && Date.now() - stat.mtimeMs > staleMs) {
-        await fs5.rm(lockPath, { recursive: true, force: true });
+        await fs4.rm(lockPath, { recursive: true, force: true });
         continue;
       }
       await sleep(delayMs);
@@ -1871,7 +1676,7 @@ async function withExtensionInstallLock(settingsRoot, destinationDirectoryName,
   try {
     return await run();
   } finally {
-    await fs5.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    await fs4.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function resolveInstalledExtensionCandidate(installed, extensionTarget) {
@@ -2128,7 +1933,7 @@ async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
       warnings: []
     };
   }
-  const entries = await fs5.readdir(extensionsRoot, { withFileTypes: true });
+  const entries = await fs4.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();
@@ -2139,8 +1944,8 @@ async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
   const warnings = [];
   const summaries = [];
   for (const directoryName of directories) {
-    const extensionDirectory = path5.join(extensionsRoot, directoryName);
-    const manifestPath = path5.join(extensionDirectory, "manifest.json");
+    const extensionDirectory = path4.join(extensionsRoot, directoryName);
+    const manifestPath = path4.join(extensionDirectory, "manifest.json");
     if (!await pathExists(manifestPath)) {
       warnings.push(`extension_manifest_missing:${scope}:${directoryName}`);
       const managedEntry2 = managedByDirectory.get(normalizeExtensionNameForMatch(directoryName));
@@ -2155,7 +1960,7 @@ async function listInstalledExtensions(extensionsRoot, scope, settings, state) {
     }
     let rawManifest;
     try {
-      rawManifest = JSON.parse(await fs5.readFile(manifestPath, "utf8"));
+      rawManifest = JSON.parse(await fs4.readFile(manifestPath, "utf8"));
     } catch {
       warnings.push(`extension_manifest_invalid_json:${scope}:${directoryName}`);
       continue;
@@ -2188,7 +1993,7 @@ function summarizeRuntimeCommandPathsForExtension(extensionName, installed) {
   };
 }
 function resolveCommandDiscoveryPackageName(extensionName, source) {
-  if (source.kind === "npm" && typeof source.package === "string" && source.package.trim().length > 0) {
+  if (typeof source.package === "string" && source.package.trim().length > 0) {
     return source.package.trim();
   }
   if (source.kind === "builtin" && typeof source.name === "string" && source.name.trim().length > 0) {
@@ -2319,7 +2124,7 @@ async function adoptUnmanagedExtensions(extensionsRoot, scope, installedExtensio
   let nextState = state;
   const adoptedEntries = [];
   for (const candidate of sortedCandidates) {
-    const extensionDirectory = path5.join(extensionsRoot, candidate.directory);
+    const extensionDirectory = path4.join(extensionsRoot, candidate.directory);
     const validated = await validateExtensionDirectory(extensionDirectory);
     const now = nowIso();
     const sourceRecord = {
@@ -2643,13 +2448,14 @@ async function runExtensionCatalogAction(ctx) {
   }
   return withResult(await buildBundledPackageCatalog(scope, global, options));
 }
-function buildInstallManagedSource(bundledAliasName, installSource, resolvedSource) {
+function buildInstallManagedSource(bundledAliasName, bundledPackageName, installSource, resolvedSource) {
   if (bundledAliasName) {
     return {
       kind: "builtin",
       input: bundledAliasName,
       location: bundledAliasName,
-      name: bundledAliasName
+      name: bundledAliasName,
+      ...bundledPackageName === null ? {} : { package: bundledPackageName }
     };
   }
   if (installSource.kind === "local") {
@@ -2682,18 +2488,19 @@ function buildInstallManagedSource(bundledAliasName, installSource, resolvedSour
 }
 async function performExtensionInstallUnderLock(ctx, input) {
   const { scope, resolvedRoots, warnings, global, withResult } = ctx;
-  const { validated, destinationDirectoryName, bundledAliasName, installSource, resolvedSource } = input;
+  const { validated, destinationDirectoryName, bundledAliasName, bundledPackageName, installSource, resolvedSource } = input;
   const settings = await readSettings(resolvedRoots.settings_root);
   const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
   warnings.push(...managedStateRead.warnings);
-  const destinationDirectory = path5.join(resolvedRoots.selected_root, destinationDirectoryName);
+  const destinationDirectory = path4.join(resolvedRoots.selected_root, destinationDirectoryName);
   const destinationExists = await pathExists(destinationDirectory);
   const installInPlace = await areDirectoriesEquivalent(validated.directory, destinationDirectory);
-  await fs5.mkdir(resolvedRoots.selected_root, { recursive: true });
+  await fs4.mkdir(resolvedRoots.selected_root, { recursive: true });
   if (!installInPlace) {
     await copyExtensionDirectoryForInstall(validated.directory, destinationDirectory);
   }
-  const sourceRecord = buildInstallManagedSource(bundledAliasName, installSource, resolvedSource);
+  await ensureExtensionModuleTypeMarker(destinationDirectory);
+  const sourceRecord = buildInstallManagedSource(bundledAliasName, bundledPackageName, installSource, resolvedSource);
   const now = nowIso();
   const existingManagedEntry = managedStateRead.state.entries.find((entry) => normalizeExtensionNameForMatch(entry.name) === normalizeExtensionNameForMatch(validated.manifest.name));
   const sourceUnchanged = existingManagedEntry !== void 0 && existingManagedEntry.manifest_version === validated.manifest.version && managedExtensionSourcesEquivalent(existingManagedEntry.source, sourceRecord);
@@ -2788,6 +2595,7 @@ async function runExtensionInstallAction(ctx) {
   }
   const bundledAliasSource = typeof githubOption === "string" ? null : await resolveBundledExtensionAliasSource(explicitSourceInput);
   const bundledAliasName = bundledAliasSource === null ? null : explicitSourceInput.trim().toLowerCase();
+  const bundledPackageName = bundledAliasName === null ? null : await resolveBundledPackageNpmName(bundledAliasName);
   const sourceInput = bundledAliasSource ?? explicitSourceInput;
   const installSource = parseExtensionInstallSource(sourceInput, {
     forceGithub: typeof githubOption === "string",
@@ -2801,6 +2609,7 @@ async function runExtensionInstallAction(ctx) {
       validated,
       destinationDirectoryName,
       bundledAliasName,
+      bundledPackageName,
       installSource,
       resolvedSource
     }));
@@ -2872,7 +2681,7 @@ async function runExtensionAdoptAction(ctx) {
       }
     });
   }
-  const extensionDirectory = path5.join(resolvedRoots.selected_root, candidate.directory);
+  const extensionDirectory = path4.join(resolvedRoots.selected_root, candidate.directory);
   const validated = await validateExtensionDirectory(extensionDirectory);
   const now = nowIso();
   const sourceRecord = githubOption === void 0 ? {
@@ -2938,8 +2747,8 @@ async function runExtensionUninstallAction(ctx) {
   if (!candidate) {
     throw new PmCliError(`Installed extension "${extensionTarget}" was not found in ${scope} scope.`, EXIT_CODE.NOT_FOUND);
   }
-  const destinationDirectory = path5.join(resolvedRoots.selected_root, candidate.directory);
-  await fs5.rm(destinationDirectory, { recursive: true, force: true });
+  const destinationDirectory = path4.join(resolvedRoots.selected_root, candidate.directory);
+  await fs4.rm(destinationDirectory, { recursive: true, force: true });
   const updatedState = {
     ...managedStateRead.state,
     updated_at: nowIso(),
@@ -3216,7 +3025,11 @@ async function runExtensionDescribeAction(ctx) {
   const describeResult = buildExtensionDescribeResult(normalizedTarget, loadResult, activationResult);
   if (normalizedTarget !== void 0 && describeResult.extensions.length === 0) {
     const noun = options.vocabulary === "package" ? "package" : "extension";
-    throw new PmCliError(`No loaded ${noun} named "${normalizedTarget}" was found in ${scope} scope. Run pm ${noun} explore to list discovered ${noun}s.`, EXIT_CODE.NOT_FOUND);
+    const loadedNames = [
+      ...new Set(loadResult.loaded.map((entry) => options.vocabulary === "package" && typeof entry.source_package === "string" && entry.source_package.trim().length > 0 ? entry.source_package.trim() : entry.name))
+    ].sort((left, right) => left.localeCompare(right));
+    const loadedHint = loadedNames.length > 0 ? ` Loaded ${noun} names: ${loadedNames.join(", ")}.` : "";
+    throw new PmCliError(`No loaded ${noun} named "${normalizedTarget}" was found in ${scope} scope.${loadedHint} Run pm ${noun} explore to list discovered ${noun}s.`, EXIT_CODE.NOT_FOUND);
   }
   return withResult({
     target: describeResult.target,
@@ -3388,6 +3201,6 @@ export {
   runExtension,
   _testOnly
 };
-//# sourceMappingURL=chunk-J4KNRDI3.js.map
+//# sourceMappingURL=chunk-JFCVQXZX.js.map
 
-//# debugId=cf15ae81-2815-5bb4-99ed-f5da84702f95
+//# debugId=470b447f-8000-5489-b56e-3bbefd5e828d