@unbrained/pm-cli 2026.7.19 → 2026.7.20

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

@@ -1,29 +1,32 @@
 
-!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){}}();
+!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]="17c1b721-84a1-59e2-8865-f28ad0b84cc7")}catch(e){}}();
 import {
   EXECUTABLE_COMMAND_ALIASES,
   PM_CORE_COMMAND_NAMES
-} from "./chunk-JPWUZOMR.js";
+} from "./chunk-UZDQXNUB.js";
 import {
   ensureTypeFolderScaffold
-} from "./chunk-H3YKUVDR.js";
+} from "./chunk-5UX66S6U.js";
+import {
+  ensurePmGitignore
+} from "./chunk-CFHAODHQ.js";
 import {
   splitCommaList
 } from "./chunk-NETP4DY4.js";
 import {
   describeExtensionActivation,
   renderExtensionSurfaceMarkdown
-} from "./chunk-Q5NHJ6RO.js";
+} from "./chunk-6JUTHVQS.js";
 import {
   TYPE_PRESET_NAMES,
   normalizeTypePresetName,
   resolveTypePresetDefinitions
-} from "./chunk-UNNCT5QY.js";
+} from "./chunk-SZVB53Y3.js";
 import {
   parseItemTypesFile,
   serializeItemTypesFile,
   upsertItemType
-} from "./chunk-IGBBTPM5.js";
+} from "./chunk-TOBGV45Y.js";
 import {
   createSerialQueue,
   getActiveExtensionRegistrations,
@@ -32,7 +35,7 @@ import {
   readSettings,
   runActiveOnWriteHooks,
   writeSettings
-} from "./chunk-QFG4MB7P.js";
+} from "./chunk-POG76WWZ.js";
 import {
   DEFAULT_EXTENSION_PRIORITY,
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
@@ -64,47 +67,7 @@ import {
   resolvePmPackageRootFromModule,
   resolvePmRoot,
   writeFileAtomic
-} 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 };
-}
+} from "./chunk-HYW67VJ5.js";
 
 // dist/sdk/command-line.js
 var quoteWindowsCommandArg = (arg) => {
@@ -138,7 +101,7 @@ var renderPmCommand = (argv, platform = process.platform) => {
 
 // dist/core/packages/manifest.js
 import fs from "node:fs/promises";
-import path2 from "node:path";
+import path from "node:path";
 var PM_PACKAGE_RESOURCE_KINDS = [
   "extensions",
   "docs",
@@ -256,7 +219,7 @@ function normalizePackageCatalogMetadata(raw) {
   return Object.values(catalog).some((value) => value !== void 0) ? catalog : void 0;
 }
 async function readPmPackageManifest(packageRoot) {
-  const packageJsonPath = path2.join(packageRoot, "package.json");
+  const packageJsonPath = path.join(packageRoot, "package.json");
   if (!await pathExists(packageJsonPath)) {
     return {
       source: "convention",
@@ -302,15 +265,15 @@ async function listExtensionManifestDirectories(parentDirectory) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const directory = path2.join(parentDirectory, entry.name);
-    if (await pathExists(path2.join(directory, "manifest.json"))) {
+    const directory = path.join(parentDirectory, entry.name);
+    if (await pathExists(path.join(directory, "manifest.json"))) {
       candidates.push(directory);
     }
   }
   return candidates.sort((left, right) => left.localeCompare(right));
 }
 async function collectPackageExtensionDirectories(packageRoot) {
-  if (await pathExists(path2.join(packageRoot, "manifest.json"))) {
+  if (await pathExists(path.join(packageRoot, "manifest.json"))) {
     return [packageRoot];
   }
   const manifest = await readPmPackageManifest(packageRoot);
@@ -320,11 +283,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 = path2.resolve(packageRoot, entry);
+    const absolute = path.resolve(packageRoot, entry);
     if (!isPathWithinDirectory(packageRoot, absolute)) {
       throw new PmCliError(`Package extension entry "${entry}" resolves outside package root.`, EXIT_CODE.USAGE);
     }
-    if (await pathExists(path2.join(absolute, "manifest.json"))) {
+    if (await pathExists(path.join(absolute, "manifest.json"))) {
       discovered.add(absolute);
       continue;
     }
@@ -334,7 +297,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(path2.join(packageRoot, root))) {
+      for (const child of await listExtensionManifestDirectories(path.join(packageRoot, root))) {
         discovered.add(child);
       }
     }
@@ -344,11 +307,11 @@ async function collectPackageExtensionDirectories(packageRoot) {
 
 // dist/sdk/extension/scaffold.js
 import fs3 from "node:fs/promises";
-import path4 from "node:path";
+import path3 from "node:path";
 
 // dist/sdk/extension/shared.js
 import fs2 from "node:fs/promises";
-import path3 from "node:path";
+import path2 from "node:path";
 function normalizeStringList(values) {
   return [
     ...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))
@@ -419,7 +382,7 @@ function parseExtensionManifest(raw) {
   };
 }
 async function validateExtensionDirectory(directory) {
-  const manifestPath = path3.join(directory, "manifest.json");
+  const manifestPath = path2.join(directory, "manifest.json");
   if (!await pathExists(manifestPath)) {
     throw new PmCliError(`Extension manifest is missing at "${manifestPath}".`, EXIT_CODE.USAGE);
   }
@@ -433,7 +396,7 @@ async function validateExtensionDirectory(directory) {
   if (!manifest) {
     throw new PmCliError(`Extension manifest at "${manifestPath}" is invalid.`, EXIT_CODE.USAGE);
   }
-  const entryPath = path3.resolve(directory, manifest.entry);
+  const entryPath = path2.resolve(directory, manifest.entry);
   if (!isPathWithinDirectory(directory, entryPath)) {
     throw new PmCliError(`Extension entry "${manifest.entry}" resolves outside extension directory "${directory}".`, EXIT_CODE.USAGE);
   }
@@ -2558,8 +2521,8 @@ async function scaffoldExtensionProject(target, vocabulary = "extension", capabi
   }
   const style = declarative ? "declarative" : "imperative";
   const normalizedTarget = target.trim();
-  const targetPath = path4.resolve(process.cwd(), normalizedTarget);
-  const extensionName = normalizeManagedDirectoryName(path4.basename(targetPath));
+  const targetPath = path3.resolve(process.cwd(), normalizedTarget);
+  const extensionName = normalizeManagedDirectoryName(path3.basename(targetPath));
   const commandName = buildScaffoldCommandName(extensionName);
   const scaffoldFiles = buildStarterExtensionScaffoldFiles(extensionName, commandName, vocabulary, resolvedCapability, declarative);
   let createdDirectory = false;
@@ -2573,7 +2536,7 @@ async function scaffoldExtensionProject(target, vocabulary = "extension", capabi
     createdDirectory = true;
   }
   for (const [relativePath, content] of Object.entries(scaffoldFiles)) {
-    const absolutePath = path4.join(targetPath, relativePath);
+    const absolutePath = path3.join(targetPath, relativePath);
     if (!await pathExists(absolutePath)) {
       continue;
     }
@@ -2584,7 +2547,7 @@ async function scaffoldExtensionProject(target, vocabulary = "extension", capabi
   }
   const files = [];
   for (const [relativePath, content] of Object.entries(scaffoldFiles)) {
-    const absolutePath = path4.join(targetPath, relativePath);
+    const absolutePath = path3.join(targetPath, relativePath);
     if (await pathExists(absolutePath)) {
       files.push({
         path: relativePath,
@@ -2592,7 +2555,7 @@ async function scaffoldExtensionProject(target, vocabulary = "extension", capabi
       });
       continue;
     }
-    await fs3.mkdir(path4.dirname(absolutePath), { recursive: true });
+    await fs3.mkdir(path3.dirname(absolutePath), { recursive: true });
     await fs3.writeFile(absolutePath, content, "utf8");
     files.push({
       path: relativePath,
@@ -2681,15 +2644,15 @@ function renderExtensionDescribeMarkdown(result, noun) {
 
 // dist/sdk/extension.js
 import fs9 from "node:fs/promises";
-import path10 from "node:path";
+import path9 from "node:path";
 
 // dist/sdk/extension/managed-state.js
 import fs4 from "node:fs/promises";
-import path5 from "node:path";
+import path4 from "node:path";
 var MANAGED_EXTENSION_STATE_FILENAME = ".managed-extensions.json";
 var MANAGED_EXTENSION_STATE_VERSION = 1;
 function resolveManagedExtensionStatePath(extensionsRoot) {
-  return path5.join(extensionsRoot, MANAGED_EXTENSION_STATE_FILENAME);
+  return path4.join(extensionsRoot, MANAGED_EXTENSION_STATE_FILENAME);
 }
 function createEmptyManagedExtensionState() {
   return {
@@ -2858,13 +2821,13 @@ function upsertManagedEntry(state, entry) {
 import { execFile } from "node:child_process";
 import fs6 from "node:fs/promises";
 import os from "node:os";
-import path7 from "node:path";
+import path6 from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
 // dist/sdk/extension/bundled-catalog.js
 import fs5 from "node:fs/promises";
-import path6 from "node:path";
+import path5 from "node:path";
 var PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
 var LEGACY_BUNDLED_PACKAGE_ALIASES = {
   beads: {
@@ -2881,7 +2844,7 @@ function resolvePackageRootCandidates() {
   const candidates = [];
   const envRoot = process.env[PM_PACKAGE_ROOT_ENV];
   if (typeof envRoot === "string" && envRoot.trim().length > 0) {
-    candidates.push(path6.resolve(envRoot.trim()));
+    candidates.push(path5.resolve(envRoot.trim()));
   }
   candidates.push(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]));
   return [...new Set(candidates)];
@@ -2897,8 +2860,8 @@ async function resolveBundledExtensionAliasSource(input3) {
     return null;
   }
   for (const packageRoot2 of resolvePackageRootCandidates()) {
-    const legacyExtensionPath = path6.join(packageRoot2, ".agents", "pm", "extensions", alias.legacy_extension_directory);
-    if (await pathExists(path6.join(legacyExtensionPath, "manifest.json"))) {
+    const legacyExtensionPath = path5.join(packageRoot2, ".agents", "pm", "extensions", alias.legacy_extension_directory);
+    if (await pathExists(path5.join(legacyExtensionPath, "manifest.json"))) {
       return legacyExtensionPath;
     }
   }
@@ -2916,8 +2879,8 @@ async function collectManifestPackageEntries(packagesRoot, entriesByAlias) {
     if (!entry.isDirectory() || !entry.name.startsWith("pm-")) {
       continue;
     }
-    const candidateRoot = path6.join(packagesRoot, entry.name);
-    if (!await pathExists(path6.join(candidateRoot, "package.json"))) {
+    const candidateRoot = path5.join(packagesRoot, entry.name);
+    if (!await pathExists(path5.join(candidateRoot, "package.json"))) {
       continue;
     }
     const manifest = await readPmPackageManifest(candidateRoot);
@@ -2939,7 +2902,7 @@ async function collectManifestPackageEntries(packagesRoot, entriesByAlias) {
 async function collectBundledPackageEntries() {
   const entriesByAlias = /* @__PURE__ */ new Map();
   for (const packageRoot of resolvePackageRootCandidates()) {
-    const packagesRoot = path6.join(packageRoot, "packages");
+    const packagesRoot = path5.join(packageRoot, "packages");
     if (!await pathExists(packagesRoot)) {
       continue;
     }
@@ -2950,8 +2913,8 @@ async function collectBundledPackageEntries() {
       continue;
     }
     for (const packageRoot of resolvePackageRootCandidates()) {
-      const packagePath = path6.join(packageRoot, "packages", legacy.package_directory);
-      if (await pathExists(path6.join(packagePath, "package.json"))) {
+      const packagePath = path5.join(packageRoot, "packages", legacy.package_directory);
+      if (await pathExists(path5.join(packagePath, "package.json"))) {
         entriesByAlias.set(alias, {
           alias,
           package_directory: legacy.package_directory,
@@ -3014,7 +2977,7 @@ function buildBundledCatalogPackageEntry(manifest, bundledEntry, scope, installe
     alias: bundledEntry.alias,
     bundled: true,
     available: true,
-    installed: installedBuiltinAliases.has(bundledEntry.alias) || installedLocations.has(path6.resolve(bundledEntry.package_root)),
+    installed: installedBuiltinAliases.has(bundledEntry.alias) || installedLocations.has(path5.resolve(bundledEntry.package_root)),
     install_target: bundledEntry.alias,
     install_command: `pm install ${bundledEntry.alias} ${installScopeFlag}`,
     package_name: manifest.package_name,
@@ -3039,7 +3002,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) => path6.resolve(entry.source.location)));
+  const installedLocations = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope).filter((entry) => entry.source.kind !== "builtin").map((entry) => path5.resolve(entry.source.location)));
   const installedBuiltinAliases = new Set(managedStateRead.state.entries.filter((entry) => entry.scope === scope && entry.source.kind === "builtin").flatMap((entry) => [
     entry.source.name,
     entry.source.input,
@@ -3209,7 +3172,7 @@ function parseExtensionInstallSource(input3, options = {}) {
   return {
     kind: "local",
     input: normalizedInput,
-    absolute_path: path7.resolve(process.cwd(), normalizedInput)
+    absolute_path: path6.resolve(process.cwd(), normalizedInput)
   };
 }
 async function runGitCommand(args, execRunner = execFileAsync, timeoutMs) {
@@ -3317,8 +3280,8 @@ function wrapNpmPackResolutionError(spec, error) {
   return new PmCliError(recovery.message, EXIT_CODE.NOT_FOUND, recovery.context);
 }
 async function resolveLocalNpmPackagePath(spec) {
-  if (path7.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..")) {
-    const absolutePath = path7.resolve(process.cwd(), spec);
+  if (path6.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("..")) {
+    const absolutePath = path6.resolve(process.cwd(), spec);
     return await pathExists(absolutePath) ? absolutePath : null;
   }
   try {
@@ -3330,7 +3293,7 @@ async function resolveLocalNpmPackagePath(spec) {
   } catch {
   }
   if (!/^[a-z][a-z0-9+.-]*:/i.test(spec)) {
-    const absolutePath = path7.resolve(process.cwd(), spec);
+    const absolutePath = path6.resolve(process.cwd(), spec);
     if (await pathExists(absolutePath)) {
       return absolutePath;
     }
@@ -3366,7 +3329,7 @@ function normalizeNpmLocalFileAliasSpec(spec, cwd = process.cwd()) {
     return spec;
   }
   if (!target.startsWith("/")) {
-    return `${packageName}@${path7.resolve(cwd, target)}`;
+    return `${packageName}@${path6.resolve(cwd, target)}`;
   }
   let decodedPath;
   try {
@@ -3383,7 +3346,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: path7.resolve(packDirectory, first.filename),
+        tarball: path6.resolve(packDirectory, first.filename),
         package: typeof first.name === "string" ? first.name : void 0,
         version: typeof first.version === "string" ? first.version : void 0
       };
@@ -3395,7 +3358,7 @@ function parsePackedNpmPackage(stdout, packDirectory) {
     throw new PmCliError("npm pack did not report a tarball filename.", EXIT_CODE.GENERIC_FAILURE);
   }
   return {
-    tarball: path7.resolve(packDirectory, lastLine)
+    tarball: path6.resolve(packDirectory, lastLine)
   };
 }
 async function resolveNpmSourceDirectory(source) {
@@ -3404,7 +3367,7 @@ async function resolveNpmSourceDirectory(source) {
 async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
   const localPackageRoot = await resolveLocalNpmPackagePath(source.spec);
   if (localPackageRoot) {
-    const packageJsonPath = path7.join(localPackageRoot, "package.json");
+    const packageJsonPath = path6.join(localPackageRoot, "package.json");
     const packageJson = await pathExists(packageJsonPath) ? JSON.parse(await fs6.readFile(packageJsonPath, "utf8")) : {};
     return {
       directory: await resolvePackageExtensionDirectory(localPackageRoot, source.input),
@@ -3414,9 +3377,9 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
       }
     };
   }
-  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");
+  const tempRoot = await fs6.mkdtemp(path6.join(os.tmpdir(), "pm-npm-package-source-"));
+  const packDirectory = path6.join(tempRoot, "pack");
+  const extractDirectory = path6.join(tempRoot, "extract");
   await fs6.mkdir(packDirectory, { recursive: true });
   await fs6.mkdir(extractDirectory, { recursive: true });
   try {
@@ -3430,7 +3393,7 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
     ]);
     const packed = parsePackedNpmPackage(packStdout, packDirectory);
     await execFileAsync("tar", ["-xzf", packed.tarball, "-C", extractDirectory], { encoding: "utf8" });
-    const packageRoot = path7.join(extractDirectory, "package");
+    const packageRoot = path6.join(extractDirectory, "package");
     await installNpmPackageRuntimeDependencies(packageRoot);
     const directory = await resolvePackageExtensionDirectory(packageRoot, source.input);
     return {
@@ -3451,7 +3414,7 @@ async function resolveNpmSourceDirectoryWithRunner(source, npmRunner) {
   }
 }
 async function installNpmPackageRuntimeDependencies(packageRoot) {
-  const packageJsonPath = path7.join(packageRoot, "package.json");
+  const packageJsonPath = path6.join(packageRoot, "package.json");
   if (!await pathExists(packageJsonPath)) {
     return;
   }
@@ -3478,8 +3441,8 @@ async function installNpmPackageRuntimeDependencies(packageRoot) {
 `, "utf8");
   try {
     await Promise.all([
-      fs6.rm(path7.join(packageRoot, "package-lock.json"), { force: true }),
-      fs6.rm(path7.join(packageRoot, "npm-shrinkwrap.json"), { force: true })
+      fs6.rm(path6.join(packageRoot, "package-lock.json"), { force: true }),
+      fs6.rm(path6.join(packageRoot, "npm-shrinkwrap.json"), { force: true })
     ]);
     if (dependencySpecs.length > 0) {
       await runNpmCommand([
@@ -3537,8 +3500,8 @@ async function linkHostedPmCliDependency(packageRoot) {
     "../../.."
   ]);
   const [scope, packageName] = PM_CLI_PACKAGE_NAME.split("/");
-  const scopedDirectory = path7.join(packageRoot, "node_modules", scope);
-  const linkPath = path7.join(scopedDirectory, packageName);
+  const scopedDirectory = path6.join(packageRoot, "node_modules", scope);
+  const linkPath = path6.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));
@@ -3571,7 +3534,7 @@ async function resolvePackageExtensionDirectory(packageRoot, sourceLabel) {
     return discovered[0];
   }
   if (discovered.length > 1) {
-    const choices = discovered.map((entry) => path7.relative(packageRoot, entry).replaceAll(path7.sep, "/")).sort((left, right) => left.localeCompare(right));
+    const choices = discovered.map((entry) => path6.relative(packageRoot, entry).replaceAll(path6.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);
@@ -3580,26 +3543,26 @@ async function resolveGithubSourceDirectory(cloneDirectory, source) {
   const candidatePaths = [];
   if (source.subpath) {
     candidatePaths.push(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));
+    candidatePaths.push(path6.posix.join(".agents/pm/extensions", source.subpath));
+    candidatePaths.push(path6.posix.join(".custom/pm-extensions", source.subpath));
+    candidatePaths.push(path6.posix.join(".custom/pm-extension", source.subpath));
   }
   for (const candidate of candidatePaths) {
-    const absolute = path7.resolve(cloneDirectory, candidate);
+    const absolute = path6.resolve(cloneDirectory, candidate);
     if (!isPathWithinDirectory(cloneDirectory, absolute)) {
       continue;
     }
-    if (await pathExists(path7.join(absolute, "manifest.json"))) {
+    if (await pathExists(path6.join(absolute, "manifest.json"))) {
       return { directory: absolute, resolved_subpath: candidate };
     }
   }
-  if (await pathExists(path7.join(cloneDirectory, "manifest.json"))) {
+  if (await pathExists(path6.join(cloneDirectory, "manifest.json"))) {
     return { directory: cloneDirectory, resolved_subpath: "." };
   }
   const discoveredDirectory = await resolvePackageExtensionDirectory(cloneDirectory, source.input);
   return {
     directory: discoveredDirectory,
-    resolved_subpath: path7.relative(cloneDirectory, discoveredDirectory).replaceAll(path7.sep, "/")
+    resolved_subpath: path6.relative(cloneDirectory, discoveredDirectory).replaceAll(path6.sep, "/")
   };
 }
 function looksLikeBarePackageName(input3) {
@@ -3621,7 +3584,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 ? path7.resolve(envPackageRoot.trim()) : "";
+    const cacheKey = typeof envPackageRoot === "string" && envPackageRoot.trim().length > 0 ? path6.resolve(envPackageRoot.trim()) : "";
     if (bundledPackageAliasesCache?.key !== cacheKey) {
       bundledPackageAliasesCache = {
         key: cacheKey,
@@ -3674,12 +3637,12 @@ async function resolveInstallSource(source) {
       source,
       directory: resolved.directory,
       cleanup: resolved.cleanup,
-      resolved_subpath: path7.relative(path7.dirname(resolved.directory), resolved.directory).replaceAll(path7.sep, "/"),
+      resolved_subpath: path6.relative(path6.dirname(resolved.directory), resolved.directory).replaceAll(path6.sep, "/"),
       npm_package: resolved.package,
       npm_version: resolved.version
     };
   }
-  const cloneDirectory = await fs6.mkdtemp(path7.join(os.tmpdir(), "pm-extension-source-"));
+  const cloneDirectory = await fs6.mkdtemp(path6.join(os.tmpdir(), "pm-extension-source-"));
   const cloneArgs = ["clone", "--depth", "1"];
   if (source.ref) {
     cloneArgs.push("--branch", source.ref);
@@ -4233,7 +4196,7 @@ function buildDoctorConsistencySummary(scope, installedExtensions, loadedExtensi
 import { randomUUID } from "node:crypto";
 import fs7 from "node:fs/promises";
 import os2 from "node:os";
-import path8 from "node:path";
+import path7 from "node:path";
 var EXTENSION_INSTALL_COPY_ATTEMPTS = 3;
 var EXTENSION_INSTALL_LOCK_ATTEMPTS = 120;
 var EXTENSION_INSTALL_LOCK_DELAY_MS = 250;
@@ -4250,7 +4213,7 @@ var sleep = (ms) => new Promise((resolve) => {
   setTimeout(resolve, ms);
 });
 var ensureExtensionModuleTypeMarker = async (destinationDirectory) => {
-  const markerPath = path8.join(destinationDirectory, "package.json");
+  const markerPath = path7.join(destinationDirectory, "package.json");
   if (await pathExists(markerPath)) {
     return;
   }
@@ -4258,25 +4221,25 @@ var ensureExtensionModuleTypeMarker = async (destinationDirectory) => {
 `, "utf8");
 };
 var resolveCanonicalExtensionInstallDestination = async (destinationDirectory) => {
-  const resolvedDestination = path8.resolve(destinationDirectory);
-  const destinationParent = path8.dirname(resolvedDestination);
-  const destinationRoot = path8.parse(destinationParent).root;
+  const resolvedDestination = path7.resolve(destinationDirectory);
+  const destinationParent = path7.dirname(resolvedDestination);
+  const destinationRoot = path7.parse(destinationParent).root;
   let canonicalDestinationParent = await fs7.realpath(destinationRoot).catch(() => destinationRoot);
-  const relativeDestinationParent = path8.relative(destinationRoot, destinationParent);
-  const destinationSegments = relativeDestinationParent === "" ? [] : relativeDestinationParent.split(path8.sep);
+  const relativeDestinationParent = path7.relative(destinationRoot, destinationParent);
+  const destinationSegments = relativeDestinationParent === "" ? [] : relativeDestinationParent.split(path7.sep);
   for (const [index, segment] of destinationSegments.entries()) {
-    const candidate = path8.join(canonicalDestinationParent, segment);
+    const candidate = path7.join(canonicalDestinationParent, segment);
     try {
       canonicalDestinationParent = await fs7.realpath(candidate);
     } catch {
-      canonicalDestinationParent = path8.join(canonicalDestinationParent, ...destinationSegments.slice(index));
+      canonicalDestinationParent = path7.join(canonicalDestinationParent, ...destinationSegments.slice(index));
       break;
     }
   }
-  return path8.join(canonicalDestinationParent, path8.basename(resolvedDestination));
+  return path7.join(canonicalDestinationParent, path7.basename(resolvedDestination));
 };
 var copyExtensionDirectoryWithoutSelfNesting = async (sourceDirectory, destinationDirectory, copyDirectory, temporaryDirectory = os2.tmpdir()) => {
-  const resolvedSource = path8.resolve(sourceDirectory);
+  const resolvedSource = path7.resolve(sourceDirectory);
   const canonicalSource = await fs7.realpath(resolvedSource).catch(() => resolvedSource);
   const canonicalDestination = await resolveCanonicalExtensionInstallDestination(destinationDirectory);
   if (canonicalSource === canonicalDestination) {
@@ -4289,13 +4252,13 @@ var copyExtensionDirectoryWithoutSelfNesting = async (sourceDirectory, destinati
     });
     return;
   }
-  const systemTempDirectory = path8.resolve(temporaryDirectory);
-  const stagingBase = isPathWithinDirectory(canonicalSource, systemTempDirectory) ? path8.dirname(canonicalSource) : systemTempDirectory;
+  const systemTempDirectory = await fs7.realpath(path7.resolve(temporaryDirectory)).catch(() => resolveCanonicalExtensionInstallDestination(temporaryDirectory));
+  const stagingBase = isPathWithinDirectory(canonicalSource, systemTempDirectory) ? path7.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 fs7.mkdtemp(path8.join(stagingBase, "pm-extension-copy-"));
-  const stagedDirectory = path8.join(stagingRoot, "extension");
+  const stagingRoot = await fs7.mkdtemp(path7.join(stagingBase, "pm-extension-copy-"));
+  const stagedDirectory = path7.join(stagingRoot, "extension");
   try {
     await copyDirectory(sourceDirectory, stagedDirectory, {
       recursive: true,
@@ -4326,7 +4289,7 @@ var copyExtensionDirectoryForInstall = async (sourceDirectory, destinationDirect
 var readExtensionInstallLockOwnerToken = async (lockPath) => {
   let ownerContents;
   try {
-    ownerContents = await fs7.readFile(path8.join(lockPath, "owner.json"), "utf8");
+    ownerContents = await fs7.readFile(path7.join(lockPath, "owner.json"), "utf8");
   } catch (error) {
     if (!isErrnoCode(error, "ENOENT"))
       throw error;
@@ -4389,7 +4352,7 @@ var startExtensionInstallLockHeartbeat = (lockPath, ownerToken, intervalMs) => {
 var createExtensionInstallLock = async (lockPath, owner) => {
   await fs7.mkdir(lockPath);
   try {
-    await fs7.writeFile(path8.join(lockPath, "owner.json"), `${JSON.stringify(owner, null, 2)}
+    await fs7.writeFile(path7.join(lockPath, "owner.json"), `${JSON.stringify(owner, null, 2)}
 `, "utf8");
   } catch (error) {
     await fs7.rm(lockPath, { recursive: true, force: true }).catch(() => {
@@ -4416,8 +4379,8 @@ var acquireExtensionInstallLock = async (lockPath, owner, attempts, delayMs, sta
   return false;
 };
 var withExtensionInstallLock = async (settingsRoot, destinationDirectoryName, run, options) => {
-  const lockRoot = path8.join(settingsRoot, "runtime", "extension-install-locks");
-  const lockPath = path8.join(lockRoot, "scope.lock");
+  const lockRoot = path7.join(settingsRoot, "runtime", "extension-install-locks");
+  const lockPath = path7.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)) {
@@ -4518,7 +4481,7 @@ var checkGithubUpdate = async (source, gitCommandRunner = runGitCommand) => {
 
 // dist/sdk/extension/install-snapshot.js
 import fs8 from "node:fs/promises";
-import path9 from "node:path";
+import path8 from "node:path";
 var readOptionalMetadataFile = async (filePath) => fs8.readFile(filePath).catch((error) => {
   if (isErrnoCode(error, "ENOENT"))
     return null;
@@ -4562,7 +4525,7 @@ var restoreExtensionInstallSnapshot = async (snapshot) => {
     if (contents === null) {
       await fs8.rm(filePath, { force: true });
     } else {
-      await fs8.mkdir(path9.dirname(filePath), { recursive: true });
+      await fs8.mkdir(path8.dirname(filePath), { recursive: true });
       await fs8.writeFile(filePath, contents);
     }
   }
@@ -4962,8 +4925,8 @@ var buildMissingManifestInspection = (directoryName, scope, settings, managedEnt
   };
 };
 var inspectInstalledExtensionDirectory = async (extensionsRoot, directoryName, scope, settings, managedByName, managedByDirectory) => {
-  const extensionDirectory = path10.join(extensionsRoot, directoryName);
-  const manifestPath = path10.join(extensionDirectory, "manifest.json");
+  const extensionDirectory = path9.join(extensionsRoot, directoryName);
+  const manifestPath = path9.join(extensionDirectory, "manifest.json");
   const managedDirectoryEntry = managedByDirectory.get(normalizeExtensionNameForMatch(directoryName));
   if (!await pathExists(manifestPath)) {
     return buildMissingManifestInspection(directoryName, scope, settings, managedDirectoryEntry);
@@ -5135,7 +5098,7 @@ var adoptUnmanagedExtensions = async (extensionsRoot, scope, installedExtensions
   let nextState = state;
   const adoptedEntries = [];
   for (const candidate of sortedCandidates) {
-    const extensionDirectory = path10.join(extensionsRoot, candidate.directory);
+    const extensionDirectory = path9.join(extensionsRoot, candidate.directory);
     const validated = await validateExtensionDirectory(extensionDirectory);
     const now = nowIso();
     const sourceRecord = {
@@ -5543,12 +5506,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 = path10.join(resolvedRoots.selected_root, destinationDirectoryName);
+  const destinationDirectory = path9.join(resolvedRoots.selected_root, destinationDirectoryName);
   const destinationExists = await pathExists(destinationDirectory);
   const installInPlace = await areDirectoriesEquivalent(validated.directory, destinationDirectory);
   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");
+  const backupRoot = await fs9.mkdtemp(path9.join(resolvedRoots.selected_root, ".pm-extension-install-backup-"));
+  const backupDirectory = path9.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);
@@ -5849,7 +5812,7 @@ var runExtensionAdoptAction = async (ctx) => {
       }
     });
   }
-  const extensionDirectory = path10.join(resolvedRoots.selected_root, candidate.directory);
+  const extensionDirectory = path9.join(resolvedRoots.selected_root, candidate.directory);
   const validated = await validateExtensionDirectory(extensionDirectory);
   const now = nowIso();
   const sourceRecord = buildAdoptedExtensionSource(githubOption, extensionTarget, extensionDirectory, options.ref);
@@ -5897,7 +5860,7 @@ var resolveRequiredInstalledExtension = async (ctx) => {
 var runExtensionUninstallAction = async (ctx) => {
   const { resolvedRoots, withResult } = ctx;
   const { settings, managedStateRead, candidate } = await resolveRequiredInstalledExtension(ctx);
-  const destinationDirectory = path10.join(resolvedRoots.selected_root, candidate.directory);
+  const destinationDirectory = path9.join(resolvedRoots.selected_root, candidate.directory);
   await fs9.rm(destinationDirectory, { recursive: true, force: true });
   const updatedState = {
     ...managedStateRead.state,
@@ -6389,7 +6352,7 @@ var dispatchExtensionAction = (ctx) => requiresExtensionStateLock(ctx) ? withExt
 
 // dist/sdk/init-agent-guidance.js
 import fs10 from "node:fs/promises";
-import path11 from "node:path";
+import path10 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 = [
@@ -6440,11 +6403,11 @@ function setAgentGuidanceReadlineFactoryForTests(factory) {
   createAgentGuidanceReadlineInterface = factory ?? (() => readline.createInterface({ input, output }));
 }
 function toPortableRelativePath(projectRoot, targetPath) {
-  const relative = path11.relative(projectRoot, targetPath);
+  const relative = path10.relative(projectRoot, targetPath);
   if (relative.length === 0) {
-    return path11.basename(targetPath);
+    return path10.basename(targetPath);
   }
-  return relative.split(path11.sep).join("/");
+  return relative.split(path10.sep).join("/");
 }
 function ensureTrailingNewline(value) {
   return value.endsWith("\n") ? value : `${value}
@@ -6507,14 +6470,14 @@ function upsertAgentGuidanceBlock(existingContent) {
   };
 }
 function resolveProjectRoot(pmRoot, cwd) {
-  const parent = path11.dirname(pmRoot);
-  if (path11.basename(pmRoot) === "pm" && path11.basename(parent) === ".agents") {
-    return path11.dirname(parent);
+  const parent = path10.dirname(pmRoot);
+  if (path10.basename(pmRoot) === "pm" && path10.basename(parent) === ".agents") {
+    return path10.dirname(parent);
   }
-  return path11.resolve(cwd, pmRoot);
+  return path10.resolve(cwd, pmRoot);
 }
 function resolveTargetGuidancePath(scans, projectRoot) {
-  const existingAgents = scans.find((entry) => path11.basename(entry.file_path) === "AGENTS.md" && entry.exists);
+  const existingAgents = scans.find((entry) => path10.basename(entry.file_path) === "AGENTS.md" && entry.exists);
   if (existingAgents) {
     return existingAgents.file_path;
   }
@@ -6522,7 +6485,7 @@ function resolveTargetGuidancePath(scans, projectRoot) {
   if (existingAny) {
     return existingAny.file_path;
   }
-  return path11.join(projectRoot, "AGENTS.md");
+  return path10.join(projectRoot, "AGENTS.md");
 }
 function parsePromptChoice(answer, currentDefault) {
   const normalized = answer.trim().toLowerCase();
@@ -6564,7 +6527,7 @@ function normalizeAgentGuidanceState(settings) {
 async function scanGuidanceFiles(projectRoot) {
   const scans = [];
   for (const filename of AGENT_GUIDANCE_TARGET_FILENAMES) {
-    const filePath = path11.join(projectRoot, filename);
+    const filePath = path10.join(projectRoot, filename);
     const exists = await pathExists(filePath);
     if (!exists) {
       scans.push({
@@ -6792,7 +6755,7 @@ async function runInitAgentGuidance(options) {
 
 // dist/sdk/init.js
 import fs11 from "node:fs/promises";
-import path12 from "node:path";
+import path11 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";
@@ -6896,7 +6859,7 @@ function isPathLikeInitTarget(rawValue) {
   if (trimmed.length === 0) {
     return false;
   }
-  return path12.isAbsolute(trimmed) || /^[a-z]:/iu.test(trimmed) || trimmed.startsWith(".") || trimmed.includes("/") || trimmed.includes("\\");
+  return path11.isAbsolute(trimmed) || /^[a-z]:/iu.test(trimmed) || trimmed.startsWith(".") || trimmed.includes("/") || trimmed.includes("\\");
 }
 function resolveInitInvocation(cwd, global, prefixArg, workspaceArg) {
   const normalizedWorkspace = workspaceArg?.trim();
@@ -6907,8 +6870,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 = path12.resolve(cwd, normalizedWorkspace);
-    const pmRoot2 = path12.join(workspaceRoot, ".agents", "pm");
+    const workspaceRoot = path11.resolve(cwd, normalizedWorkspace);
+    const pmRoot2 = path11.join(workspaceRoot, ".agents", "pm");
     return {
       pmRoot: pmRoot2,
       prefixArg,
@@ -6920,7 +6883,7 @@ function resolveInitInvocation(cwd, global, prefixArg, workspaceArg) {
     };
   }
   if (global.path === void 0 && isPathLikeInitTarget(prefixArg)) {
-    const positionalTarget = path12.resolve(cwd, prefixArg.trim());
+    const positionalTarget = path11.resolve(cwd, prefixArg.trim());
     return {
       pmRoot: positionalTarget,
       prefixArg: void 0,
@@ -7042,10 +7005,10 @@ async function isLikelyWorkspaceRoot(candidate) {
     "package.json",
     "pnpm-workspace.yaml",
     "AGENTS.md",
-    path12.join(".agents", "pm")
+    path11.join(".agents", "pm")
   ];
   for (const indicator of indicators) {
-    if (await pathExists(path12.join(candidate, indicator))) {
+    if (await pathExists(path11.join(candidate, indicator))) {
       return true;
     }
   }
@@ -7055,13 +7018,13 @@ async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, explicitTrack
   if (!explicitTrackerTarget || force) {
     return;
   }
-  if (await pathExists(path12.join(pmRoot, "settings.json"))) {
+  if (await pathExists(path11.join(pmRoot, "settings.json"))) {
     return;
   }
   if (!await isLikelyWorkspaceRoot(pmRoot)) {
     return;
   }
-  const nestedTracker = path12.join(pmRoot, ".agents", "pm");
+  const nestedTracker = path11.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",
@@ -7085,7 +7048,7 @@ async function ensureInitDirectories(pmRoot, subdirs) {
   const createdDirs = [];
   const warnings = [];
   for (const subdir of subdirs) {
-    const target = subdir ? path12.join(pmRoot, subdir) : pmRoot;
+    const target = subdir ? path11.join(pmRoot, subdir) : pmRoot;
     const existed = await pathExists(target);
     await fs11.mkdir(target, { recursive: true });
     if (existed) {
@@ -7320,10 +7283,10 @@ async function ensureInitTypeDirectories(params) {
   params.warnings.push(...scaffold.warnings);
 }
 function resolveInitWorkspaceRoot(target) {
-  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);
+  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);
   }
   return target.workspace_root;
 }
@@ -7380,7 +7343,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 = path12.join(pmRoot, "settings.json");
+  const settingsPath = path11.join(pmRoot, "settings.json");
   const settingsExists = await pathExists(settingsPath);
   const settingsResolution = await resolveInitSettings({
     pmRoot,
@@ -7415,7 +7378,7 @@ async function runInit(prefixArg, global, options = {}) {
   }
   await ensureInitTypeDirectories({ pmRoot, settings, createdDirs, warnings });
   if (workspaceRoot) {
-    const gitignore = await ensurePmGitignore(workspaceRoot);
+    const gitignore = await ensurePmGitignore(workspaceRoot, { pmRoot });
     if (gitignore.changed) {
       warnings.push(`updated:gitignore:${gitignore.path}`);
     }
@@ -7444,10 +7407,6 @@ async function runInit(prefixArg, global, options = {}) {
 }
 
 export {
-  PM_GITIGNORE_START,
-  PM_GITIGNORE_END,
-  getPmGitignoreBlock,
-  ensurePmGitignore,
   quoteWindowsCommandArg,
   quoteCommandArg,
   renderPmCommand,
@@ -7470,6 +7429,6 @@ export {
   _testOnly2,
   runInit
 };
-//# sourceMappingURL=chunk-MI3346YW.js.map
+//# sourceMappingURL=chunk-QANSTTC7.js.map
 
-//# debugId=36449c46-4651-5a6f-93c6-1065305d35d8
+//# debugId=17c1b721-84a1-59e2-8865-f28ad0b84cc7