@unbrained/pm-cli 2026.7.18 → 2026.7.19

package/dist/cli-bundle/chunks/{chunk-DHNG452T.js → chunk-ZF52NVRT.js}

@@ -1,36 +1,27 @@
+import {
+  EXECUTABLE_COMMAND_ALIASES,
+  PM_CORE_COMMAND_NAMES
+} from "./chunk-EEECAV5M.js";
 import {
   ensureTypeFolderScaffold
-} from "./chunk-2XOSFSTH.js";
+} from "./chunk-MQOSMBWV.js";
 import {
-  normalizeExtensionNameForMatch,
-  normalizeManagedDirectoryName,
-  normalizeStringList,
-  parseExtensionManifest,
-  quoteCommandArg,
-  renderPmCommand,
-  validateExtensionDirectory
-} from "./chunk-74FKFFXO.js";
+  splitCommaList
+} from "./chunk-D6HZN36B.js";
 import {
   describeExtensionActivation,
   renderExtensionSurfaceMarkdown
-} from "./chunk-YQEZWI3R.js";
+} from "./chunk-KZ5AC6B5.js";
 import {
   TYPE_PRESET_NAMES,
   normalizeTypePresetName,
   resolveTypePresetDefinitions
-} from "./chunk-2CXL335K.js";
-import {
-  EXECUTABLE_COMMAND_ALIASES,
-  PM_CORE_COMMAND_NAMES
-} from "./chunk-WQXRZMFN.js";
+} from "./chunk-OK7VSX3N.js";
 import {
   parseItemTypesFile,
   serializeItemTypesFile,
   upsertItemType
-} from "./chunk-HO4DLBNK.js";
-import {
-  splitCommaList
-} from "./chunk-D6HZN36B.js";
+} from "./chunk-4M6RZJXF.js";
 import {
   createSerialQueue,
   getActiveExtensionRegistrations,
@@ -39,8 +30,9 @@ import {
   readSettings,
   runActiveOnWriteHooks,
   writeSettings
-} from "./chunk-646MQXFW.js";
+} from "./chunk-RLLOZAM2.js";
 import {
+  DEFAULT_EXTENSION_PRIORITY,
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
   EXIT_CODE,
   EXTENSION_CAPABILITY_CONTRACT,
@@ -53,6 +45,7 @@ import {
   ensureRuntimeSchemaFileScaffold,
   filePathForSchemaSection,
   getSettingsPath,
+  isCanonicalPathWithinDirectory,
   isPathWithinDirectory,
   levenshteinDistanceWithinLimit,
   loadExtensions,
@@ -69,11 +62,95 @@ import {
   resolvePmPackageRootFromModule,
   resolvePmRoot,
   writeFileAtomic
-} from "./chunk-WACRQ26A.js";
+} from "./chunk-WCBB6VI3.js";
+
+// dist/sdk/workspace.js
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "5b3e660c-f869-5a00-8082-1f0d240c74bf");
+  } catch (e2) {
+  }
+})();
+var PM_GITIGNORE_START = "# pm-cli:runtime-cache:start";
+var PM_GITIGNORE_END = "# pm-cli:runtime-cache:end";
+var PM_GITIGNORE_BLOCK = [
+  PM_GITIGNORE_START,
+  ".agents/pm/runtime/",
+  ".agents/pm/search/",
+  ".agents/pm/locks/",
+  PM_GITIGNORE_END
+].join("\n");
+function getPmGitignoreBlock() {
+  return PM_GITIGNORE_BLOCK;
+}
+async function ensurePmGitignore(workspaceRoot) {
+  const gitignorePath = path.join(workspaceRoot, ".gitignore");
+  let current = "";
+  try {
+    current = await readFile(gitignorePath, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+      throw error;
+    }
+  }
+  const start = current.indexOf(PM_GITIGNORE_START);
+  const end = current.indexOf(PM_GITIGNORE_END);
+  const withoutManagedBlock = start >= 0 && end >= start ? `${current.slice(0, start)}${current.slice(end + PM_GITIGNORE_END.length)}` : current;
+  const prefix = withoutManagedBlock.trimEnd();
+  const next = `${prefix.length > 0 ? `${prefix}
+
+` : ""}${PM_GITIGNORE_BLOCK}
+`;
+  if (next === current) {
+    return { path: gitignorePath, changed: false };
+  }
+  await writeFile(gitignorePath, next, "utf8");
+  return { path: gitignorePath, changed: true };
+}
+
+// dist/sdk/command-line.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "82ea8f22-efe9-5310-9fc7-a373063b7f0b");
+  } catch (e2) {
+  }
+})();
+var quoteWindowsCommandArg = (arg) => {
+  let escaped = '"';
+  let pendingBackslashes = 0;
+  for (const character of arg) {
+    if (character === "\\") {
+      pendingBackslashes += 1;
+      continue;
+    }
+    escaped += "\\".repeat(character === '"' ? pendingBackslashes * 2 + 1 : pendingBackslashes);
+    escaped += character;
+    pendingBackslashes = 0;
+  }
+  return `${escaped}${"\\".repeat(pendingBackslashes * 2)}"`;
+};
+var quoteCommandArg = (arg, platform = process.platform) => {
+  const safePattern = platform === "win32" ? /^[A-Za-z0-9._:/\\@=-]+$/ : /^[A-Za-z0-9._:/@=-]+$/;
+  if (safePattern.test(arg)) {
+    return arg;
+  }
+  if (platform === "win32") {
+    return quoteWindowsCommandArg(arg);
+  }
+  return `"${arg.replace(/(["\\$`])/g, "\\$1")}"`;
+};
+var renderPmCommand = (argv, platform = process.platform) => {
+  const args = argv.map((token) => quoteCommandArg(token, platform)).join(" ");
+  return args.length > 0 ? `pm ${args}` : "pm";
+};
 
 // dist/core/packages/manifest.js
 import fs from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
@@ -198,7 +275,7 @@ function normalizePackageCatalogMetadata(raw) {
   return Object.values(catalog).some((value) => value !== void 0) ? catalog : void 0;
 }
 async function readPmPackageManifest(packageRoot) {
-  const packageJsonPath = path.join(packageRoot, "package.json");
+  const packageJsonPath = path2.join(packageRoot, "package.json");
   if (!await pathExists(packageJsonPath)) {
     return {
       source: "convention",
@@ -244,15 +321,15 @@ async function listExtensionManifestDirectories(parentDirectory) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const directory = path.join(parentDirectory, entry.name);
-    if (await pathExists(path.join(directory, "manifest.json"))) {
+    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(path.join(packageRoot, "manifest.json"))) {
+  if (await pathExists(path2.join(packageRoot, "manifest.json"))) {
     return [packageRoot];
   }
   const manifest = await readPmPackageManifest(packageRoot);
@@ -262,11 +339,11 @@ async function collectPackageExtensionDirectories(packageRoot) {
     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 = path.resolve(packageRoot, entry);
+    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(path.join(absolute, "manifest.json"))) {
+    if (await pathExists(path2.join(absolute, "manifest.json"))) {
       discovered.add(absolute);
       continue;
     }
@@ -276,7 +353,7 @@ async function collectPackageExtensionDirectories(packageRoot) {
   }
   if (manifestEntries.length === 0) {
     for (const root of PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS.extensions) {
-      for (const child of await listExtensionManifestDirectories(path.join(packageRoot, root))) {
+      for (const child of await listExtensionManifestDirectories(path2.join(packageRoot, root))) {
         discovered.add(child);
       }
     }
@@ -285,8 +362,125 @@ async function collectPackageExtensionDirectories(packageRoot) {
 }
 
 // dist/sdk/extension/scaffold.js
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
+
+// dist/sdk/extension/shared.js
 import fs2 from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "79cbf5a9-d060-546d-aa23-79e4b16fa6dc");
+  } catch (e2) {
+  }
+})();
+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, "-");
+  let start = 0;
+  while (normalized[start] === "-") {
+    start += 1;
+  }
+  let end = normalized.length;
+  while (end > start && normalized[end - 1] === "-") {
+    end -= 1;
+  }
+  const directoryName = normalized.slice(start, end);
+  if (directoryName.length === 0) {
+    throw new PmCliError("Extension manifest name must resolve to a non-empty directory name.", EXIT_CODE.USAGE);
+  }
+  if (directoryName === "." || directoryName === "..") {
+    throw new PmCliError('Extension manifest name must not resolve to "." or "..".', EXIT_CODE.USAGE);
+  }
+  return directoryName;
+}
+function parseOptionalManifestPriority(value) {
+  if (value === void 0 || value === null) {
+    return DEFAULT_EXTENSION_PRIORITY;
+  }
+  return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+function parseOptionalManifestCapabilities(value) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    return null;
+  }
+  return normalizeStringList(value.map((entry) => String(entry).toLowerCase()));
+}
+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;
+  }
+  const priority = parseOptionalManifestPriority(candidate.priority);
+  const capabilities = parseOptionalManifestCapabilities(candidate.capabilities);
+  if (priority === null || capabilities === null) {
+    return null;
+  }
+  return {
+    name: candidate.name.trim(),
+    version: candidate.version.trim(),
+    entry: candidate.entry.trim(),
+    priority,
+    capabilities
+  };
+}
+async function validateExtensionDirectory(directory) {
+  const manifestPath = path3.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 fs2.readFile(manifestPath, "utf8"));
+  } catch (error) {
+    throw new PmCliError(`Failed to parse extension manifest at "${manifestPath}": ${formatManifestReadError(error)}`, EXIT_CODE.USAGE);
+  }
+  const manifest = parseExtensionManifest(parsedManifest);
+  if (!manifest) {
+    throw new PmCliError(`Extension manifest at "${manifestPath}" is invalid.`, EXIT_CODE.USAGE);
+  }
+  const entryPath = path3.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
+  };
+}
+function formatManifestReadError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// dist/sdk/extension/scaffold.js
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
@@ -2397,33 +2591,33 @@ async function scaffoldExtensionProject(target, vocabulary = "extension", capabi
   }
   const style = declarative ? "declarative" : "imperative";
   const normalizedTarget = target.trim();
-  const targetPath = path2.resolve(process.cwd(), normalizedTarget);
-  const extensionName = normalizeManagedDirectoryName(path2.basename(targetPath));
+  const targetPath = path4.resolve(process.cwd(), normalizedTarget);
+  const extensionName = normalizeManagedDirectoryName(path4.basename(targetPath));
   const commandName = buildScaffoldCommandName(extensionName);
   const scaffoldFiles = buildStarterExtensionScaffoldFiles(extensionName, commandName, vocabulary, resolvedCapability, declarative);
   let createdDirectory = false;
   if (await pathExists(targetPath)) {
-    const existingTargetStats = await fs2.stat(targetPath);
+    const existingTargetStats = await fs3.stat(targetPath);
     if (!existingTargetStats.isDirectory()) {
       throw new PmCliError(`Scaffold target "${targetPath}" exists and is not a directory.`, EXIT_CODE.CONFLICT);
     }
   } else {
-    await fs2.mkdir(targetPath, { recursive: true });
+    await fs3.mkdir(targetPath, { recursive: true });
     createdDirectory = true;
   }
   for (const [relativePath, content] of Object.entries(scaffoldFiles)) {
-    const absolutePath = path2.join(targetPath, relativePath);
+    const absolutePath = path4.join(targetPath, relativePath);
     if (!await pathExists(absolutePath)) {
       continue;
     }
-    const existingContent = await fs2.readFile(absolutePath, "utf8");
+    const existingContent = await fs3.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 = path2.join(targetPath, relativePath);
+    const absolutePath = path4.join(targetPath, relativePath);
     if (await pathExists(absolutePath)) {
       files.push({
         path: relativePath,
@@ -2431,8 +2625,8 @@ async function scaffoldExtensionProject(target, vocabulary = "extension", capabi
       });
       continue;
     }
-    await fs2.mkdir(path2.dirname(absolutePath), { recursive: true });
-    await fs2.writeFile(absolutePath, content, "utf8");
+    await fs3.mkdir(path4.dirname(absolutePath), { recursive: true });
+    await fs3.writeFile(absolutePath, content, "utf8");
     files.push({
       path: relativePath,
       status: "created"
@@ -2526,12 +2720,12 @@ function renderExtensionDescribeMarkdown(result, noun) {
 }
 
 // dist/sdk/extension.js
-import fs8 from "node:fs/promises";
-import path8 from "node:path";
+import fs9 from "node:fs/promises";
+import path10 from "node:path";
 
 // dist/sdk/extension/managed-state.js
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
@@ -2542,7 +2736,7 @@ import path3 from "node:path";
 var MANAGED_EXTENSION_STATE_FILENAME = ".managed-extensions.json";
 var MANAGED_EXTENSION_STATE_VERSION = 1;
 function resolveManagedExtensionStatePath(extensionsRoot) {
-  return path3.join(extensionsRoot, MANAGED_EXTENSION_STATE_FILENAME);
+  return path5.join(extensionsRoot, MANAGED_EXTENSION_STATE_FILENAME);
 }
 function createEmptyManagedExtensionState() {
   return {
@@ -2661,7 +2855,7 @@ async function readManagedExtensionState(extensionsRoot) {
   const statePath = resolveManagedExtensionStatePath(extensionsRoot);
   const fallback = createEmptyManagedExtensionState();
   try {
-    const raw = await fs3.readFile(statePath, "utf8");
+    const raw = await fs4.readFile(statePath, "utf8");
     const parsed = JSON.parse(raw);
     const normalized = normalizeManagedState(parsed);
     if (!normalized) {
@@ -2693,8 +2887,8 @@ async function writeManagedExtensionState(extensionsRoot, state) {
     updated_at: nowIso(),
     entries: sortManagedEntries(state.entries)
   };
-  await fs3.mkdir(extensionsRoot, { recursive: true });
-  await fs3.writeFile(statePath, `${JSON.stringify(normalized, null, 2)}
+  await fs4.mkdir(extensionsRoot, { recursive: true });
+  await fs4.writeFile(statePath, `${JSON.stringify(normalized, null, 2)}
 `, "utf8");
 }
 function upsertManagedEntry(state, entry) {
@@ -2709,15 +2903,15 @@ function upsertManagedEntry(state, entry) {
 
 // dist/sdk/extension/install-sources.js
 import { execFile } from "node:child_process";
-import fs5 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 import os from "node:os";
-import path5 from "node:path";
+import path7 from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
 // dist/sdk/extension/bundled-catalog.js
-import fs4 from "node:fs/promises";
-import path4 from "node:path";
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
@@ -2741,7 +2935,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(path6.resolve(envRoot.trim()));
   }
   candidates.push(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]));
   return [...new Set(candidates)];
@@ -2757,8 +2951,8 @@ async function resolveBundledExtensionAliasSource(input3) {
     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 = path6.join(packageRoot2, ".agents", "pm", "extensions", alias.legacy_extension_directory);
+    if (await pathExists(path6.join(legacyExtensionPath, "manifest.json"))) {
       return legacyExtensionPath;
     }
   }
@@ -2771,13 +2965,13 @@ function derivePackageAlias(packageDirectory) {
   return packageDirectory.replace(/^pm-/i, "").trim().toLowerCase();
 }
 async function collectManifestPackageEntries(packagesRoot, entriesByAlias) {
-  const entries = await fs4.readdir(packagesRoot, { withFileTypes: true });
+  const entries = await fs5.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 = path6.join(packagesRoot, entry.name);
+    if (!await pathExists(path6.join(candidateRoot, "package.json"))) {
       continue;
     }
     const manifest = await readPmPackageManifest(candidateRoot);
@@ -2799,7 +2993,7 @@ async function collectManifestPackageEntries(packagesRoot, entriesByAlias) {
 async function collectBundledPackageEntries() {
   const entriesByAlias = /* @__PURE__ */ new Map();
   for (const packageRoot of resolvePackageRootCandidates()) {
-    const packagesRoot = path4.join(packageRoot, "packages");
+    const packagesRoot = path6.join(packageRoot, "packages");
     if (!await pathExists(packagesRoot)) {
       continue;
     }
@@ -2810,8 +3004,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 = path6.join(packageRoot, "packages", legacy.package_directory);
+      if (await pathExists(path6.join(packagePath, "package.json"))) {
         entriesByAlias.set(alias, {
           alias,
           package_directory: legacy.package_directory,
@@ -2874,7 +3068,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(path6.resolve(bundledEntry.package_root)),
     install_target: bundledEntry.alias,
     install_command: `pm install ${bundledEntry.alias} ${installScopeFlag}`,
     package_name: manifest.package_name,
@@ -2899,7 +3093,7 @@ async function buildBundledPackageCatalog(scope, global2, options = {}) {
   const roots = resolveExtensionRoots(resolvePmRoot(process.cwd(), global2.path), process.cwd());
   const selectedRoot = scope === "global" ? roots.global : roots.project;
   const managedStateRead = await readManagedExtensionState(selectedRoot);
-  const installedLocations = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope).filter((entry) => entry.source.kind !== "builtin").map((entry) => 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) => path6.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,
@@ -3076,7 +3270,7 @@ function parseExtensionInstallSource(input3, options = {}) {
   return {
     kind: "local",
     input: normalizedInput,
-    absolute_path: path5.resolve(process.cwd(), normalizedInput)
+    absolute_path: path7.resolve(process.cwd(), normalizedInput)
   };
 }
 async function runGitCommand(args, execRunner = execFileAsync, timeoutMs) {
@@ -3184,8 +3378,8 @@ function wrapNpmPackResolutionError(spec, error) {
   return new PmCliError(recovery.message, EXIT_CODE.NOT_FOUND, recovery.context);
 }
 async function resolveLocalNpmPackagePath(spec) {
-  if (path5.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..")) {
-    const absolutePath = path5.resolve(process.cwd(), spec);
+  if (path7.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..")) {
+    const absolutePath = path7.resolve(process.cwd(), spec);
     return await pathExists(absolutePath) ? absolutePath : null;
   }
   try {
@@ -3197,7 +3391,7 @@ async function resolveLocalNpmPackagePath(spec) {
   } catch {
   }
   if (!/^[a-z][a-z0-9+.-]*:/i.test(spec)) {
-    const absolutePath = path5.resolve(process.cwd(), spec);
+    const absolutePath = path7.resolve(process.cwd(), spec);
     if (await pathExists(absolutePath)) {
       return absolutePath;
     }
@@ -3233,7 +3427,7 @@ function normalizeNpmLocalFileAliasSpec(spec, cwd = process.cwd()) {
     return spec;
   }
   if (!target.startsWith("/")) {
-    return `${packageName}@${path5.resolve(cwd, target)}`;
+    return `${packageName}@${path7.resolve(cwd, target)}`;
   }
   let decodedPath;
   try {
@@ -3250,7 +3444,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: path5.resolve(packDirectory, first.filename),
+        tarball: path7.resolve(packDirectory, first.filename),
         package: typeof first.name === "string" ? first.name : void 0,
         version: typeof first.version === "string" ? first.version : void 0
       };
@@ -3262,7 +3456,7 @@ function parsePackedNpmPackage(stdout, packDirectory) {
     throw new PmCliError("npm pack did not report a tarball filename.", EXIT_CODE.GENERIC_FAILURE);
   }
   return {
-    tarball: path5.resolve(packDirectory, lastLine)
+    tarball: path7.resolve(packDirectory, lastLine)
   };
 }
 async function resolveNpmSourceDirectory(source) {
@@ -3271,8 +3465,8 @@ async function resolveNpmSourceDirectory(source) {
 async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
   const localPackageRoot = await resolveLocalNpmPackagePath(source.spec);
   if (localPackageRoot) {
-    const packageJsonPath = path5.join(localPackageRoot, "package.json");
-    const packageJson = await pathExists(packageJsonPath) ? JSON.parse(await fs5.readFile(packageJsonPath, "utf8")) : {};
+    const packageJsonPath = path7.join(localPackageRoot, "package.json");
+    const packageJson = await pathExists(packageJsonPath) ? JSON.parse(await fs6.readFile(packageJsonPath, "utf8")) : {};
     return {
       directory: await resolvePackageExtensionDirectory(localPackageRoot, source.input),
       package: typeof packageJson.name === "string" ? packageJson.name : void 0,
@@ -3281,11 +3475,11 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
       }
     };
   }
-  const tempRoot = await fs5.mkdtemp(path5.join(os.tmpdir(), "pm-npm-package-source-"));
-  const packDirectory = path5.join(tempRoot, "pack");
-  const extractDirectory = path5.join(tempRoot, "extract");
-  await fs5.mkdir(packDirectory, { recursive: true });
-  await fs5.mkdir(extractDirectory, { recursive: true });
+  const tempRoot = await fs6.mkdtemp(path7.join(os.tmpdir(), "pm-npm-package-source-"));
+  const packDirectory = path7.join(tempRoot, "pack");
+  const extractDirectory = path7.join(tempRoot, "extract");
+  await fs6.mkdir(packDirectory, { recursive: true });
+  await fs6.mkdir(extractDirectory, { recursive: true });
   try {
     const packSpec = await resolveNpmPackSpec(source.spec);
     const packStdout = await npmRunner([
@@ -3297,7 +3491,7 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
     ]);
     const packed = parsePackedNpmPackage(packStdout, packDirectory);
     await execFileAsync("tar", ["-xzf", packed.tarball, "-C", extractDirectory], { encoding: "utf8" });
-    const packageRoot = path5.join(extractDirectory, "package");
+    const packageRoot = path7.join(extractDirectory, "package");
     await installNpmPackageRuntimeDependencies(packageRoot);
     const directory = await resolvePackageExtensionDirectory(packageRoot, source.input);
     return {
@@ -3305,11 +3499,11 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
       package: packed.package,
       version: packed.version,
       cleanup: async () => {
-        await fs5.rm(tempRoot, { recursive: true, force: true });
+        await fs6.rm(tempRoot, { recursive: true, force: true });
       }
     };
   } catch (error) {
-    await fs5.rm(tempRoot, { recursive: true, force: true });
+    await fs6.rm(tempRoot, { recursive: true, force: true });
     const wrappedError = wrapNpmPackResolutionError(source.spec, error);
     if (wrappedError) {
       throw wrappedError;
@@ -3318,13 +3512,13 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
   }
 }
 async function installNpmPackageRuntimeDependencies(packageRoot) {
-  const packageJsonPath = path5.join(packageRoot, "package.json");
+  const packageJsonPath = path7.join(packageRoot, "package.json");
   if (!await pathExists(packageJsonPath)) {
     return;
   }
   let parsed;
   try {
-    parsed = JSON.parse(await fs5.readFile(packageJsonPath, "utf8"));
+    parsed = JSON.parse(await fs6.readFile(packageJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -3341,12 +3535,12 @@ async function installNpmPackageRuntimeDependencies(packageRoot) {
   delete runtimeOnlyManifest.devDependencies;
   const installManifest = { ...runtimeOnlyManifest };
   removeHostedPmCliDependency(installManifest);
-  await fs5.writeFile(packageJsonPath, `${JSON.stringify(installManifest, null, 2)}
+  await fs6.writeFile(packageJsonPath, `${JSON.stringify(installManifest, null, 2)}
 `, "utf8");
   try {
     await Promise.all([
-      fs5.rm(path5.join(packageRoot, "package-lock.json"), { force: true }),
-      fs5.rm(path5.join(packageRoot, "npm-shrinkwrap.json"), { force: true })
+      fs6.rm(path7.join(packageRoot, "package-lock.json"), { force: true }),
+      fs6.rm(path7.join(packageRoot, "npm-shrinkwrap.json"), { force: true })
     ]);
     if (dependencySpecs.length > 0) {
       await runNpmCommand([
@@ -3364,7 +3558,7 @@ async function installNpmPackageRuntimeDependencies(packageRoot) {
       await linkHostedPmCliDependency(packageRoot);
     }
   } finally {
-    await fs5.writeFile(packageJsonPath, `${JSON.stringify(runtimeOnlyManifest, null, 2)}
+    await fs6.writeFile(packageJsonPath, `${JSON.stringify(runtimeOnlyManifest, null, 2)}
 `, "utf8");
   }
 }
@@ -3404,11 +3598,11 @@ async function linkHostedPmCliDependency(packageRoot) {
     "../../.."
   ]);
   const [scope, packageName] = PM_CLI_PACKAGE_NAME.split("/");
-  const scopedDirectory = path5.join(packageRoot, "node_modules", scope);
-  const linkPath = path5.join(scopedDirectory, packageName);
-  await fs5.mkdir(scopedDirectory, { recursive: true });
-  await fs5.rm(linkPath, { recursive: true, force: true });
-  await fs5.symlink(hostPackageRoot, linkPath, resolveDirectorySymlinkType(process.platform));
+  const scopedDirectory = path7.join(packageRoot, "node_modules", scope);
+  const linkPath = path7.join(scopedDirectory, packageName);
+  await fs6.mkdir(scopedDirectory, { recursive: true });
+  await fs6.rm(linkPath, { recursive: true, force: true });
+  await fs6.symlink(hostPackageRoot, linkPath, resolveDirectorySymlinkType(process.platform));
 }
 function resolveDirectorySymlinkType(platform) {
   return platform === "win32" ? "junction" : "dir";
@@ -3438,7 +3632,7 @@ async function resolvePackageExtensionDirectory(packageRoot, sourceLabel) {
     return discovered[0];
   }
   if (discovered.length > 1) {
-    const choices = discovered.map((entry) => path5.relative(packageRoot, entry).replaceAll(path5.sep, "/")).sort((left, right) => left.localeCompare(right));
+    const choices = discovered.map((entry) => path7.relative(packageRoot, entry).replaceAll(path7.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);
@@ -3447,26 +3641,26 @@ async function resolveGithubSourceDirectory(cloneDirectory, source) {
   const candidatePaths = [];
   if (source.subpath) {
     candidatePaths.push(source.subpath);
-    candidatePaths.push(path5.posix.join(".agents/pm/extensions", source.subpath));
-    candidatePaths.push(path5.posix.join(".custom/pm-extensions", source.subpath));
-    candidatePaths.push(path5.posix.join(".custom/pm-extension", source.subpath));
+    candidatePaths.push(path7.posix.join(".agents/pm/extensions", source.subpath));
+    candidatePaths.push(path7.posix.join(".custom/pm-extensions", source.subpath));
+    candidatePaths.push(path7.posix.join(".custom/pm-extension", source.subpath));
   }
   for (const candidate of candidatePaths) {
-    const absolute = path5.resolve(cloneDirectory, candidate);
+    const absolute = path7.resolve(cloneDirectory, candidate);
     if (!isPathWithinDirectory(cloneDirectory, absolute)) {
       continue;
     }
-    if (await pathExists(path5.join(absolute, "manifest.json"))) {
+    if (await pathExists(path7.join(absolute, "manifest.json"))) {
       return { directory: absolute, resolved_subpath: candidate };
     }
   }
-  if (await pathExists(path5.join(cloneDirectory, "manifest.json"))) {
+  if (await pathExists(path7.join(cloneDirectory, "manifest.json"))) {
     return { directory: cloneDirectory, resolved_subpath: "." };
   }
   const discoveredDirectory = await resolvePackageExtensionDirectory(cloneDirectory, source.input);
   return {
     directory: discoveredDirectory,
-    resolved_subpath: path5.relative(cloneDirectory, discoveredDirectory).replaceAll(path5.sep, "/")
+    resolved_subpath: path7.relative(cloneDirectory, discoveredDirectory).replaceAll(path7.sep, "/")
   };
 }
 function looksLikeBarePackageName(input3) {
@@ -3488,7 +3682,7 @@ async function buildLocalSourceNotFoundError(source) {
   let bundledAliases = [];
   try {
     const envPackageRoot = process.env.PM_CLI_PACKAGE_ROOT;
-    const cacheKey = typeof envPackageRoot === "string" && envPackageRoot.trim().length > 0 ? path5.resolve(envPackageRoot.trim()) : "";
+    const cacheKey = typeof envPackageRoot === "string" && envPackageRoot.trim().length > 0 ? path7.resolve(envPackageRoot.trim()) : "";
     if (bundledPackageAliasesCache?.key !== cacheKey) {
       bundledPackageAliasesCache = {
         key: cacheKey,
@@ -3522,7 +3716,7 @@ async function resolveInstallSource(source) {
   if (source.kind === "local") {
     let localStats;
     try {
-      localStats = await fs5.stat(source.absolute_path);
+      localStats = await fs6.stat(source.absolute_path);
     } catch {
       throw await buildLocalSourceNotFoundError(source);
     }
@@ -3541,12 +3735,12 @@ async function resolveInstallSource(source) {
       source,
       directory: resolved.directory,
       cleanup: resolved.cleanup,
-      resolved_subpath: path5.relative(path5.dirname(resolved.directory), resolved.directory).replaceAll(path5.sep, "/"),
+      resolved_subpath: path7.relative(path7.dirname(resolved.directory), resolved.directory).replaceAll(path7.sep, "/"),
       npm_package: resolved.package,
       npm_version: resolved.version
     };
   }
-  const cloneDirectory = await fs5.mkdtemp(path5.join(os.tmpdir(), "pm-extension-source-"));
+  const cloneDirectory = await fs6.mkdtemp(path7.join(os.tmpdir(), "pm-extension-source-"));
   const cloneArgs = ["clone", "--depth", "1"];
   if (source.ref) {
     cloneArgs.push("--branch", source.ref);
@@ -3567,11 +3761,11 @@ async function resolveInstallSource(source) {
       resolved_subpath: resolved.resolved_subpath,
       commit,
       cleanup: async () => {
-        await fs5.rm(cloneDirectory, { recursive: true, force: true });
+        await fs6.rm(cloneDirectory, { recursive: true, force: true });
       }
     };
   } catch (error) {
-    await fs5.rm(cloneDirectory, { recursive: true, force: true });
+    await fs6.rm(cloneDirectory, { recursive: true, force: true });
     throw error;
   }
 }
@@ -3580,8 +3774,8 @@ async function areDirectoriesEquivalent(left, right) {
     return false;
   }
   const [leftRealPath, rightRealPath] = await Promise.all([
-    fs5.realpath(left),
-    fs5.realpath(right)
+    fs6.realpath(left),
+    fs6.realpath(right)
   ]);
   return leftRealPath === rightRealPath;
 }
@@ -4105,9 +4299,9 @@ function buildDoctorConsistencySummary(scope, installedExtensions, loadedExtensi
 
 // dist/sdk/extension/install-runtime.js
 import { randomUUID } from "node:crypto";
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 import os2 from "node:os";
-import path6 from "node:path";
+import path8 from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
@@ -4131,34 +4325,34 @@ var sleep = (ms) => new Promise((resolve) => {
   setTimeout(resolve, ms);
 });
 var ensureExtensionModuleTypeMarker = async (destinationDirectory) => {
-  const markerPath = path6.join(destinationDirectory, "package.json");
+  const markerPath = path8.join(destinationDirectory, "package.json");
   if (await pathExists(markerPath)) {
     return;
   }
-  await fs6.writeFile(markerPath, `${JSON.stringify({ type: "module" }, null, 2)}
+  await fs7.writeFile(markerPath, `${JSON.stringify({ type: "module" }, null, 2)}
 `, "utf8");
 };
 var resolveCanonicalExtensionInstallDestination = async (destinationDirectory) => {
-  const resolvedDestination = path6.resolve(destinationDirectory);
-  const destinationParent = path6.dirname(resolvedDestination);
-  const destinationRoot = path6.parse(destinationParent).root;
-  let canonicalDestinationParent = await fs6.realpath(destinationRoot).catch(() => destinationRoot);
-  const relativeDestinationParent = path6.relative(destinationRoot, destinationParent);
-  const destinationSegments = relativeDestinationParent === "" ? [] : relativeDestinationParent.split(path6.sep);
+  const resolvedDestination = path8.resolve(destinationDirectory);
+  const destinationParent = path8.dirname(resolvedDestination);
+  const destinationRoot = path8.parse(destinationParent).root;
+  let canonicalDestinationParent = await fs7.realpath(destinationRoot).catch(() => destinationRoot);
+  const relativeDestinationParent = path8.relative(destinationRoot, destinationParent);
+  const destinationSegments = relativeDestinationParent === "" ? [] : relativeDestinationParent.split(path8.sep);
   for (const [index, segment] of destinationSegments.entries()) {
-    const candidate = path6.join(canonicalDestinationParent, segment);
+    const candidate = path8.join(canonicalDestinationParent, segment);
     try {
-      canonicalDestinationParent = await fs6.realpath(candidate);
+      canonicalDestinationParent = await fs7.realpath(candidate);
     } catch {
-      canonicalDestinationParent = path6.join(canonicalDestinationParent, ...destinationSegments.slice(index));
+      canonicalDestinationParent = path8.join(canonicalDestinationParent, ...destinationSegments.slice(index));
       break;
     }
   }
-  return path6.join(canonicalDestinationParent, path6.basename(resolvedDestination));
+  return path8.join(canonicalDestinationParent, path8.basename(resolvedDestination));
 };
 var copyExtensionDirectoryWithoutSelfNesting = async (sourceDirectory, destinationDirectory, copyDirectory, temporaryDirectory = os2.tmpdir()) => {
-  const resolvedSource = path6.resolve(sourceDirectory);
-  const canonicalSource = await fs6.realpath(resolvedSource).catch(() => resolvedSource);
+  const resolvedSource = path8.resolve(sourceDirectory);
+  const canonicalSource = await fs7.realpath(resolvedSource).catch(() => resolvedSource);
   const canonicalDestination = await resolveCanonicalExtensionInstallDestination(destinationDirectory);
   if (canonicalSource === canonicalDestination) {
     return;
@@ -4170,13 +4364,13 @@ var copyExtensionDirectoryWithoutSelfNesting = async (sourceDirectory, destinati
     });
     return;
   }
-  const systemTempDirectory = path6.resolve(temporaryDirectory);
-  const stagingBase = isPathWithinDirectory(canonicalSource, systemTempDirectory) ? path6.dirname(canonicalSource) : systemTempDirectory;
+  const systemTempDirectory = path8.resolve(temporaryDirectory);
+  const stagingBase = isPathWithinDirectory(canonicalSource, systemTempDirectory) ? path8.dirname(canonicalSource) : systemTempDirectory;
   if (isPathWithinDirectory(canonicalSource, stagingBase)) {
     throw new PmCliError(`Extension source "${sourceDirectory}" contains its install destination and no external staging directory is available. Install a narrower package directory instead.`, EXIT_CODE.USAGE, { code: "extension_install_source_contains_destination" });
   }
-  const stagingRoot = await fs6.mkdtemp(path6.join(stagingBase, "pm-extension-copy-"));
-  const stagedDirectory = path6.join(stagingRoot, "extension");
+  const stagingRoot = await fs7.mkdtemp(path8.join(stagingBase, "pm-extension-copy-"));
+  const stagedDirectory = path8.join(stagingRoot, "extension");
   try {
     await copyDirectory(sourceDirectory, stagedDirectory, {
       recursive: true,
@@ -4187,13 +4381,13 @@ var copyExtensionDirectoryWithoutSelfNesting = async (sourceDirectory, destinati
       force: true
     });
   } finally {
-    await fs6.rm(stagingRoot, { recursive: true, force: true });
+    await fs7.rm(stagingRoot, { recursive: true, force: true });
   }
 };
-var copyExtensionDirectoryForInstall = async (sourceDirectory, destinationDirectory, copyDirectory = fs6.cp) => {
+var copyExtensionDirectoryForInstall = async (sourceDirectory, destinationDirectory, copyDirectory = fs7.cp) => {
   for (let attempt = 1; attempt <= EXTENSION_INSTALL_COPY_ATTEMPTS; attempt += 1) {
     try {
-      await fs6.rm(destinationDirectory, { recursive: true, force: true });
+      await fs7.rm(destinationDirectory, { recursive: true, force: true });
       await copyExtensionDirectoryWithoutSelfNesting(sourceDirectory, destinationDirectory, copyDirectory);
       return;
     } catch (error) {
@@ -4207,7 +4401,7 @@ var copyExtensionDirectoryForInstall = async (sourceDirectory, destinationDirect
 var readExtensionInstallLockOwnerToken = async (lockPath) => {
   let ownerContents;
   try {
-    ownerContents = await fs6.readFile(path6.join(lockPath, "owner.json"), "utf8");
+    ownerContents = await fs7.readFile(path8.join(lockPath, "owner.json"), "utf8");
   } catch (error) {
     if (!isErrnoCode(error, "ENOENT"))
       throw error;
@@ -4230,13 +4424,13 @@ var removeExtensionInstallLockIfOwned = async (lockPath, ownerToken) => {
   if (currentOwnerToken !== ownerToken) {
     return false;
   }
-  await fs6.rm(lockPath, { recursive: true, force: true });
+  await fs7.rm(lockPath, { recursive: true, force: true });
   return true;
 };
 var reclaimStaleExtensionInstallLock = async (lockPath, staleMs) => {
   let stat;
   try {
-    stat = await fs6.stat(lockPath);
+    stat = await fs7.stat(lockPath);
   } catch {
     return false;
   }
@@ -4245,7 +4439,7 @@ var reclaimStaleExtensionInstallLock = async (lockPath, staleMs) => {
   }
   const staleOwnerToken = await readExtensionInstallLockOwnerToken(lockPath);
   if (staleOwnerToken === null) {
-    await fs6.rm(lockPath, { recursive: true, force: true });
+    await fs7.rm(lockPath, { recursive: true, force: true });
     return true;
   }
   return removeExtensionInstallLockIfOwned(lockPath, staleOwnerToken);
@@ -4258,7 +4452,7 @@ var startExtensionInstallLockHeartbeat = (lockPath, ownerToken, intervalMs) => {
         return;
       }
       const heartbeatAt = /* @__PURE__ */ new Date();
-      await fs6.utimes(lockPath, heartbeatAt, heartbeatAt);
+      await fs7.utimes(lockPath, heartbeatAt, heartbeatAt);
     }).catch(() => void 0);
   }, intervalMs);
   timer.unref();
@@ -4268,12 +4462,12 @@ var startExtensionInstallLockHeartbeat = (lockPath, ownerToken, intervalMs) => {
   };
 };
 var createExtensionInstallLock = async (lockPath, owner) => {
-  await fs6.mkdir(lockPath);
+  await fs7.mkdir(lockPath);
   try {
-    await fs6.writeFile(path6.join(lockPath, "owner.json"), `${JSON.stringify(owner, null, 2)}
+    await fs7.writeFile(path8.join(lockPath, "owner.json"), `${JSON.stringify(owner, null, 2)}
 `, "utf8");
   } catch (error) {
-    await fs6.rm(lockPath, { recursive: true, force: true }).catch(() => {
+    await fs7.rm(lockPath, { recursive: true, force: true }).catch(() => {
     });
     throw error;
   }
@@ -4297,9 +4491,9 @@ var acquireExtensionInstallLock = async (lockPath, owner, attempts, delayMs, sta
   return false;
 };
 var withExtensionInstallLock = async (settingsRoot, destinationDirectoryName, run, options) => {
-  const lockRoot = path6.join(settingsRoot, "runtime", "extension-install-locks");
-  const lockPath = path6.join(lockRoot, "scope.lock");
-  await fs6.mkdir(lockRoot, { recursive: true });
+  const lockRoot = path8.join(settingsRoot, "runtime", "extension-install-locks");
+  const lockPath = path8.join(lockRoot, "scope.lock");
+  await fs7.mkdir(lockRoot, { recursive: true });
   const { attempts: rawAttempts = EXTENSION_INSTALL_LOCK_ATTEMPTS, delay_ms: rawDelayMs = EXTENSION_INSTALL_LOCK_DELAY_MS, stale_ms: rawStaleMs = EXTENSION_INSTALL_LOCK_STALE_MS, heartbeat_ms: rawHeartbeatMs } = options ?? {};
   if (![rawAttempts, rawDelayMs, rawStaleMs, rawHeartbeatMs].filter((value) => value !== void 0).every(Number.isFinite)) {
     throw new PmCliError("Extension install lock timings must be finite numbers.", EXIT_CODE.USAGE);
@@ -4412,8 +4606,8 @@ var checkGithubUpdate = async (source, gitCommandRunner = runGitCommand) => {
 };
 
 // dist/sdk/extension/install-snapshot.js
-import fs7 from "node:fs/promises";
-import path7 from "node:path";
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
@@ -4421,7 +4615,7 @@ import path7 from "node:path";
   } catch (e2) {
   }
 })();
-var readOptionalMetadataFile = async (filePath) => fs7.readFile(filePath).catch((error) => {
+var readOptionalMetadataFile = async (filePath) => fs8.readFile(filePath).catch((error) => {
   if (isErrnoCode(error, "ENOENT"))
     return null;
   throw error;
@@ -4434,7 +4628,7 @@ var captureExtensionInstallSnapshot = async (selectedRoot, settingsRoot, destina
     readOptionalMetadataFile(settingsPath)
   ]);
   if (destinationExists) {
-    await fs7.cp(destinationDirectory, backupDirectory, {
+    await fs8.cp(destinationDirectory, backupDirectory, {
       recursive: true,
       force: true
     });
@@ -4450,9 +4644,9 @@ var captureExtensionInstallSnapshot = async (selectedRoot, settingsRoot, destina
   };
 };
 var restoreExtensionInstallSnapshot = async (snapshot) => {
-  await fs7.rm(snapshot.destinationDirectory, { recursive: true, force: true });
+  await fs8.rm(snapshot.destinationDirectory, { recursive: true, force: true });
   if (snapshot.destinationExists) {
-    await fs7.cp(snapshot.backupDirectory, snapshot.destinationDirectory, {
+    await fs8.cp(snapshot.backupDirectory, snapshot.destinationDirectory, {
       recursive: true,
       force: true
     });
@@ -4462,10 +4656,10 @@ var restoreExtensionInstallSnapshot = async (snapshot) => {
     [snapshot.settingsPath, snapshot.settingsContents]
   ]) {
     if (contents === null) {
-      await fs7.rm(filePath, { force: true });
+      await fs8.rm(filePath, { force: true });
     } else {
-      await fs7.mkdir(path7.dirname(filePath), { recursive: true });
-      await fs7.writeFile(filePath, contents);
+      await fs8.mkdir(path9.dirname(filePath), { recursive: true });
+      await fs8.writeFile(filePath, contents);
     }
   }
 };
@@ -4871,14 +5065,14 @@ var buildMissingManifestInspection = (directoryName, scope, settings, managedEnt
   };
 };
 var inspectInstalledExtensionDirectory = async (extensionsRoot, directoryName, scope, settings, managedByName, managedByDirectory) => {
-  const extensionDirectory = path8.join(extensionsRoot, directoryName);
-  const manifestPath = path8.join(extensionDirectory, "manifest.json");
+  const extensionDirectory = path10.join(extensionsRoot, directoryName);
+  const manifestPath = path10.join(extensionDirectory, "manifest.json");
   const managedDirectoryEntry = managedByDirectory.get(normalizeExtensionNameForMatch(directoryName));
   if (!await pathExists(manifestPath)) {
     return buildMissingManifestInspection(directoryName, scope, settings, managedDirectoryEntry);
   }
   const invalidJson = /* @__PURE__ */ Symbol("invalid-extension-manifest-json");
-  const rawManifest = await fs8.readFile(manifestPath, "utf8").then((contents) => JSON.parse(contents)).catch(() => invalidJson);
+  const rawManifest = await fs9.readFile(manifestPath, "utf8").then((contents) => JSON.parse(contents)).catch(() => invalidJson);
   if (rawManifest === invalidJson) {
     return {
       warning: `extension_manifest_invalid_json:${scope}:${directoryName}`
@@ -4906,7 +5100,7 @@ var listInstalledExtensions = async (extensionsRoot, scope, settings, state) =>
       warnings: []
     };
   }
-  const entries = await fs8.readdir(extensionsRoot, { withFileTypes: true });
+  const entries = await fs9.readdir(extensionsRoot, { withFileTypes: true });
   const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
   const managedByName = new Map(state.entries.map((managedEntry) => [
     normalizeExtensionNameForMatch(managedEntry.name),
@@ -5044,7 +5238,7 @@ var adoptUnmanagedExtensions = async (extensionsRoot, scope, installedExtensions
   let nextState = state;
   const adoptedEntries = [];
   for (const candidate of sortedCandidates) {
-    const extensionDirectory = path8.join(extensionsRoot, candidate.directory);
+    const extensionDirectory = path10.join(extensionsRoot, candidate.directory);
     const validated = await validateExtensionDirectory(extensionDirectory);
     const now = nowIso();
     const sourceRecord = {
@@ -5452,12 +5646,12 @@ var persistExtensionInstall = async (ctx, input3) => {
   const settings = await readSettings(resolvedRoots.settings_root);
   const managedStateRead = await readManagedExtensionState(resolvedRoots.selected_root);
   warnings.push(...managedStateRead.warnings);
-  const destinationDirectory = path8.join(resolvedRoots.selected_root, destinationDirectoryName);
+  const destinationDirectory = path10.join(resolvedRoots.selected_root, destinationDirectoryName);
   const destinationExists = await pathExists(destinationDirectory);
   const installInPlace = await areDirectoriesEquivalent(validated.directory, destinationDirectory);
-  await fs8.mkdir(resolvedRoots.selected_root, { recursive: true });
-  const backupRoot = await fs8.mkdtemp(path8.join(resolvedRoots.selected_root, ".pm-extension-install-backup-"));
-  const backupDirectory = path8.join(backupRoot, "destination");
+  await fs9.mkdir(resolvedRoots.selected_root, { recursive: true });
+  const backupRoot = await fs9.mkdtemp(path10.join(resolvedRoots.selected_root, ".pm-extension-install-backup-"));
+  const backupDirectory = path10.join(backupRoot, "destination");
   try {
     const snapshot = await captureExtensionInstallSnapshot(resolvedRoots.selected_root, resolvedRoots.settings_root, destinationDirectory, destinationExists, backupDirectory);
     const sourceRecord = buildInstallManagedSource(input3.bundledAliasName, input3.bundledPackageName, input3.installSource, input3.resolvedSource);
@@ -5501,7 +5695,7 @@ var persistExtensionInstall = async (ctx, input3) => {
       activationChanged
     };
   } finally {
-    await fs8.rm(backupRoot, { recursive: true, force: true }).catch(() => void 0);
+    await fs9.rm(backupRoot, { recursive: true, force: true }).catch(() => void 0);
   }
 };
 var scaffoldInstalledExtensionItemTypes = async (ctx, extensionName, registrations) => {
@@ -5758,7 +5952,7 @@ var runExtensionAdoptAction = async (ctx) => {
       }
     });
   }
-  const extensionDirectory = path8.join(resolvedRoots.selected_root, candidate.directory);
+  const extensionDirectory = path10.join(resolvedRoots.selected_root, candidate.directory);
   const validated = await validateExtensionDirectory(extensionDirectory);
   const now = nowIso();
   const sourceRecord = buildAdoptedExtensionSource(githubOption, extensionTarget, extensionDirectory, options.ref);
@@ -5806,8 +6000,8 @@ var resolveRequiredInstalledExtension = async (ctx) => {
 var runExtensionUninstallAction = async (ctx) => {
   const { resolvedRoots, withResult } = ctx;
   const { settings, managedStateRead, candidate } = await resolveRequiredInstalledExtension(ctx);
-  const destinationDirectory = path8.join(resolvedRoots.selected_root, candidate.directory);
-  await fs8.rm(destinationDirectory, { recursive: true, force: true });
+  const destinationDirectory = path10.join(resolvedRoots.selected_root, candidate.directory);
+  await fs9.rm(destinationDirectory, { recursive: true, force: true });
   const updatedState = {
     ...managedStateRead.state,
     updated_at: nowIso(),
@@ -6296,56 +6490,9 @@ var requiresExtensionStateLock = (ctx) => [
 ].some(Boolean);
 var dispatchExtensionAction = (ctx) => requiresExtensionStateLock(ctx) ? withExtensionInstallLock(ctx.resolvedRoots.settings_root, `${ctx.action}-state`, () => EXTENSION_ACTION_HANDLERS[ctx.action](ctx)) : EXTENSION_ACTION_HANDLERS[ctx.action](ctx);
 
-// dist/sdk/workspace.js
-import { readFile, writeFile } from "node:fs/promises";
-import path9 from "node:path";
-!(function() {
-  try {
-    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "5b3e660c-f869-5a00-8082-1f0d240c74bf");
-  } catch (e2) {
-  }
-})();
-var PM_GITIGNORE_START = "# pm-cli:runtime-cache:start";
-var PM_GITIGNORE_END = "# pm-cli:runtime-cache:end";
-var PM_GITIGNORE_BLOCK = [
-  PM_GITIGNORE_START,
-  ".agents/pm/runtime/",
-  ".agents/pm/search/",
-  ".agents/pm/locks/",
-  PM_GITIGNORE_END
-].join("\n");
-function getPmGitignoreBlock() {
-  return PM_GITIGNORE_BLOCK;
-}
-async function ensurePmGitignore(workspaceRoot) {
-  const gitignorePath = path9.join(workspaceRoot, ".gitignore");
-  let current = "";
-  try {
-    current = await readFile(gitignorePath, "utf8");
-  } catch (error) {
-    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
-      throw error;
-    }
-  }
-  const start = current.indexOf(PM_GITIGNORE_START);
-  const end = current.indexOf(PM_GITIGNORE_END);
-  const withoutManagedBlock = start >= 0 && end >= start ? `${current.slice(0, start)}${current.slice(end + PM_GITIGNORE_END.length)}` : current;
-  const prefix = withoutManagedBlock.trimEnd();
-  const next = `${prefix.length > 0 ? `${prefix}
-
-` : ""}${PM_GITIGNORE_BLOCK}
-`;
-  if (next === current) {
-    return { path: gitignorePath, changed: false };
-  }
-  await writeFile(gitignorePath, next, "utf8");
-  return { path: gitignorePath, changed: true };
-}
-
 // dist/sdk/init-agent-guidance.js
-import fs9 from "node:fs/promises";
-import path10 from "node:path";
+import fs10 from "node:fs/promises";
+import path11 from "node:path";
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 !(function() {
@@ -6403,11 +6550,11 @@ function setAgentGuidanceReadlineFactoryForTests(factory) {
   createAgentGuidanceReadlineInterface = factory ?? (() => readline.createInterface({ input, output }));
 }
 function toPortableRelativePath(projectRoot, targetPath) {
-  const relative = path10.relative(projectRoot, targetPath);
+  const relative = path11.relative(projectRoot, targetPath);
   if (relative.length === 0) {
-    return path10.basename(targetPath);
+    return path11.basename(targetPath);
   }
-  return relative.split(path10.sep).join("/");
+  return relative.split(path11.sep).join("/");
 }
 function ensureTrailingNewline(value) {
   return value.endsWith("\n") ? value : `${value}
@@ -6470,14 +6617,14 @@ function upsertAgentGuidanceBlock(existingContent) {
   };
 }
 function resolveProjectRoot(pmRoot, cwd) {
-  const parent = path10.dirname(pmRoot);
-  if (path10.basename(pmRoot) === "pm" && path10.basename(parent) === ".agents") {
-    return path10.dirname(parent);
+  const parent = path11.dirname(pmRoot);
+  if (path11.basename(pmRoot) === "pm" && path11.basename(parent) === ".agents") {
+    return path11.dirname(parent);
   }
-  return path10.resolve(cwd, pmRoot);
+  return path11.resolve(cwd, pmRoot);
 }
 function resolveTargetGuidancePath(scans, projectRoot) {
-  const existingAgents = scans.find((entry) => path10.basename(entry.file_path) === "AGENTS.md" && entry.exists);
+  const existingAgents = scans.find((entry) => path11.basename(entry.file_path) === "AGENTS.md" && entry.exists);
   if (existingAgents) {
     return existingAgents.file_path;
   }
@@ -6485,7 +6632,7 @@ function resolveTargetGuidancePath(scans, projectRoot) {
   if (existingAny) {
     return existingAny.file_path;
   }
-  return path10.join(projectRoot, "AGENTS.md");
+  return path11.join(projectRoot, "AGENTS.md");
 }
 function parsePromptChoice(answer, currentDefault) {
   const normalized = answer.trim().toLowerCase();
@@ -6527,7 +6674,7 @@ function normalizeAgentGuidanceState(settings) {
 async function scanGuidanceFiles(projectRoot) {
   const scans = [];
   for (const filename of AGENT_GUIDANCE_TARGET_FILENAMES) {
-    const filePath = path10.join(projectRoot, filename);
+    const filePath = path11.join(projectRoot, filename);
     const exists = await pathExists(filePath);
     if (!exists) {
       scans.push({
@@ -6538,7 +6685,7 @@ async function scanGuidanceFiles(projectRoot) {
       });
       continue;
     }
-    const content = await fs9.readFile(filePath, "utf8");
+    const content = await fs10.readFile(filePath, "utf8");
     const contentLower = content.toLowerCase();
     const tokenHits = AGENT_GUIDANCE_REQUIRED_TOKENS.filter((token) => contentLower.includes(token));
     const hasMarker = hasGuidanceMarker(content);
@@ -6566,7 +6713,7 @@ function applyAgentGuidanceState(settings, currentState) {
 }
 async function writeGuidanceFile(filePath) {
   const exists = await pathExists(filePath);
-  const currentContent = exists ? await fs9.readFile(filePath, "utf8") : "";
+  const currentContent = exists ? await fs10.readFile(filePath, "utf8") : "";
   const nextContent = upsertAgentGuidanceBlock(currentContent);
   if (!nextContent.changed) {
     return { changed: false, warnings: [] };
@@ -6754,8 +6901,8 @@ async function runInitAgentGuidance(options) {
 }
 
 // dist/sdk/init.js
-import fs10 from "node:fs/promises";
-import path11 from "node:path";
+import fs11 from "node:fs/promises";
+import path12 from "node:path";
 import readline2 from "node:readline/promises";
 import { stdin as input2, stdout as output2 } from "node:process";
 import { hostname, userInfo } from "node:os";
@@ -6866,7 +7013,7 @@ function isPathLikeInitTarget(rawValue) {
   if (trimmed.length === 0) {
     return false;
   }
-  return path11.isAbsolute(trimmed) || /^[a-z]:/iu.test(trimmed) || trimmed.startsWith(".") || trimmed.includes("/") || trimmed.includes("\\");
+  return path12.isAbsolute(trimmed) || /^[a-z]:/iu.test(trimmed) || trimmed.startsWith(".") || trimmed.includes("/") || trimmed.includes("\\");
 }
 function resolveInitInvocation(cwd, global2, prefixArg, workspaceArg) {
   const normalizedWorkspace = workspaceArg?.trim();
@@ -6877,8 +7024,8 @@ function resolveInitInvocation(cwd, global2, prefixArg, workspaceArg) {
     if (global2.path !== void 0 || isPathLikeInitTarget(prefixArg)) {
       throw new PmCliError("--workspace cannot be combined with --pm-path/--path or a path-like positional target.", EXIT_CODE.USAGE);
     }
-    const workspaceRoot = path11.resolve(cwd, normalizedWorkspace);
-    const pmRoot2 = path11.join(workspaceRoot, ".agents", "pm");
+    const workspaceRoot = path12.resolve(cwd, normalizedWorkspace);
+    const pmRoot2 = path12.join(workspaceRoot, ".agents", "pm");
     return {
       pmRoot: pmRoot2,
       prefixArg,
@@ -6890,7 +7037,7 @@ function resolveInitInvocation(cwd, global2, prefixArg, workspaceArg) {
     };
   }
   if (global2.path === void 0 && isPathLikeInitTarget(prefixArg)) {
-    const positionalTarget = path11.resolve(cwd, prefixArg.trim());
+    const positionalTarget = path12.resolve(cwd, prefixArg.trim());
     return {
       pmRoot: positionalTarget,
       prefixArg: void 0,
@@ -7012,10 +7159,10 @@ async function isLikelyWorkspaceRoot(candidate) {
     "package.json",
     "pnpm-workspace.yaml",
     "AGENTS.md",
-    path11.join(".agents", "pm")
+    path12.join(".agents", "pm")
   ];
   for (const indicator of indicators) {
-    if (await pathExists(path11.join(candidate, indicator))) {
+    if (await pathExists(path12.join(candidate, indicator))) {
       return true;
     }
   }
@@ -7025,13 +7172,13 @@ async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, explicitTrack
   if (!explicitTrackerTarget || force) {
     return;
   }
-  if (await pathExists(path11.join(pmRoot, "settings.json"))) {
+  if (await pathExists(path12.join(pmRoot, "settings.json"))) {
     return;
   }
   if (!await isLikelyWorkspaceRoot(pmRoot)) {
     return;
   }
-  const nestedTracker = path11.join(pmRoot, ".agents", "pm");
+  const nestedTracker = path12.join(pmRoot, ".agents", "pm");
   throw new PmCliError(`Refusing to initialize tracker files directly in workspace root "${pmRoot}".`, EXIT_CODE.USAGE, {
     code: "workspace_root_pm_path",
     type: "urn:pm-cli:error:workspace_root_pm_path",
@@ -7055,9 +7202,9 @@ async function ensureInitDirectories(pmRoot, subdirs) {
   const createdDirs = [];
   const warnings = [];
   for (const subdir of subdirs) {
-    const target = subdir ? path11.join(pmRoot, subdir) : pmRoot;
+    const target = subdir ? path12.join(pmRoot, subdir) : pmRoot;
     const existed = await pathExists(target);
-    await fs10.mkdir(target, { recursive: true });
+    await fs11.mkdir(target, { recursive: true });
     if (existed) {
       warnings.push(`already_exists:${target}`);
     } else {
@@ -7290,10 +7437,10 @@ async function ensureInitTypeDirectories(params) {
   params.warnings.push(...scaffold.warnings);
 }
 function resolveInitWorkspaceRoot(target) {
-  const trackerRoot = path11.resolve(target.tracker_root);
-  const agentsRoot = path11.dirname(trackerRoot);
-  if (path11.basename(trackerRoot) === "pm" && path11.basename(agentsRoot) === ".agents") {
-    return path11.dirname(agentsRoot);
+  const trackerRoot = path12.resolve(target.tracker_root);
+  const agentsRoot = path12.dirname(trackerRoot);
+  if (path12.basename(trackerRoot) === "pm" && path12.basename(agentsRoot) === ".agents") {
+    return path12.dirname(agentsRoot);
   }
   return target.workspace_root;
 }
@@ -7350,7 +7497,7 @@ async function runInit(prefixArg, global2, options = {}) {
   const baseDirs = await ensureInitDirectories(pmRoot, PM_REQUIRED_SUBDIRS);
   createdDirs.push(...baseDirs.createdDirs);
   warnings.push(...baseDirs.warnings);
-  const settingsPath = path11.join(pmRoot, "settings.json");
+  const settingsPath = path12.join(pmRoot, "settings.json");
   const settingsExists = await pathExists(settingsPath);
   const settingsResolution = await resolveInitSettings({
     pmRoot,
@@ -7414,6 +7561,14 @@ async function runInit(prefixArg, global2, options = {}) {
 }
 
 export {
+  PM_GITIGNORE_START,
+  PM_GITIGNORE_END,
+  getPmGitignoreBlock,
+  ensurePmGitignore,
+  quoteWindowsCommandArg,
+  quoteCommandArg,
+  renderPmCommand,
+  normalizeExtensionNameForMatch,
   readManagedExtensionState,
   PM_PACKAGE_RESOURCE_KINDS,
   PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS,
@@ -7425,10 +7580,6 @@ export {
   collectUnknownCapabilityGuidance,
   buildCapabilityContractMetadata,
   runExtension,
-  PM_GITIGNORE_START,
-  PM_GITIGNORE_END,
-  getPmGitignoreBlock,
-  ensurePmGitignore,
   INIT_AGENT_GUIDANCE_MODE_VALUES,
   _testOnly,
   runInitAgentGuidance,
@@ -7436,4 +7587,4 @@ export {
   _testOnly2,
   runInit
 };
-//# sourceMappingURL=chunk-DHNG452T.js.map
+//# sourceMappingURL=chunk-ZF52NVRT.js.map