@unbrained/pm-cli 2026.7.18 → 2026.7.19

package/dist/cli-bundle/chunks/{chunk-QRZNCRNA.js → chunk-MI3346YW.js}

@@ -1,38 +1,29 @@
 
-!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]="f34a834c-7c67-555c-a8b0-6c26e7d8c12a")}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]="36449c46-4651-5a6f-93c6-1065305d35d8")}catch(e){}}();
+import {
+  EXECUTABLE_COMMAND_ALIASES,
+  PM_CORE_COMMAND_NAMES
+} from "./chunk-JPWUZOMR.js";
 import {
   ensureTypeFolderScaffold
-} from "./chunk-FXFCFL73.js";
+} from "./chunk-H3YKUVDR.js";
 import {
-  normalizeExtensionNameForMatch,
-  normalizeManagedDirectoryName,
-  normalizeStringList,
-  parseExtensionManifest,
-  quoteCommandArg,
-  renderPmCommand,
-  validateExtensionDirectory
-} from "./chunk-FL4D53ND.js";
+  splitCommaList
+} from "./chunk-NETP4DY4.js";
 import {
   describeExtensionActivation,
   renderExtensionSurfaceMarkdown
-} from "./chunk-5UKQLQM2.js";
+} from "./chunk-Q5NHJ6RO.js";
 import {
   TYPE_PRESET_NAMES,
   normalizeTypePresetName,
   resolveTypePresetDefinitions
-} from "./chunk-N33FD2UI.js";
-import {
-  EXECUTABLE_COMMAND_ALIASES,
-  PM_CORE_COMMAND_NAMES
-} from "./chunk-7UCY6DR5.js";
+} from "./chunk-UNNCT5QY.js";
 import {
   parseItemTypesFile,
   serializeItemTypesFile,
   upsertItemType
-} from "./chunk-ARGDWQ4J.js";
-import {
-  splitCommaList
-} from "./chunk-NETP4DY4.js";
+} from "./chunk-IGBBTPM5.js";
 import {
   createSerialQueue,
   getActiveExtensionRegistrations,
@@ -41,8 +32,9 @@ import {
   readSettings,
   runActiveOnWriteHooks,
   writeSettings
-} from "./chunk-P22HGFFI.js";
+} from "./chunk-QFG4MB7P.js";
 import {
+  DEFAULT_EXTENSION_PRIORITY,
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
   EXIT_CODE,
   EXTENSION_CAPABILITY_CONTRACT,
@@ -55,6 +47,7 @@ import {
   ensureRuntimeSchemaFileScaffold,
   filePathForSchemaSection,
   getSettingsPath,
+  isCanonicalPathWithinDirectory,
   isPathWithinDirectory,
   levenshteinDistanceWithinLimit,
   loadExtensions,
@@ -71,11 +64,81 @@ import {
   resolvePmPackageRootFromModule,
   resolvePmRoot,
   writeFileAtomic
-} from "./chunk-KX62NMZC.js";
+} from "./chunk-D35WYXWC.js";
+
+// dist/sdk/workspace.js
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+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
+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";
 var PM_PACKAGE_RESOURCE_KINDS = [
   "extensions",
   "docs",
@@ -193,7 +256,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",
@@ -239,15 +302,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);
@@ -257,11 +320,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;
     }
@@ -271,7 +334,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);
       }
     }
@@ -280,8 +343,118 @@ 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 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
 var SCAFFOLD_MANIFEST_VERSION = 1;
 var SCAFFOLD_PM_MIN_VERSION = "2026.6.24";
 var SCAFFOLD_NODE_ENGINE = ">=22.18.0";
@@ -2385,33 +2558,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,
@@ -2419,8 +2592,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"
@@ -2507,16 +2680,16 @@ 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";
 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 {
@@ -2635,7 +2808,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) {
@@ -2667,8 +2840,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) {
@@ -2683,15 +2856,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";
 var PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
 var LEGACY_BUNDLED_PACKAGE_ALIASES = {
   beads: {
@@ -2708,7 +2881,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)];
@@ -2724,8 +2897,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;
     }
   }
@@ -2738,13 +2911,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);
@@ -2766,7 +2939,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;
     }
@@ -2777,8 +2950,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,
@@ -2841,7 +3014,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,
@@ -2866,7 +3039,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) => 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,
@@ -3036,7 +3209,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) {
@@ -3144,8 +3317,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 {
@@ -3157,7 +3330,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;
     }
@@ -3193,7 +3366,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 {
@@ -3210,7 +3383,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
       };
@@ -3222,7 +3395,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) {
@@ -3231,8 +3404,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,
@@ -3241,11 +3414,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([
@@ -3257,7 +3430,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 {
@@ -3265,11 +3438,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;
@@ -3278,13 +3451,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;
   }
@@ -3301,12 +3474,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([
@@ -3324,7 +3497,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");
   }
 }
@@ -3364,11 +3537,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";
@@ -3398,7 +3571,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);
@@ -3407,26 +3580,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) {
@@ -3448,7 +3621,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,
@@ -3482,7 +3655,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);
     }
@@ -3501,12 +3674,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);
@@ -3527,11 +3700,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;
   }
 }
@@ -3540,8 +3713,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;
 }
@@ -4058,9 +4231,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";
 var EXTENSION_INSTALL_COPY_ATTEMPTS = 3;
 var EXTENSION_INSTALL_LOCK_ATTEMPTS = 120;
 var EXTENSION_INSTALL_LOCK_DELAY_MS = 250;
@@ -4077,34 +4250,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;
@@ -4116,13 +4289,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,
@@ -4133,13 +4306,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) {
@@ -4153,7 +4326,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;
@@ -4176,13 +4349,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;
   }
@@ -4191,7 +4364,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);
@@ -4204,7 +4377,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();
@@ -4214,12 +4387,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;
   }
@@ -4243,9 +4416,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);
@@ -4344,9 +4517,9 @@ var checkGithubUpdate = async (source, gitCommandRunner = runGitCommand) => {
 };
 
 // dist/sdk/extension/install-snapshot.js
-import fs7 from "node:fs/promises";
-import path7 from "node:path";
-var readOptionalMetadataFile = async (filePath) => fs7.readFile(filePath).catch((error) => {
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
+var readOptionalMetadataFile = async (filePath) => fs8.readFile(filePath).catch((error) => {
   if (isErrnoCode(error, "ENOENT"))
     return null;
   throw error;
@@ -4359,7 +4532,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
     });
@@ -4375,9 +4548,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
     });
@@ -4387,10 +4560,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);
     }
   }
 };
@@ -4789,14 +4962,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}`
@@ -4824,7 +4997,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),
@@ -4962,7 +5135,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 = {
@@ -5370,12 +5543,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);
@@ -5419,7 +5592,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) => {
@@ -5676,7 +5849,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);
@@ -5724,8 +5897,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(),
@@ -6214,49 +6387,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";
-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";
 var INIT_AGENT_GUIDANCE_MODE_VALUES = [
@@ -6307,11 +6440,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}
@@ -6374,14 +6507,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;
   }
@@ -6389,7 +6522,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();
@@ -6431,7 +6564,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({
@@ -6442,7 +6575,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);
@@ -6470,7 +6603,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: [] };
@@ -6658,8 +6791,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";
@@ -6763,7 +6896,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, global, prefixArg, workspaceArg) {
   const normalizedWorkspace = workspaceArg?.trim();
@@ -6774,8 +6907,8 @@ function resolveInitInvocation(cwd, global, prefixArg, workspaceArg) {
     if (global.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,
@@ -6787,7 +6920,7 @@ function resolveInitInvocation(cwd, global, prefixArg, workspaceArg) {
     };
   }
   if (global.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,
@@ -6909,10 +7042,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;
     }
   }
@@ -6922,13 +7055,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",
@@ -6952,9 +7085,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 {
@@ -7187,10 +7320,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;
 }
@@ -7247,7 +7380,7 @@ async function runInit(prefixArg, global, 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,
@@ -7311,6 +7444,14 @@ async function runInit(prefixArg, global, options = {}) {
 }
 
 export {
+  PM_GITIGNORE_START,
+  PM_GITIGNORE_END,
+  getPmGitignoreBlock,
+  ensurePmGitignore,
+  quoteWindowsCommandArg,
+  quoteCommandArg,
+  renderPmCommand,
+  normalizeExtensionNameForMatch,
   readManagedExtensionState,
   PM_PACKAGE_RESOURCE_KINDS,
   PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS,
@@ -7322,10 +7463,6 @@ export {
   collectUnknownCapabilityGuidance,
   buildCapabilityContractMetadata,
   runExtension,
-  PM_GITIGNORE_START,
-  PM_GITIGNORE_END,
-  getPmGitignoreBlock,
-  ensurePmGitignore,
   INIT_AGENT_GUIDANCE_MODE_VALUES,
   _testOnly,
   runInitAgentGuidance,
@@ -7333,6 +7470,6 @@ export {
   _testOnly2,
   runInit
 };
-//# sourceMappingURL=chunk-QRZNCRNA.js.map
+//# sourceMappingURL=chunk-MI3346YW.js.map
 
-//# debugId=f34a834c-7c67-555c-a8b0-6c26e7d8c12a
+//# debugId=36449c46-4651-5a6f-93c6-1065305d35d8