@modootoday/pmcp 0.13.1 → 0.14.0

package/dist/index.js

@@ -137,8 +137,8 @@ async function openIntentCache(options) {
 }
 
 // src/catalog.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { basename as basename2, dirname as dirname2, isAbsolute, join as join2, relative } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { basename as basename2, dirname as dirname2, isAbsolute as isAbsolute2, join as join3, relative as relative2 } from "path";
 
 // src/frontmatter.ts
 import { parse } from "yaml";
@@ -260,8 +260,122 @@ function specProblems(front, directory) {
 }
 
 // src/marketplace.ts
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { basename, dirname, join, resolve } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { basename, dirname, join as join2, resolve as resolve2 } from "path";
+
+// src/marketplace/local.ts
+import { existsSync, readFileSync, realpathSync, statSync } from "fs";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function containedPath(root, path) {
+  const result = resolve(root, path);
+  const lexical = relative(resolve(root), result);
+  if (isAbsolute(lexical) || lexical === ".." || lexical.startsWith(`..${sep}`))
+    throw new Error("Path leaves the plugin root");
+  const physical = relative(realpathSync(root), realpathSync(result));
+  if (isAbsolute(physical) || physical === ".." || physical.startsWith(`..${sep}`))
+    throw new Error("Path leaves the plugin root through a symlink");
+  return result;
+}
+function pluginManifest(directory) {
+  for (const path of [
+    ".claude-plugin/plugin.json",
+    "plugin.json",
+    ".codex-plugin/plugin.json",
+    ".grok-plugin/plugin.json"
+  ]) {
+    if (!existsSync(join(directory, path))) continue;
+    const value = JSON.parse(
+      readFileSync(containedPath(directory, path), "utf8")
+    );
+    if (!object(value)) throw new Error("Plugin manifest must be an object");
+    return value;
+  }
+  return {};
+}
+function localSource(value) {
+  if (typeof value === "string") return value;
+  if (object(value) && value.source === "local" && typeof value.path === "string")
+    return value.path;
+  throw new Error(
+    "Only installed local plugin sources can be read; use the native installer for remote sources"
+  );
+}
+function readLocalMarketplace(directory, onReject) {
+  const filename = [
+    ".claude-plugin/marketplace.json",
+    ".agents/plugins/marketplace.json",
+    ".grok-plugin/marketplace.json"
+  ].find((path2) => existsSync(join(directory, path2)));
+  if (!filename) {
+    onReject?.({
+      path: directory,
+      reason: "No supported native marketplace.json found"
+    });
+    return null;
+  }
+  const path = join(directory, filename);
+  let manifest2;
+  try {
+    manifest2 = JSON.parse(
+      readFileSync(containedPath(directory, filename), "utf8")
+    );
+  } catch {
+    onReject?.({
+      path,
+      reason: "marketplace.json is not valid JSON or is outside its root"
+    });
+    return null;
+  }
+  if (!object(manifest2) || !Array.isArray(manifest2.plugins)) {
+    onReject?.({ path, reason: "marketplace.json requires a plugins array" });
+    return null;
+  }
+  const name = typeof manifest2.name === "string" ? manifest2.name : "marketplace";
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/u.test(name)) {
+    onReject?.({ path, reason: "Invalid marketplace name" });
+    return null;
+  }
+  const plugins = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of manifest2.plugins) {
+    try {
+      if (!object(item) || typeof item.name !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/u.test(item.name))
+        throw new Error("Invalid plugin name");
+      if (seen.has(item.name)) throw new Error("Duplicate plugin name");
+      const source = localSource(item.source);
+      if (!source.startsWith("./") || source.split(/[\\/]/u).includes(".."))
+        throw new Error("Local plugin source must be a contained ./ path");
+      const pluginDirectory = containedPath(directory, source);
+      if (!statSync(pluginDirectory).isDirectory())
+        throw new Error("Plugin source must be a directory");
+      const metadata2 = pluginManifest(pluginDirectory);
+      if (metadata2.name !== void 0 && metadata2.name !== item.name)
+        throw new Error("Plugin manifest name differs from marketplace entry");
+      seen.add(item.name);
+      plugins.push({
+        name: item.name,
+        directory: pluginDirectory,
+        manifest: metadata2
+      });
+    } catch (error) {
+      onReject?.({
+        path,
+        reason: error instanceof Error ? error.message : "Invalid plugin source"
+      });
+    }
+  }
+  const metadata = object(manifest2.metadata) ? manifest2.metadata : {};
+  return {
+    name,
+    plugins,
+    ...typeof metadata.tier === "string" ? { tier: metadata.tier } : {}
+  };
+}
+
+// src/marketplace.ts
 function readMetadata(source) {
   return metadataOf(frontmatterObject(source));
 }
@@ -274,16 +388,27 @@ var asList = (value) => {
   if (typeof value === "string") return [value];
   return Array.isArray(value) ? value : [];
 };
-function readJson(path) {
+function readJson(path, root) {
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = JSON.parse(
+      readFileSync2(containedPath(root, path), "utf8")
+    );
     return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 function markdownEntry(context, path, fallbackSlug, shape) {
-  const source = readFileSync(path, "utf8");
+  let source;
+  try {
+    source = readFileSync2(containedPath(context.pluginDir, path), "utf8");
+  } catch {
+    context.onReject?.({
+      path,
+      reason: "Asset is unreadable or outside the plugin root"
+    });
+    return null;
+  }
   const front = readFrontmatter(source);
   const description = front["description"] ?? "";
   if (description === "") {
@@ -315,25 +440,25 @@ function markdownEntry(context, path, fallbackSlug, shape) {
   };
 }
 function skillEntries(context) {
-  const dir = join(context.pluginDir, "skills");
-  if (!existsSync(dir)) return [];
+  const dir = join2(context.pluginDir, "skills");
+  if (!existsSync2(dir)) return [];
   const found = [];
   for (const child of readdirSync(dir, { withFileTypes: true })) {
     if (!child.isDirectory()) continue;
-    const path = join(dir, child.name, "SKILL.md");
-    if (!existsSync(path)) continue;
+    const path = join2(dir, child.name, "SKILL.md");
+    if (!existsSync2(path)) continue;
     const entry = markdownEntry(context, path, child.name, {});
     if (entry) found.push(entry);
   }
   return found;
 }
 function commandEntries(context) {
-  const dir = join(context.pluginDir, "commands");
-  if (!existsSync(dir)) return [];
+  const dir = join2(context.pluginDir, "commands");
+  if (!existsSync2(dir)) return [];
   const found = [];
   for (const child of readdirSync(dir, { withFileTypes: true })) {
     if (!child.isFile() || !child.name.endsWith(".md")) continue;
-    const path = join(dir, child.name);
+    const path = join2(dir, child.name);
     const entry = markdownEntry(context, path, basename(child.name, ".md"), {
       root: path
     });
@@ -342,22 +467,22 @@ function commandEntries(context) {
   return found;
 }
 function agentEntries(context) {
-  const dir = join(context.pluginDir, "agents");
-  if (!existsSync(dir)) return [];
+  const dir = join2(context.pluginDir, "agents");
+  if (!existsSync2(dir)) return [];
   const found = [];
   for (const child of readdirSync(dir, { withFileTypes: true })) {
     let entry = null;
     if (child.isFile() && child.name.endsWith(".md")) {
-      const path = join(dir, child.name);
+      const path = join2(dir, child.name);
       entry = markdownEntry(context, path, basename(child.name, ".md"), {
         kind: "agent",
         root: path,
         namespace: "agents"
       });
-    } else if (child.isDirectory() && existsSync(join(dir, child.name, "agent.md"))) {
+    } else if (child.isDirectory() && existsSync2(join2(dir, child.name, "agent.md"))) {
       entry = markdownEntry(
         context,
-        join(dir, child.name, "agent.md"),
+        join2(dir, child.name, "agent.md"),
         child.name,
         {
           kind: "agent",
@@ -371,9 +496,9 @@ function agentEntries(context) {
 }
 function hookEntries(context, manifest2) {
   const declared = typeof manifest2.hooks === "string" ? manifest2.hooks : void 0;
-  const path = resolve(context.pluginDir, declared ?? "hooks/hooks.json");
-  if (!existsSync(path)) return [];
-  const hooks = readJson(path);
+  const path = resolve2(context.pluginDir, declared ?? "hooks/hooks.json");
+  if (!existsSync2(path)) return [];
+  const hooks = readJson(path, context.pluginDir);
   if (hooks === null) {
     context.onReject?.({ path, reason: "hooks.json is not a JSON object" });
     return [];
@@ -399,9 +524,12 @@ function hookEntries(context, manifest2) {
   ];
 }
 function mcpEntries(context) {
-  const path = join(context.pluginDir, ".mcp.json");
-  if (!existsSync(path)) return [];
-  const config = readJson(path);
+  const filename = [".mcp.json", "mcp.json", "mcp_config.json"].find(
+    (name) => existsSync2(join2(context.pluginDir, name))
+  );
+  if (!filename) return [];
+  const path = join2(context.pluginDir, filename);
+  const config = readJson(path, context.pluginDir);
   const servers = config?.["mcpServers"];
   if (servers === null || typeof servers !== "object" || Array.isArray(servers)) {
     context.onReject?.({ path, reason: ".mcp.json has no mcpServers object" });
@@ -420,48 +548,24 @@ function mcpEntries(context) {
   }));
 }
 function readMarketplace(dir, onReject) {
-  const manifestPath = join(dir, ".claude-plugin", "marketplace.json");
-  if (!existsSync(manifestPath)) {
-    onReject?.({
-      path: dir,
-      reason: "no .claude-plugin/marketplace.json here"
-    });
-    return [];
-  }
-  let manifest2;
-  try {
-    manifest2 = JSON.parse(
-      readFileSync(manifestPath, "utf8")
-    );
-  } catch {
-    onReject?.({
-      path: manifestPath,
-      reason: "marketplace.json is not valid JSON"
-    });
-    return [];
-  }
-  const marketplace = manifest2.name ?? "marketplace";
+  const marketplace = readLocalMarketplace(dir, onReject);
+  if (!marketplace) return [];
   const found = [];
-  for (const plugin of manifest2.plugins ?? []) {
-    if (!plugin.name || !plugin.source) continue;
-    const pluginDir = resolve(dir, plugin.source);
-    if (!existsSync(pluginDir)) continue;
-    const pluginManifest = readJson(
-      join(pluginDir, ".claude-plugin", "plugin.json")
-    ) ?? {};
+  for (const plugin of marketplace.plugins) {
+    const pluginManifest2 = plugin.manifest;
     const context = {
-      marketplace,
+      marketplace: marketplace.name,
       plugin: plugin.name,
-      pluginDir,
-      pluginDescription: typeof pluginManifest.description === "string" ? pluginManifest.description : void 0,
-      tier: manifest2.metadata?.tier,
+      pluginDir: plugin.directory,
+      pluginDescription: typeof pluginManifest2.description === "string" ? pluginManifest2.description : void 0,
+      tier: marketplace.tier,
       onReject
     };
     found.push(
       ...skillEntries(context),
       ...commandEntries(context),
       ...agentEntries(context),
-      ...hookEntries(context, pluginManifest),
+      ...hookEntries(context, pluginManifest2),
       ...mcpEntries(context)
     );
   }
@@ -503,29 +607,29 @@ function skillFiles(packageDir) {
     }
     for (const entry of entries) {
       if (entry.isFile()) {
-        if (entry.name === "SKILL.md") found.push(join2(dir, entry.name));
+        if (entry.name === "SKILL.md") found.push(join3(dir, entry.name));
         continue;
       }
       if (!entry.isDirectory()) continue;
       if (SKIPPED_DIRS.has(entry.name)) continue;
       if (depth + 1 <= MAX_SKILL_DEPTH)
-        stack.push([join2(dir, entry.name), depth + 1]);
+        stack.push([join3(dir, entry.name), depth + 1]);
     }
   }
   return found.sort();
 }
 function packageDirs(root) {
-  if (!existsSync2(root)) return [];
+  if (!existsSync3(root)) return [];
   const found = [];
   for (const entry of readdirSync2(root, { withFileTypes: true })) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
     if (entry.name === ".bin" || entry.name === ".cache") continue;
-    const path = join2(root, entry.name);
+    const path = join3(root, entry.name);
     if (entry.name.startsWith("@")) {
-      if (!existsSync2(path)) continue;
+      if (!existsSync3(path)) continue;
       for (const scoped of readdirSync2(path, { withFileTypes: true })) {
         if (scoped.isDirectory() || scoped.isSymbolicLink()) {
-          found.push(join2(path, scoped.name));
+          found.push(join3(path, scoped.name));
         }
       }
       continue;
@@ -537,7 +641,7 @@ function packageDirs(root) {
 function readManifest(dir) {
   try {
     const parsed = JSON.parse(
-      readFileSync2(join2(dir, "package.json"), "utf8")
+      readFileSync3(join3(dir, "package.json"), "utf8")
     );
     return parsed !== null && typeof parsed === "object" ? parsed : null;
   } catch {
@@ -571,8 +675,8 @@ function globDirs(base, pattern) {
     }
     const segment = segments[index];
     if (!segment.includes("*")) {
-      const next = join2(dir, segment);
-      if (existsSync2(next)) walk(next, index + 1);
+      const next = join3(dir, segment);
+      if (existsSync3(next)) walk(next, index + 1);
       return;
     }
     let entries;
@@ -584,12 +688,12 @@ function globDirs(base, pattern) {
     const children = entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).filter((e) => !SKIPPED_DIRS.has(e.name));
     if (segment === "**") {
       walk(dir, index + 1);
-      for (const child of children) walk(join2(dir, child.name), index);
+      for (const child of children) walk(join3(dir, child.name), index);
       return;
     }
     const matcher = segmentMatcher(segment);
     for (const child of children) {
-      if (matcher.test(child.name)) walk(join2(dir, child.name), index + 1);
+      if (matcher.test(child.name)) walk(join3(dir, child.name), index + 1);
     }
   };
   walk(base, 0);
@@ -614,7 +718,7 @@ function workspacePackageDirs(root) {
         }
       }
     }
-    const members = [...included].filter((m) => !excluded.has(m) && existsSync2(join2(m, "package.json"))).sort();
+    const members = [...included].filter((m) => !excluded.has(m) && existsSync3(join3(m, "package.json"))).sort();
     for (const member of members) expand(member);
     ordered.push(dir);
   };
@@ -631,9 +735,9 @@ function nameOf(dir, named2) {
 }
 function expandRootGlob(dir) {
   if (!dir.includes("*")) return [dir];
-  const absolute = isAbsolute(dir);
+  const absolute = isAbsolute2(dir);
   const base = absolute ? "/" : ".";
-  return globDirs(base, dir).filter((d) => existsSync2(join2(d, "package.json"))).sort();
+  return globDirs(base, dir).filter((d) => existsSync3(join3(d, "package.json"))).sort();
 }
 function readCatalog(options) {
   const scopes = options.scopes ?? [];
@@ -657,7 +761,7 @@ function readCatalog(options) {
       seenPaths.add(path);
       let source;
       try {
-        source = readFileSync2(path, "utf8");
+        source = readFileSync3(path, "utf8");
       } catch {
         continue;
       }
@@ -701,7 +805,7 @@ function readCatalog(options) {
       }
       seen.add(entry.name);
       if (kindOf(entry) === "skill" && basename2(entry.path) === "SKILL.md") {
-        const parsed = frontmatterObject(readFileSync2(entry.path, "utf8"));
+        const parsed = frontmatterObject(readFileSync3(entry.path, "utf8"));
         for (const problem of specProblems(
           parsed,
           basename2(dirname2(entry.path))
@@ -721,7 +825,7 @@ function withoutBody({
   return rest;
 }
 function displayPath(root, entry) {
-  return relative(root, entry.path).replaceAll("\\", "/");
+  return relative2(root, entry.path).replaceAll("\\", "/");
 }
 
 // src/find.ts
@@ -811,10 +915,10 @@ function rank(matches2, limit) {
 }
 
 // src/search.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 
 // src/embed.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 
 // src/encoder.ts
 import { createHash as createHash2 } from "crypto";
@@ -1000,7 +1104,7 @@ async function loadEmbedder(modelId, options = {}) {
     const cache = options.cacheDir ?? module.env?.cacheDir;
     if (typeof cache !== "string")
       throw new Error("Provide modelPath or cacheDir for an offline encoder");
-    source = resolve2(
+    source = resolve3(
       cache,
       selected.modelId,
       selected.revision === "main" ? "." : selected.revision
@@ -1147,7 +1251,7 @@ async function prepareSearch(catalog, options) {
     reason,
     options: {}
   });
-  if (!existsSync3(options.indexPath)) return lexical("index_missing");
+  if (!existsSync4(options.indexPath)) return lexical("index_missing");
   let store;
   try {
     store = await openEntryVectors(options.indexPath, { readOnly: true });
@@ -1234,8 +1338,8 @@ function detectRuntime(server, ctx) {
 }
 
 // src/config.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
 import { parse as parse2 } from "smol-toml";
 var CONFIG_FILE = "pmcp.toml";
 function embeddingSection(path, dir, value) {
@@ -1303,8 +1407,8 @@ function embeddingSection(path, dir, value) {
     revision: string("revision"),
     encoder,
     enabled: section.enabled,
-    modelPath: modelPath === void 0 ? void 0 : resolve3(dir, modelPath),
-    cacheDir: cacheDir === void 0 ? void 0 : resolve3(dir, cacheDir)
+    modelPath: modelPath === void 0 ? void 0 : resolve4(dir, modelPath),
+    cacheDir: cacheDir === void 0 ? void 0 : resolve4(dir, cacheDir)
   };
   try {
     resolveEncoder(result.modelId, result);
@@ -1323,12 +1427,16 @@ var ConfigError = class extends Error {
   }
 };
 var PATH_KEYS = ["roots", "workspaces", "packages", "marketplaces"];
-var CATALOG_KEYS = /* @__PURE__ */ new Set([...PATH_KEYS, "scopes"]);
+var CATALOG_KEYS = /* @__PURE__ */ new Set([
+  ...PATH_KEYS,
+  "scopes",
+  "builtin"
+]);
 function findConfig(start) {
-  let dir = resolve3(start);
+  let dir = resolve4(start);
   for (; ; ) {
-    const candidate = join3(dir, CONFIG_FILE);
-    if (existsSync4(candidate)) return candidate;
+    const candidate = join4(dir, CONFIG_FILE);
+    if (existsSync5(candidate)) return candidate;
     const parent = dirname3(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -1341,11 +1449,11 @@ function stringList(path, key, value) {
   return value;
 }
 function readConfig(path) {
-  const absolute = resolve3(path);
+  const absolute = resolve4(path);
   const dir = dirname3(absolute);
   let raw;
   try {
-    raw = parse2(readFileSync3(absolute, "utf8"));
+    raw = parse2(readFileSync4(absolute, "utf8"));
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unreadable";
     throw new ConfigError(absolute, reason.split("\n")[0] ?? reason);
@@ -1363,10 +1471,22 @@ function readConfig(path) {
     if (!CATALOG_KEYS.has(key)) {
       throw new ConfigError(absolute, `unknown key [catalog] ${key}`);
     }
+    if (key === "builtin") {
+      if (typeof value !== "boolean")
+        throw new ConfigError(absolute, "[catalog] builtin must be a boolean");
+      catalog[key] = value;
+      continue;
+    }
     const list2 = stringList(absolute, key, value);
-    catalog[key] = key === "scopes" ? list2 : list2.map((p) => resolve3(dir, p));
+    catalog[key] = key === "scopes" ? list2 : list2.map((p) => resolve4(dir, p));
   }
-  return { path: absolute, dir, catalog, raw, ...configured };
+  return {
+    path: absolute,
+    dir,
+    catalog,
+    raw,
+    ...configured
+  };
 }
 
 // src/project/mcp-spec.ts
@@ -1390,7 +1510,7 @@ var KEYS = /* @__PURE__ */ new Set([
 function fail(path, where, detail) {
   throw new ConfigError(path, `${where} ${detail}`);
 }
-function object(path, where, value) {
+function object2(path, where, value) {
   if (value === void 0) {
     return {};
   }
@@ -1413,7 +1533,7 @@ function list(path, where, value, unique = true) {
 }
 function mapping(path, where, value) {
   const result = {};
-  for (const [key, item] of Object.entries(object(path, where, value))) {
+  for (const [key, item] of Object.entries(object2(path, where, value))) {
     if (typeof item !== "string") {
       fail(path, where, "values must be strings");
     }
@@ -1431,14 +1551,14 @@ function nativeOptions(path, where, value) {
   };
   const result = {};
   for (const [tool, raw] of Object.entries(
-    object(path, `${where} native`, value)
+    object2(path, `${where} native`, value)
   )) {
     if (!TOOLS.includes(tool)) {
       fail(path, where, `unknown native target ${tool}`);
     }
     const values = {};
     for (const [key, item] of Object.entries(
-      object(path, `${where} native.${tool}`, raw)
+      object2(path, `${where} native.${tool}`, raw)
     )) {
       if (!fields[tool].includes(key) || typeof item !== "number" || !Number.isFinite(item) || item <= 0) {
         fail(path, where, `unsupported native option ${tool}.${key}`);
@@ -1452,12 +1572,12 @@ function nativeOptions(path, where, value) {
 function environmentSources(path, where, value) {
   const result = {};
   for (const [key, raw] of Object.entries(
-    object(path, `${where} env_from`, value)
+    object2(path, `${where} env_from`, value)
   )) {
     if (!ENV_NAME.test(key) || key === "PROJECT_ROOT") {
       fail(path, where, "invalid environment source name");
     }
-    const source = object(path, `${where} env_from.${key}`, raw);
+    const source = object2(path, `${where} env_from.${key}`, raw);
     if (Object.keys(source).some((name) => name !== "file" && name !== "pointer")) {
       fail(path, where, "environment sources accept only file and pointer");
     }
@@ -1470,12 +1590,12 @@ function environmentSources(path, where, value) {
 }
 function readMcp(path, value) {
   const servers = {};
-  for (const [alias, raw] of Object.entries(object(path, "[mcp]", value))) {
+  for (const [alias, raw] of Object.entries(object2(path, "[mcp]", value))) {
     const where = `[mcp.${alias}]`;
     if (!/^[a-z0-9][a-z0-9-]*$/u.test(alias)) {
       fail(path, where, "use lowercase, digits and -");
     }
-    const entry = object(path, where, raw);
+    const entry = object2(path, where, raw);
     for (const key of Object.keys(entry)) {
       if (!KEYS.has(key)) {
         fail(path, where, `unknown field ${key}`);
@@ -1606,8 +1726,8 @@ function readMcp(path, value) {
 // src/project/hook-adapter.ts
 import { spawnSync } from "child_process";
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync4, realpathSync, statSync } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync2 } from "fs";
+import { dirname as dirname4, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve5 } from "path";
 var denied = () => ({
   decision: "deny",
   reason: "Shell guard failed validation or execution"
@@ -1617,22 +1737,22 @@ function guardPath(root, command) {
   if (!script?.startsWith(".agents/guards/")) {
     throw new Error("Hook command must execute a script under .agents/guards/");
   }
-  const absolute = resolve4(root, script);
-  const base = resolve4(root, ".agents/guards");
-  const inside = relative2(base, absolute);
-  if (isAbsolute2(inside) || inside === ".." || inside.startsWith("../") || inside.startsWith("..\\")) {
+  const absolute = resolve5(root, script);
+  const base = resolve5(root, ".agents/guards");
+  const inside = relative3(base, absolute);
+  if (isAbsolute3(inside) || inside === ".." || inside.startsWith("../") || inside.startsWith("..\\")) {
     throw new Error("Hook guard must stay under .agents/guards/");
   }
-  if (!existsSync5(absolute) || !statSync(absolute).isFile()) {
+  if (!existsSync6(absolute) || !statSync2(absolute).isFile()) {
     throw new Error("Hook guard script must exist");
   }
-  const actual = relative2(base, realpathSync(absolute));
-  if (isAbsolute2(actual) || actual === ".." || actual.startsWith("../") || actual.startsWith("..\\")) {
+  const actual = relative3(base, realpathSync2(absolute));
+  if (isAbsolute3(actual) || actual === ".." || actual.startsWith("../") || actual.startsWith("..\\")) {
     throw new Error("Hook guard cannot resolve outside .agents/guards/");
   }
   return absolute;
 }
-function object2(value) {
+function object3(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return {};
   }
@@ -1656,9 +1776,9 @@ function scalar(value) {
 }
 function evaluateShellHook(root, policy, tool, payload) {
   try {
-    const value = object2(payload);
-    const call = object2(value["toolCall"]);
-    const input = tool === "antigravity" ? object2(call["args"]) : object2(value["tool_input"]);
+    const value = object3(payload);
+    const call = object3(value["toolCall"]);
+    const input = tool === "antigravity" ? object3(call["args"]) : object3(value["tool_input"]);
     const name = tool === "antigravity" ? call["name"] : value["tool_name"];
     const shellNames = {
       codex: ["Bash", "exec_command", "shell", "shell_command"],
@@ -1706,7 +1826,7 @@ function evaluateShellHook(root, policy, tool, payload) {
     if (result.status !== 0 || result.error) {
       return denied();
     }
-    const response = object2(JSON.parse(result.stdout));
+    const response = object3(JSON.parse(result.stdout));
     if (Object.keys(response).some(
       (key) => !["decision", "reason"].includes(key)
     ) || !["allow", "deny"].includes(String(response["decision"])) || response["reason"] !== void 0 && typeof response["reason"] !== "string") {
@@ -1744,8 +1864,8 @@ async function main() {
     if (!file) {
       throw new Error("Missing hook policy");
     }
-    const bytes = readFileSync4(file);
-    const adapter = readFileSync4(process.argv[1]);
+    const bytes = readFileSync5(file);
+    const adapter = readFileSync5(process.argv[1]);
     const actual = createHash3("sha256").update(adapter).update(bytes).digest("hex");
     if (actual !== integrity) {
       throw new Error("Hook integrity mismatch");
@@ -1764,8 +1884,8 @@ async function main() {
       }
       chunks.push(bytes2);
     }
-    const root = resolve4(dirname4(file), "../..");
-    const guardSha256 = createHash3("sha256").update(readFileSync4(guardPath(root, policy.command))).digest("hex");
+    const root = resolve5(dirname4(file), "../..");
+    const guardSha256 = createHash3("sha256").update(readFileSync5(guardPath(root, policy.command))).digest("hex");
     if (policy.contractVersion !== 1 || guardSha256 !== policy.guardSha256) {
       throw new Error(
         "Hook guard source changed; reproject and review native trust"
@@ -1958,8 +2078,8 @@ function readSpec(config) {
 }
 
 // src/project/plan.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "fs";
+import { join as join7 } from "path";
 
 // src/project/frontmatter.ts
 import { parse as parse3 } from "yaml";
@@ -1967,8 +2087,8 @@ function splitFrontmatter(source) {
   const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/u.exec(source);
   if (!match) return { meta: {}, body: source };
   const meta = parse3(match[1] ?? "");
-  const object4 = meta !== null && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
-  return { meta: object4, body: match[2] ?? "" };
+  const object5 = meta !== null && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
+  return { meta: object5, body: match[2] ?? "" };
 }
 function scalar2(value) {
   if (typeof value === "string") return value;
@@ -2011,8 +2131,8 @@ function splitKeyed(path) {
 
 // src/project/package-rules.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync6, lstatSync, readdirSync as readdirSync3, readlinkSync } from "fs";
-import { dirname as dirname5, join as join4, posix } from "path";
+import { existsSync as existsSync7, lstatSync, readdirSync as readdirSync3, readlinkSync } from "fs";
+import { dirname as dirname5, join as join5, posix } from "path";
 var ProjectError = class extends Error {
   constructor(message) {
     super(message);
@@ -2057,11 +2177,11 @@ function linkTarget(abs) {
 }
 function legacyLinks(root) {
   const found = /* @__PURE__ */ new Map();
-  const dir = join4(root, RULES_DIR);
-  if (!existsSync6(dir)) return found;
+  const dir = join5(root, RULES_DIR);
+  if (!existsSync7(dir)) return found;
   for (const entry of readdirSync3(dir).sort()) {
     if (!entry.endsWith(".md")) continue;
-    const target = linkTarget(join4(dir, entry));
+    const target = linkTarget(join5(dir, entry));
     if (target === null || !target.startsWith("../../")) continue;
     found.set(entry.slice(0, -3), target.slice("../../".length));
   }
@@ -2106,7 +2226,7 @@ function packageRuleOutputs(root, spec, owned) {
 }
 
 // src/project/mcp.ts
-import { isAbsolute as isAbsolute3, relative as relative3 } from "path";
+import { isAbsolute as isAbsolute4, relative as relative4 } from "path";
 var runtimeByTool = {
   claude: "claude-code",
   codex: "codex-cli",
@@ -2257,12 +2377,12 @@ function nativeEntry(spec, alias, server, tool) {
     }
     let started;
     if (Object.keys(server.envFrom ?? {}).length > 0) {
-      const entry = relative3(spec.root, process.argv[1] ?? "");
+      const entry = relative4(spec.root, process.argv[1] ?? "");
       const driverEnv = {};
       if (server.mailbox) {
         driverEnv["PMCP_MAILBOX_RUNTIME"] = runtimeByTool[tool];
       }
-      if (!isAbsolute3(entry) && !entry.startsWith("..")) {
+      if (!isAbsolute4(entry) && !entry.startsWith("..")) {
         started = launch({
           command: "node",
           args: [`${ROOT_VAR}/${entry}`, "project", "exec-mcp", alias],
@@ -2371,8 +2491,8 @@ function mcpOutputs(spec) {
 
 // src/project/hooks.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
 import { fileURLToPath } from "url";
 var HOOK_DIRECTORY = ".agents/pmcp-hooks";
 var ADAPTER = `${HOOK_DIRECTORY}/adapter.mjs`;
@@ -2393,7 +2513,7 @@ var native = {
     matcher: "run_command"
   }
 };
-function object3(value) {
+function object4(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new ProjectError(
       "Native hook configuration must be an object; contents are redacted"
@@ -2402,20 +2522,20 @@ function object3(value) {
   return value;
 }
 function groups(root, file, key) {
-  const absolute = join5(root, file);
-  if (!existsSync7(absolute)) {
+  const absolute = join6(root, file);
+  if (!existsSync8(absolute)) {
     return [];
   }
   let value;
   try {
-    value = JSON.parse(readFileSync5(absolute, "utf8"));
+    value = JSON.parse(readFileSync6(absolute, "utf8"));
   } catch {
     throw new ProjectError(
       "Cannot parse native hook configuration; contents are redacted"
     );
   }
   for (const part of key) {
-    value = object3(value)[part];
+    value = object4(value)[part];
     if (value === void 0) {
       return [];
     }
@@ -2432,15 +2552,15 @@ function adapterSource() {
   const sourceBuild = fileURLToPath(
     new URL("../../dist/project/hook-adapter.js", import.meta.url)
   );
-  const file = existsSync7(published) ? published : sourceBuild;
-  if (!existsSync7(file)) {
+  const file = existsSync8(published) ? published : sourceBuild;
+  if (!existsSync8(file)) {
     throw new ProjectError("Build pmcp before projecting shell hook adapters");
   }
-  return readFileSync5(file, "utf8");
+  return readFileSync6(file, "utf8");
 }
 function hookOutputs(spec) {
-  const lockFile = join5(spec.root, "pmcp.lock");
-  const lock = existsSync7(lockFile) ? JSON.parse(readFileSync5(lockFile, "utf8")) : {};
+  const lockFile = join6(spec.root, "pmcp.lock");
+  const lock = existsSync8(lockFile) ? JSON.parse(readFileSync6(lockFile, "utf8")) : {};
   const previous = new Map(
     (lock.outputs ?? []).filter((entry) => entry.managed !== void 0).map((entry) => [entry.path, entry.managed])
   );
@@ -2457,7 +2577,7 @@ function hookOutputs(spec) {
     outputs.push({ kind: "file", path: ADAPTER, content: adapter });
     for (const hook of selected) {
       const policyFile = `${HOOK_DIRECTORY}/${hook.name}.json`;
-      const guardSha256 = createHash4("sha256").update(readFileSync5(guardPath(spec.root, hook.command))).digest("hex");
+      const guardSha256 = createHash4("sha256").update(readFileSync6(guardPath(spec.root, hook.command))).digest("hex");
       const policy = `${JSON.stringify({ ...hook, contractVersion: 1, guardSha256 }, null, 2)}
 `;
       outputs.push({ kind: "file", path: policyFile, content: policy });
@@ -2527,20 +2647,20 @@ var AGENT_FIELDS = {
 };
 var SETTINGS = ".claude/settings.json";
 function listDirs(dir) {
-  if (!existsSync8(dir)) return [];
+  if (!existsSync9(dir)) return [];
   return readdirSync4(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
 }
 var tomlString = (value) => JSON.stringify(typeof value === "string" ? value : String(value ?? ""));
 function skillNames(root) {
-  const dir = join6(root, ".agents/skills");
+  const dir = join7(root, ".agents/skills");
   return listDirs(dir).filter(
-    (name) => existsSync8(join6(dir, name, "SKILL.md"))
+    (name) => existsSync9(join7(dir, name, "SKILL.md"))
   );
 }
 function agentNames(root) {
-  const dir = join6(root, ".agents/agents");
+  const dir = join7(root, ".agents/agents");
   return listDirs(dir).filter(
-    (name) => existsSync8(join6(dir, name, "agent.md"))
+    (name) => existsSync9(join7(dir, name, "agent.md"))
   );
 }
 function skillOutputs(spec) {
@@ -2574,13 +2694,13 @@ policy:
 }
 function ruleOutputs(spec) {
   if (!spec.tools.has("claude")) return [];
-  const dir = join6(spec.root, ".agents/rules");
-  if (!existsSync8(dir)) return [];
+  const dir = join7(spec.root, ".agents/rules");
+  if (!existsSync9(dir)) return [];
   const outputs = [];
   for (const file of readdirSync4(dir).filter((f) => f.endsWith(".md")).sort()) {
     const rel = `.agents/rules/${file}`;
     const { meta, body } = splitFrontmatter(
-      readFileSync6(join6(spec.root, rel), "utf8")
+      readFileSync7(join7(spec.root, rel), "utf8")
     );
     const globs = [meta["globs"] ?? []].flat().filter((g) => typeof g === "string" && g !== "");
     const head = globs.length > 0 ? renderFrontmatter({ paths: globs }) : "";
@@ -2599,7 +2719,7 @@ function agentOutputs(spec) {
   for (const name of agentNames(spec.root)) {
     const rel = `.agents/agents/${name}/agent.md`;
     const { meta, body } = splitFrontmatter(
-      readFileSync6(join6(spec.root, rel), "utf8")
+      readFileSync7(join7(spec.root, rel), "utf8")
     );
     const overrides = spec.agents[name] ?? {};
     const note = `<!-- ${MARK} from ${rel} -->
@@ -2671,35 +2791,35 @@ function censusDirs(spec) {
 // src/project/apply.ts
 import { createHash as createHash6 } from "crypto";
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync5,
   readlinkSync as readlinkSync2,
   rmSync,
   symlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname7, join as join8, posix as posix2 } from "path";
+import { dirname as dirname7, join as join9, posix as posix2 } from "path";
 import { parse as parse4 } from "smol-toml";
 
 // src/project/backup.ts
 import { createHash as createHash5 } from "crypto";
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   lstatSync as lstatSync2,
   mkdirSync,
   mkdtempSync,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   writeFileSync
 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join7, relative as relative4, resolve as resolve5 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute5, join as join8, relative as relative5, resolve as resolve6 } from "path";
 function backupFiles(root, paths) {
-  const base = join7(homedir(), ".cache/pmcp/project-backups");
-  const inside = relative4(resolve5(root), resolve5(base));
-  if (!isAbsolute4(inside) && inside !== ".." && !inside.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
+  const base = join8(homedir(), ".cache/pmcp/project-backups");
+  const inside = relative5(resolve6(root), resolve6(base));
+  if (!isAbsolute5(inside) && inside !== ".." && !inside.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
     throw new ProjectError("Project backups must be outside the project");
   }
   mkdirSync(base, { recursive: true, mode: 448 });
@@ -2713,12 +2833,12 @@ function backupFiles(root, paths) {
     );
   }
   const snapshots = [...new Set(paths)].map((path) => {
-    const absolute = resolve5(root, path);
-    const within = relative4(resolve5(root), absolute);
-    if (isAbsolute4(within) || within === ".." || within.startsWith("../") || within.startsWith("..\\")) {
+    const absolute = resolve6(root, path);
+    const within = relative5(resolve6(root), absolute);
+    if (isAbsolute5(within) || within === ".." || within.startsWith("../") || within.startsWith("..\\")) {
       throw new ProjectError("Backup paths must stay inside the project");
     }
-    if (!existsSync9(absolute)) {
+    if (!existsSync10(absolute)) {
       return { path, contents: null };
     }
     const stat = lstatSync2(absolute);
@@ -2727,14 +2847,14 @@ function backupFiles(root, paths) {
         `Refusing to back up a nonregular config file: ${path}`
       );
     }
-    return { path, contents: readFileSync7(absolute) };
+    return { path, contents: readFileSync8(absolute) };
   });
-  const destination = mkdtempSync(join7(base, "project-"));
+  const destination = mkdtempSync(join8(base, "project-"));
   const entries = snapshots.map(({ path, contents }) => {
     if (contents === null) {
       return { path, present: false };
     }
-    const output = join7(destination, "files", path);
+    const output = join8(destination, "files", path);
     mkdirSync(dirname6(output), { recursive: true, mode: 448 });
     writeFileSync(output, contents, { mode: 384 });
     return {
@@ -2744,11 +2864,11 @@ function backupFiles(root, paths) {
     };
   });
   writeFileSync(
-    join7(destination, "receipt.json"),
+    join8(destination, "receipt.json"),
     JSON.stringify(
       {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        projectRoot: resolve5(root),
+        projectRoot: resolve6(root),
         entries
       },
       null,
@@ -2769,9 +2889,9 @@ var PREDECESSORS = [
 ];
 var sha = (text) => createHash6("sha256").update(text).digest("hex");
 function readLock(root) {
-  const path = join8(root, LOCK_FILE);
-  if (!existsSync10(path)) return [];
-  const lock = JSON.parse(readFileSync8(path, "utf8"));
+  const path = join9(root, LOCK_FILE);
+  if (!existsSync11(path)) return [];
+  const lock = JSON.parse(readFileSync9(path, "utf8"));
   return lock.outputs ?? [];
 }
 function linkOf(abs) {
@@ -2781,12 +2901,12 @@ function linkOf(abs) {
     return null;
   }
 }
-var exists = (abs) => existsSync10(abs) || linkOf(abs) !== null;
+var exists = (abs) => existsSync11(abs) || linkOf(abs) !== null;
 function readJson2(abs) {
-  if (!existsSync10(abs)) return {};
+  if (!existsSync11(abs)) return {};
   let value;
   try {
-    value = JSON.parse(readFileSync8(abs, "utf8"));
+    value = JSON.parse(readFileSync9(abs, "utf8"));
   } catch {
     throw new ProjectError(
       "Cannot parse native JSON configuration; contents are redacted"
@@ -2794,16 +2914,16 @@ function readJson2(abs) {
   }
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function getKey(object4, key) {
-  let node = object4;
+function getKey(object5, key) {
+  let node = object5;
   for (const part of key) {
     if (node === null || typeof node !== "object") return void 0;
     node = node[part];
   }
   return node;
 }
-function setKey(object4, key, value) {
-  let node = object4;
+function setKey(object5, key, value) {
+  let node = object5;
   for (const part of key.slice(0, -1)) {
     const next = node[part];
     if (next === null || typeof next !== "object" || Array.isArray(next)) {
@@ -2813,17 +2933,17 @@ function setKey(object4, key, value) {
   }
   node[key[key.length - 1] ?? ""] = value;
 }
-function deleteKey(object4, key) {
+function deleteKey(object5, key) {
   const [head, ...rest] = key;
-  if (head === void 0 || !(head in object4)) return;
+  if (head === void 0 || !(head in object5)) return;
   if (rest.length === 0) {
-    delete object4[head];
+    delete object5[head];
     return;
   }
-  const child = object4[head];
+  const child = object5[head];
   if (child === null || typeof child !== "object") return;
   deleteKey(child, rest);
-  if (Object.keys(child).length === 0) delete object4[head];
+  if (Object.keys(child).length === 0) delete object5[head];
 }
 var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 var block = (content) => `${BEGIN}
@@ -2838,19 +2958,19 @@ function withoutBlock(text) {
   return `${text.slice(0, start).replace(/\n+$/u, "\n")}${after}`;
 }
 function present(root, output) {
-  const abs = join8(root, "file" in output ? output.file : output.path);
+  const abs = join9(root, "file" in output ? output.file : output.path);
   switch (output.kind) {
     case "link":
       return linkOf(abs) === output.target;
     case "file":
-      return existsSync10(abs) && linkOf(abs) === null && readFileSync8(abs, "utf8") === output.content;
+      return existsSync11(abs) && linkOf(abs) === null && readFileSync9(abs, "utf8") === output.content;
     case "json":
       if (output.managed && Array.isArray(output.value) && output.value.length === 0) {
         return getKey(readJson2(abs), output.key) === void 0;
       }
       return same(getKey(readJson2(abs), output.key), output.value);
     case "block":
-      return existsSync10(abs) && readFileSync8(abs, "utf8").includes(block(output.content));
+      return existsSync11(abs) && readFileSync9(abs, "utf8").includes(block(output.content));
   }
 }
 function replaceable(root, output, owned) {
@@ -2858,12 +2978,12 @@ function replaceable(root, output, owned) {
     if (output.key[0] !== "mcpServers" || owned.has(output.path)) {
       return true;
     }
-    const existing = getKey(readJson2(join8(root, output.file)), output.key);
+    const existing = getKey(readJson2(join9(root, output.file)), output.key);
     return existing === void 0 || same(existing, output.value);
   }
   if (output.kind === "block") {
-    const absolute = join8(root, output.file);
-    const text2 = existsSync10(absolute) ? readFileSync8(absolute, "utf8") : "";
+    const absolute = join9(root, output.file);
+    const text2 = existsSync11(absolute) ? readFileSync9(absolute, "utf8") : "";
     const outside = parse4(withoutBlock(text2));
     const proposed = parse4(output.content);
     const existing = objectKeys(outside["mcp_servers"]);
@@ -2872,14 +2992,14 @@ function replaceable(root, output, owned) {
     );
   }
   if (owned.has(output.path)) return true;
-  const abs = join8(root, output.path);
+  const abs = join9(root, output.path);
   if (!exists(abs)) return true;
   const target = linkOf(abs);
   if (target !== null) {
     return output.kind === "link" && target === output.target;
   }
   if (lstatSync3(abs).isDirectory()) return false;
-  const text = readFileSync8(abs, "utf8");
+  const text = readFileSync9(abs, "utf8");
   if (output.kind === "file" && text === output.content) return true;
   return PREDECESSORS.some((mark) => text.includes(mark));
 }
@@ -2893,15 +3013,15 @@ function undeclared(spec, outputs) {
   const declared = new Set(outputs.map((o) => o.path));
   const found = [];
   for (const dir of censusDirs(spec)) {
-    const abs = join8(spec.root, dir);
-    if (!existsSync10(abs)) continue;
+    const abs = join9(spec.root, dir);
+    if (!existsSync11(abs)) continue;
     for (const entry of readdirSync5(abs)) {
       const path = `${dir}/${entry}`;
       if (!declared.has(path)) found.push(path);
     }
   }
-  const rules = join8(spec.root, RULES_DIR);
-  if (spec.tools.has("grok") && existsSync10(rules)) {
+  const rules = join9(spec.root, RULES_DIR);
+  if (spec.tools.has("grok") && existsSync11(rules)) {
     for (const entry of readdirSync5(rules, { withFileTypes: true })) {
       if (entry.isDirectory()) continue;
       found.push(`${RULES_DIR}/${entry.name}`);
@@ -2928,9 +3048,9 @@ function deadGlobs(root, outputs) {
     if (rule.kind === "file") {
       text = rule.content;
     } else if (rule.kind === "link") {
-      const abs = join8(root, posix2.join(posix2.dirname(rule.path), rule.target));
-      if (!existsSync10(abs)) continue;
-      text = readFileSync8(abs, "utf8");
+      const abs = join9(root, posix2.join(posix2.dirname(rule.path), rule.target));
+      if (!existsSync11(abs)) continue;
+      text = readFileSync9(abs, "utf8");
     } else {
       continue;
     }
@@ -2980,7 +3100,7 @@ function project(spec, options) {
     }
   }
   for (const path of jsonPaths) {
-    readJson2(join8(spec.root, path));
+    readJson2(join9(spec.root, path));
   }
   if (options.check) {
     const problems = [
@@ -3042,7 +3162,7 @@ function project(spec, options) {
   for (const output of outputs) {
     if (output.kind !== "link" && output.kind !== "file") continue;
     if (present(spec.root, output)) continue;
-    const abs = join8(spec.root, output.path);
+    const abs = join9(spec.root, output.path);
     mkdirSync2(dirname7(abs), { recursive: true });
     rmSync(abs, { force: true, recursive: true });
     if (output.kind === "link") symlinkSync(output.target, abs);
@@ -3068,12 +3188,12 @@ function project(spec, options) {
       group.drops.push(keyed.key);
       jsonFiles.set(keyed.file, group);
     } else {
-      rmSync(join8(spec.root, entry.path), { force: true, recursive: true });
+      rmSync(join9(spec.root, entry.path), { force: true, recursive: true });
     }
     pruned += 1;
   }
   for (const [file, { sets, drops }] of jsonFiles) {
-    const abs = join8(spec.root, file);
+    const abs = join9(spec.root, file);
     const before = readJson2(abs);
     const after = structuredClone(before);
     for (const key of drops) deleteKey(after, key);
@@ -3088,18 +3208,18 @@ function project(spec, options) {
       }
     }
     if (same(before, after)) continue;
-    if (!existsSync10(abs) && Object.keys(after).length === 0) continue;
+    if (!existsSync11(abs) && Object.keys(after).length === 0) continue;
     mkdirSync2(dirname7(abs), { recursive: true });
     writeFileSync2(abs, `${JSON.stringify(after, null, 2)}
 `);
   }
   for (const [file, content] of blockFiles) {
-    const abs = join8(spec.root, file);
-    const before = existsSync10(abs) ? readFileSync8(abs, "utf8") : "";
+    const abs = join9(spec.root, file);
+    const before = existsSync11(abs) ? readFileSync9(abs, "utf8") : "";
     let after = withoutBlock(before);
     if (content !== null) {
-      const sep4 = after === "" || after.endsWith("\n\n") ? "" : after.endsWith("\n") ? "\n" : "\n\n";
-      after = `${after}${sep4}${block(content)}`;
+      const sep5 = after === "" || after.endsWith("\n\n") ? "" : after.endsWith("\n") ? "\n" : "\n\n";
+      after = `${after}${sep5}${block(content)}`;
     }
     if (after === before) continue;
     mkdirSync2(dirname7(abs), { recursive: true });
@@ -3114,15 +3234,15 @@ function project(spec, options) {
       )
     );
     for (const [name, target] of legacyLinks(spec.root)) {
-      const abs = join8(spec.root, RULES_DIR, `${name}.md`);
-      const broken = !existsSync10(abs);
+      const abs = join9(spec.root, RULES_DIR, `${name}.md`);
+      const broken = !existsSync11(abs);
       if (!broken && !linkedDirs.has(posix2.dirname(target))) continue;
       rmSync(abs, { force: true });
       pruned += 1;
     }
   }
   writeFileSync2(
-    join8(spec.root, LOCK_FILE),
+    join9(spec.root, LOCK_FILE),
     `${JSON.stringify({ version: 1, outputs: outputs.filter((output) => output.kind !== "json" || output.managed === void 0 || output.managed.length > 0).map(lockEntry) }, null, 2)}
 `
   );
@@ -3137,8 +3257,8 @@ function project(spec, options) {
 
 // src/project/doctor.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { join as join10 } from "path";
 import { parse as parse5 } from "smol-toml";
 var missingFrom = (names, present2) => names.filter((name) => !present2(name));
 function verdict(tool, check, missing) {
@@ -3200,10 +3320,10 @@ function claude(spec, o) {
 }
 function codex(spec, o) {
   const findings = [];
-  const config = join9(o.home, ".codex/config.toml");
+  const config = join10(o.home, ".codex/config.toml");
   let trusted = false;
-  if (existsSync11(config)) {
-    const projects = parse5(readFileSync9(config, "utf8")).projects ?? {};
+  if (existsSync12(config)) {
+    const projects = parse5(readFileSync10(config, "utf8")).projects ?? {};
     const root = spec.root.replace(/\/$/u, "");
     trusted = projects[root]?.trust_level === "trusted" || projects[`${root}/`]?.trust_level === "trusted";
   }
@@ -3329,8 +3449,8 @@ function grok(spec, o) {
 }
 function antigravity(spec, options) {
   const foreign = agentNames(spec.root).filter((name) => {
-    const text = readFileSync9(
-      join9(spec.root, ".agents/agents", name, "agent.md"),
+    const text = readFileSync10(
+      join10(spec.root, ".agents/agents", name, "agent.md"),
       "utf8"
     );
     return splitFrontmatter(text).meta["tools"] !== void 0;
@@ -3350,7 +3470,7 @@ function antigravity(spec, options) {
   if (serversForTool(spec, "antigravity").length > 0) {
     const result = options.run(
       "agy",
-      ["plugin", "validate", join9(spec.root, ANTIGRAVITY_MCP_PLUGIN)],
+      ["plugin", "validate", join10(spec.root, ANTIGRAVITY_MCP_PLUGIN)],
       spec.root
     );
     findings.push(
@@ -3381,11 +3501,11 @@ function doctor(spec, options) {
 }
 
 // src/server.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 
 // src/files/bundle.ts
-import { readFileSync as readFileSync11, statSync as statSync3 } from "fs";
-import { dirname as dirname8, join as join11 } from "path";
+import { readFileSync as readFileSync12, statSync as statSync4 } from "fs";
+import { dirname as dirname8, join as join12 } from "path";
 
 // src/mime.ts
 var TYPES = {
@@ -3492,8 +3612,8 @@ function classify(path, bytes) {
 
 // src/files/list.ts
 import { createHash as createHash7 } from "crypto";
-import { readFileSync as readFileSync10, readdirSync as readdirSync6, statSync as statSync2 } from "fs";
-import { basename as basename4, join as join10, relative as relative5, sep } from "path";
+import { readFileSync as readFileSync11, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
+import { basename as basename4, join as join11, relative as relative6, sep as sep2 } from "path";
 
 // src/files/redact.ts
 import { basename as basename3 } from "path";
@@ -3530,11 +3650,11 @@ function servedBytes(path, raw) {
 var FILE_LIST_LIMIT = 200;
 var sha256 = (bytes) => createHash7("sha256").update(bytes).digest("hex");
 function describe(path, full) {
-  const bytes = servedBytes(full, readFileSync10(full));
+  const bytes = servedBytes(full, readFileSync11(full));
   return { path, bytes: bytes.length, sha256: sha256(bytes) };
 }
 function listSkillFiles(root, limit = FILE_LIST_LIMIT) {
-  if (statSync2(root).isFile()) {
+  if (statSync3(root).isFile()) {
     return { files: [describe(basename4(root), root)], truncated: false };
   }
   const files = [];
@@ -3543,14 +3663,14 @@ function listSkillFiles(root, limit = FILE_LIST_LIMIT) {
     const dir = stack.pop();
     for (const entry of readdirSync6(dir, { withFileTypes: true })) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join10(dir, entry.name);
+      const full = join11(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(full);
         continue;
       }
       if (!entry.isFile()) continue;
       if (files.length >= limit) return { files, truncated: true };
-      files.push(describe(relative5(root, full).split(sep).join("/"), full));
+      files.push(describe(relative6(root, full).split(sep2).join("/"), full));
     }
   }
   files.sort((a, b) => a.path.localeCompare(b.path));
@@ -3577,7 +3697,7 @@ function resolveSkillFileUri(uri, entries) {
 // src/files/bundle.ts
 function bundleSkill(entry) {
   const root = assetRoot(entry);
-  const base = statSync3(root).isFile() ? dirname8(root) : root;
+  const base = statSync4(root).isFile() ? dirname8(root) : root;
   const listing2 = listSkillFiles(root);
   return {
     name: entry.name,
@@ -3585,40 +3705,40 @@ function bundleSkill(entry) {
     files: listing2.files.map((file) => ({
       ...file,
       uri: skillFileUri(entry, file.path),
-      mimeType: classify(file.path, readFileSync11(join11(base, file.path))).mimeType
+      mimeType: classify(file.path, readFileSync12(join12(base, file.path))).mimeType
     }))
   };
 }
 
 // src/files/read.ts
-import { readFileSync as readFileSync12, statSync as statSync5 } from "fs";
+import { readFileSync as readFileSync13, statSync as statSync6 } from "fs";
 
 // src/files/resolve.ts
-import { realpathSync as realpathSync2, statSync as statSync4 } from "fs";
-import { dirname as dirname9, isAbsolute as isAbsolute5, relative as relative6, resolve as resolve6, sep as sep2 } from "path";
-var ownFile = (entry) => relative6(assetRoot(entry), entry.path).split(sep2).join("/");
+import { realpathSync as realpathSync3, statSync as statSync5 } from "fs";
+import { dirname as dirname9, isAbsolute as isAbsolute6, relative as relative7, resolve as resolve7, sep as sep3 } from "path";
+var ownFile = (entry) => relative7(assetRoot(entry), entry.path).split(sep3).join("/");
 function resolveSkillFile(entry, wanted = ownFile(entry)) {
-  if (isAbsolute5(wanted) || wanted.split(/[\\/]/u).includes("..")) {
+  if (isAbsolute6(wanted) || wanted.split(/[\\/]/u).includes("..")) {
     return { ok: false, error: "path_outside_skill", detail: wanted };
   }
-  const scope = realpathSync2(assetRoot(entry));
-  const single = statSync4(scope).isFile();
+  const scope = realpathSync3(assetRoot(entry));
+  const single = statSync5(scope).isFile();
   const root = single ? dirname9(scope) : scope;
   let target;
   try {
-    target = realpathSync2(
-      single && wanted === "" ? scope : resolve6(root, wanted)
+    target = realpathSync3(
+      single && wanted === "" ? scope : resolve7(root, wanted)
     );
   } catch {
     return { ok: false, error: "no_such_file", detail: wanted };
   }
-  const inside = single ? target === scope : target === root || target.startsWith(root + sep2);
+  const inside = single ? target === scope : target === root || target.startsWith(root + sep3);
   if (!inside)
     return { ok: false, error: "path_outside_skill", detail: wanted };
   return {
     ok: true,
     target,
-    path: relative6(root, target).split(sep2).join("/")
+    path: relative7(root, target).split(sep3).join("/")
   };
 }
 
@@ -3627,7 +3747,7 @@ var READ_BUDGET_BYTES = 256 * 1024;
 function readSkillFile(entry, wanted, budget = READ_BUDGET_BYTES) {
   const resolved = resolveSkillFile(entry, wanted);
   if (!resolved.ok) return resolved;
-  const size = statSync5(resolved.target).size;
+  const size = statSync6(resolved.target).size;
   if (size > budget) {
     return {
       ok: false,
@@ -3635,7 +3755,7 @@ function readSkillFile(entry, wanted, budget = READ_BUDGET_BYTES) {
       detail: `${size} bytes > ${budget}`
     };
   }
-  const bytes = servedBytes(resolved.target, readFileSync12(resolved.target));
+  const bytes = servedBytes(resolved.target, readFileSync13(resolved.target));
   const { kind: kind2, mimeType } = classify(resolved.path, bytes);
   return {
     ok: true,
@@ -3811,7 +3931,7 @@ function createSkillTools(options) {
     describe(name) {
       const entry = byName(name);
       if (!entry) return null;
-      const source = readFileSync13(entry.path, "utf8");
+      const source = readFileSync14(entry.path, "utf8");
       const listing2 = listSkillFiles(assetRoot(entry));
       return {
         name: entry.name,
@@ -3848,7 +3968,7 @@ function createSkillTools(options) {
       return {
         name: entry.name,
         body: readBody(
-          servedBytes(entry.path, readFileSync13(entry.path)).toString("utf8")
+          servedBytes(entry.path, readFileSync14(entry.path)).toString("utf8")
         ),
         files: bundle.files.filter((file) => file.path !== own),
         filesTruncated: bundle.truncated
@@ -3917,7 +4037,7 @@ function registerSkillPrompts(server, tools) {
 }
 
 // src/resources.ts
-import { statSync as statSync6 } from "fs";
+import { statSync as statSync7 } from "fs";
 import {
   ResourceNotFoundError,
   ResourceTemplate
@@ -3930,7 +4050,7 @@ function listing(entries) {
     name: entry.name,
     description: entry.description,
     mimeType: "text/markdown",
-    size: statSync6(entry.path).size
+    size: statSync7(entry.path).size
   }));
 }
 function complete(value, entries) {
@@ -3968,17 +4088,17 @@ function registerSkillResources(server, skills) {
 
 // src/extension/entry.ts
 import { createHash as createHash8 } from "crypto";
-import { readFileSync as readFileSync14, readdirSync as readdirSync7, statSync as statSync7 } from "fs";
-import { basename as basename5, dirname as dirname10, join as join12, relative as relative7, sep as sep3 } from "path";
+import { readFileSync as readFileSync15, readdirSync as readdirSync7, statSync as statSync8 } from "fs";
+import { basename as basename5, dirname as dirname10, join as join13, relative as relative8, sep as sep4 } from "path";
 var MAX_RESOURCES = 512;
 var MAX_SKILL_BYTES = 16 * 1024 * 1024;
 var digests = /* @__PURE__ */ new Map();
 function facts(path) {
-  const stat = statSync7(path);
+  const stat = statSync8(path);
   const key = `${stat.mtimeMs}:${stat.size}`;
   const cached = digests.get(path);
   if (cached?.key === key) return cached;
-  const bytes = servedBytes(path, readFileSync14(path));
+  const bytes = servedBytes(path, readFileSync15(path));
   const digest = `sha256:${createHash8("sha256").update(bytes).digest("hex")}`;
   const fresh = { key, digest, size: bytes.length };
   digests.set(path, fresh);
@@ -3991,7 +4111,7 @@ function filesUnder(root) {
     const dir = stack.pop();
     for (const entry of readdirSync7(dir, { withFileTypes: true })) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join12(dir, entry.name);
+      const full = join13(dir, entry.name);
       if (entry.isDirectory()) stack.push(full);
       else if (entry.isFile()) found.push(full);
       if (found.length > MAX_RESOURCES) return null;
@@ -4002,7 +4122,7 @@ function filesUnder(root) {
 function extensionEntry(entry) {
   if (kindOf(entry) !== "skill" || basename5(entry.path) !== "SKILL.md")
     return null;
-  const frontmatter = frontmatterObject(readFileSync14(entry.path, "utf8"));
+  const frontmatter = frontmatterObject(readFileSync15(entry.path, "utf8"));
   const root = dirname10(entry.path);
   if (specProblems(frontmatter, basename5(root)).length > 0) return null;
   if (frontmatter?.["name"] !== entry.slug) return null;
@@ -4012,7 +4132,7 @@ function extensionEntry(entry) {
   const resources = files.map((path) => {
     const fact = facts(path);
     total += fact.size;
-    const file = relative7(root, path).split(sep3).join("/");
+    const file = relative8(root, path).split(sep4).join("/");
     return {
       uri: skillFileUri(entry, file),
       digest: fact.digest,
@@ -4497,7 +4617,7 @@ function registerMailboxTools(server, service) {
 
 // src/mcp.ts
 var SERVER_NAME = "pmcp";
-var SERVER_VERSION = "0.13.1";
+var SERVER_VERSION = "0.14.0";
 function registerSkillTools(server, tools) {
   registerCatalogTool(server, tools);
   registerFindTool(server, tools);
@@ -4518,16 +4638,16 @@ function createSkillServer(options) {
 }
 
 // src/validate.ts
-import { existsSync as existsSync12, readFileSync as readFileSync15, statSync as statSync8 } from "fs";
-import { basename as basename6, join as join13, resolve as resolve7 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync16, statSync as statSync9 } from "fs";
+import { basename as basename6, join as join14, resolve as resolve8 } from "path";
 function validateSkillDir(dir) {
-  const root = resolve7(dir);
-  const skillMd = basename6(root) === "SKILL.md" ? root : join13(root, "SKILL.md");
-  if (!existsSync12(skillMd) || !statSync8(skillMd).isFile()) {
+  const root = resolve8(dir);
+  const skillMd = basename6(root) === "SKILL.md" ? root : join14(root, "SKILL.md");
+  if (!existsSync13(skillMd) || !statSync9(skillMd).isFile()) {
     return [{ path: root, reason: "no SKILL.md", level: "error" }];
   }
-  const front = frontmatterObject(readFileSync15(skillMd, "utf8"));
-  const directory = basename6(skillMd === root ? join13(root, "..") : root);
+  const front = frontmatterObject(readFileSync16(skillMd, "utf8"));
+  const directory = basename6(skillMd === root ? join14(root, "..") : root);
   return specProblems(front, directory).map((reason) => ({
     path: skillMd,
     reason,