@modootoday/pmcp 0.10.0 → 0.11.0

package/dist/chunk-ZUFFVIHQ.js

@@ -1,1191 +0,0 @@
-import {
-  loadEmbedder,
-  openEntryVectors
-} from "./chunk-XEH4ZGGJ.js";
-import {
-  frontmatterObject,
-  readCatalog,
-  specProblems
-} from "./chunk-VRZFM2M5.js";
-import {
-  ConfigError
-} from "./chunk-MSTKY33C.js";
-import {
-  DEFAULT_MODEL_ID,
-  resolveEncoder
-} from "./chunk-XOH2CW6P.js";
-
-// src/search.ts
-import { existsSync } from "fs";
-async function prepareSearch(catalog, options) {
-  const lexical = (reason) => ({
-    ranking: "lexical",
-    reason,
-    options: {}
-  });
-  if (!existsSync(options.indexPath)) return lexical("index_missing");
-  let store;
-  try {
-    store = await openEntryVectors(options.indexPath, { readOnly: true });
-  } catch {
-    return lexical("index_unavailable");
-  }
-  if (!store) return lexical("index_unavailable");
-  try {
-    const entries = (options.loadCatalog ?? readCatalog)(catalog);
-    const selected = resolveEncoder(
-      options.modelId ?? options.embedder?.modelId ?? DEFAULT_MODEL_ID,
-      options
-    );
-    const modelId = selected.modelId;
-    const key = selected.indexKey;
-    if (options.embedder?.indexKey !== void 0 && options.embedder.indexKey !== key)
-      return lexical("vector_mismatch");
-    const descriptions = new Map(
-      entries.map((entry2) => [entry2.name, entry2.description])
-    );
-    if (entries.length === 0 || store.stale(key, descriptions).length > 0)
-      return lexical("index_stale");
-    const vectors = store.read(key);
-    const embedder = options.embedder ?? await loadEmbedder(selected.modelId, {
-      ...options,
-      localOnly: options.localOnly ?? true
-    });
-    if (!embedder || embedder.modelId !== modelId)
-      return lexical("encoder_unavailable");
-    if (embedder.indexKey !== void 0 && embedder.indexKey !== key)
-      return lexical("vector_mismatch");
-    const probe = await embedder.embed("pmcp");
-    if (probe.length === 0 || !entries.every(
-      (entry2) => vectors.get(entry2.name)?.length === probe.length
-    ))
-      return lexical("vector_mismatch");
-    return {
-      ranking: "semantic",
-      options: { embedder, vectors, loadCatalog: () => entries }
-    };
-  } catch {
-    return lexical("encoder_unavailable");
-  } finally {
-    store.close();
-  }
-}
-
-// src/project/package-rules.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync2, lstatSync, readdirSync, readlinkSync } from "fs";
-import { dirname, join, posix } from "path";
-var ProjectError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProjectError";
-  }
-};
-var RULES_DIR = ".claude/rules";
-function trackedFiles(root, recurse = false) {
-  try {
-    const out = execFileSync(
-      "git",
-      ["ls-files", "-z", ...recurse ? ["--recurse-submodules"] : []],
-      { cwd: root, encoding: "utf8", maxBuffer: 1 << 28 }
-    );
-    return out.split("\0").filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-function deriveName(dir, strip) {
-  const segments = dir.split("/");
-  if (segments.length > 1 && strip.includes(segments[0] ?? "")) {
-    segments.shift();
-  }
-  const tokens = [];
-  for (const segment of segments) {
-    if (segment === "packages") continue;
-    for (const token of segment.split("-")) {
-      if (token === tokens[tokens.length - 1]) continue;
-      tokens.push(token);
-    }
-  }
-  return tokens.join("-");
-}
-function linkTarget(abs) {
-  try {
-    if (!lstatSync(abs).isSymbolicLink()) return null;
-    return readlinkSync(abs);
-  } catch {
-    return null;
-  }
-}
-function legacyLinks(root) {
-  const found = /* @__PURE__ */ new Map();
-  const dir = join(root, RULES_DIR);
-  if (!existsSync2(dir)) return found;
-  for (const entry2 of readdirSync(dir).sort()) {
-    if (!entry2.endsWith(".md")) continue;
-    const target = linkTarget(join(dir, entry2));
-    if (target === null || !target.startsWith("../../")) continue;
-    found.set(entry2.slice(0, -3), target.slice("../../".length));
-  }
-  return found;
-}
-function packageRuleOutputs(root, spec, owned) {
-  const suffix = `/${spec.file}`;
-  const files = trackedFiles(root).filter((file) => file.endsWith(suffix)).sort();
-  const prefix = `${RULES_DIR}/${spec.dir}/`;
-  const byTarget = /* @__PURE__ */ new Map();
-  for (const [path, target] of owned) {
-    if (!path.startsWith(prefix)) continue;
-    const rel = posix.normalize(posix.join(posix.dirname(path), target));
-    byTarget.set(rel, path.slice(prefix.length, -3));
-  }
-  const legacy = legacyLinks(root);
-  const legacyByDir = /* @__PURE__ */ new Map();
-  for (const [name, target] of legacy) {
-    if (!byTarget.has(target)) byTarget.set(target, name);
-    const dir = dirname(target);
-    if (!legacyByDir.has(dir)) legacyByDir.set(dir, name);
-  }
-  const outputs = [];
-  const taken = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const pkg = file.slice(0, -suffix.length);
-    const name = byTarget.get(file) ?? legacyByDir.get(dirname(file)) ?? deriveName(pkg, spec.strip);
-    const other = taken.get(name);
-    if (other !== void 0) {
-      throw new ProjectError(
-        `two packages want rule link ${prefix}${name}.md: ${other} and ${pkg}`
-      );
-    }
-    taken.set(name, pkg);
-    outputs.push({
-      kind: "link",
-      path: `${prefix}${name}.md`,
-      target: `../../../${file}`
-    });
-  }
-  return outputs;
-}
-
-// src/project/plan.ts
-import { existsSync as existsSync3, readFileSync, readdirSync as readdirSync2 } from "fs";
-import { join as join2 } from "path";
-
-// src/project/frontmatter.ts
-import { parse } from "yaml";
-function splitFrontmatter(source) {
-  const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/u.exec(source);
-  if (!match) return { meta: {}, body: source };
-  const meta = parse(match[1] ?? "");
-  const object = meta !== null && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
-  return { meta: object, body: match[2] ?? "" };
-}
-function scalar(value) {
-  if (typeof value === "string") return value;
-  return JSON.stringify(value);
-}
-function renderFrontmatter(meta) {
-  const lines2 = [];
-  for (const [key, value] of Object.entries(meta)) {
-    if (value === void 0 || value === null) continue;
-    if (typeof value === "string" && value.includes("\n")) {
-      const block2 = value.replace(/\n$/u, "").split("\n").map((line) => `  ${line}`);
-      lines2.push(`${key}: |`, ...block2);
-      continue;
-    }
-    if (Array.isArray(value)) {
-      lines2.push(`${key}: [${value.map((v) => JSON.stringify(v)).join(", ")}]`);
-      continue;
-    }
-    lines2.push(`${key}: ${scalar(value)}`);
-  }
-  return `---
-${lines2.join("\n")}
----
-`;
-}
-
-// src/project/outputs.ts
-var MARK = "AUTO-GENERATED by pmcp project";
-function jsonOutput(file, key, value) {
-  return { kind: "json", path: `${file}#${key.join(".")}`, file, key, value };
-}
-function blockOutput(file, content) {
-  return { kind: "block", path: `${file}#pmcp`, file, content };
-}
-function splitKeyed(path) {
-  const at = path.indexOf("#");
-  if (at === -1) return null;
-  return { file: path.slice(0, at), key: path.slice(at + 1).split(".") };
-}
-
-// src/project/mcp.ts
-var runtimeByTool = {
-  claude: "claude-code",
-  codex: "codex-cli",
-  gemini: "gemini-cli",
-  grok: "grok-cli",
-  antigravity: "antigravity"
-};
-function launchForTool(server, tool) {
-  if (!server.mailbox) return launch(server);
-  return launch({
-    ...server,
-    env: { ...server.env, PMCP_MAILBOX_RUNTIME: runtimeByTool[tool] }
-  });
-}
-var ROOT_VAR = "${PROJECT_ROOT}";
-var quote = (text) => `'${text.replaceAll("'", "'\\''")}'`;
-function shellWord(text) {
-  return text.split(ROOT_VAR).map((piece) => piece === "" ? "" : quote(piece)).join('"$d"');
-}
-function launch(spec) {
-  const words = [spec.command, ...spec.args, ...Object.values(spec.env)];
-  if (!words.some((word) => word.includes(ROOT_VAR))) {
-    return { command: spec.command, args: spec.args, env: spec.env };
-  }
-  const exports = Object.entries(spec.env).map(
-    ([key, value]) => `export ${key}=${shellWord(value)}; `
-  );
-  const script = 'd=$PWD; while [ ! -f "$d/pmcp.toml" ]; do [ "$d" = / ] && exit 1; d=$(dirname "$d"); done; ' + exports.join("") + `exec ${[spec.command, ...spec.args].map(shellWord).join(" ")}`;
-  return { command: "sh", args: ["-c", script], env: {} };
-}
-function entry(server, extra = {}) {
-  return {
-    command: server.command,
-    args: [...server.args],
-    ...Object.keys(server.env).length > 0 ? { env: { ...server.env } } : {},
-    ...extra
-  };
-}
-var tomlValue = (value) => {
-  if (Array.isArray(value)) return `[${value.map(tomlValue).join(", ")}]`;
-  if (value !== null && typeof value === "object") {
-    const parts = Object.entries(value).map(
-      ([k, v]) => `${JSON.stringify(k)} = ${tomlValue(v)}`
-    );
-    return `{ ${parts.join(", ")} }`;
-  }
-  return JSON.stringify(value);
-};
-function tomlServers(servers) {
-  const lines2 = [`# ${MARK} from pmcp.toml [mcp]`];
-  for (const [alias, server] of servers) {
-    lines2.push(
-      "",
-      `[mcp_servers.${alias}]`,
-      `command = ${tomlValue(server.command)}`,
-      `args = ${tomlValue(server.args)}`
-    );
-    if (Object.keys(server.env).length > 0) {
-      lines2.push(`env = ${tomlValue(server.env)}`);
-    }
-  }
-  return `${lines2.join("\n")}
-`;
-}
-function mcpOutputs(spec) {
-  const servers = Object.entries(spec.mcp);
-  if (servers.length === 0) return [];
-  const outputs = [];
-  for (const [alias, server] of servers) {
-    const tools = spec.mcp[alias]?.tools;
-    if (spec.tools.has("claude")) {
-      outputs.push(
-        jsonOutput(
-          ".mcp.json",
-          ["mcpServers", alias],
-          entry(launchForTool(server, "claude"))
-        )
-      );
-    }
-    if (spec.tools.has("gemini")) {
-      const extra = tools ? { includeTools: [...tools] } : {};
-      outputs.push(
-        jsonOutput(
-          ".gemini/settings.json",
-          ["mcpServers", alias],
-          entry(launchForTool(server, "gemini"), extra)
-        )
-      );
-    }
-    if (spec.tools.has("antigravity")) {
-      outputs.push(
-        jsonOutput(
-          ".agents/mcp_config.json",
-          ["mcpServers", alias],
-          entry(launchForTool(server, "antigravity"))
-        )
-      );
-    }
-  }
-  if (spec.tools.has("codex")) {
-    outputs.push(
-      blockOutput(
-        ".codex/config.toml",
-        tomlServers(
-          servers.map(([alias, server]) => [
-            alias,
-            launchForTool(server, "codex")
-          ])
-        )
-      )
-    );
-  }
-  if (spec.tools.has("grok")) {
-    outputs.push(
-      blockOutput(
-        ".grok/config.toml",
-        tomlServers(
-          servers.map(([alias, server]) => [
-            alias,
-            launchForTool(server, "grok")
-          ])
-        )
-      )
-    );
-  }
-  return outputs;
-}
-
-// src/project/plan.ts
-var AGENT_FIELDS = {
-  claude: ["name", "description", "tools", "model", "effort"],
-  gemini: ["name", "description"]
-};
-var SETTINGS = ".claude/settings.json";
-function listDirs(dir) {
-  if (!existsSync3(dir)) return [];
-  return readdirSync2(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 = join2(root, ".agents/skills");
-  return listDirs(dir).filter(
-    (name) => existsSync3(join2(dir, name, "SKILL.md"))
-  );
-}
-function agentNames(root) {
-  const dir = join2(root, ".agents/agents");
-  return listDirs(dir).filter(
-    (name) => existsSync3(join2(dir, name, "agent.md"))
-  );
-}
-function skillOutputs(spec) {
-  const outputs = [];
-  for (const name of skillNames(spec.root)) {
-    const target = `../../.agents/skills/${name}`;
-    if (spec.tools.has("claude")) {
-      outputs.push({ kind: "link", path: `.claude/skills/${name}`, target });
-    }
-    if (spec.tools.has("grok")) {
-      outputs.push({ kind: "link", path: `.grok/skills/${name}`, target });
-    }
-    if (spec.skills[name]?.invocation !== "user") continue;
-    if (spec.tools.has("claude")) {
-      outputs.push(
-        jsonOutput(SETTINGS, ["skillOverrides", name], "user-invocable-only")
-      );
-    }
-    if (spec.tools.has("codex")) {
-      outputs.push({
-        kind: "file",
-        path: `.agents/skills/${name}/agents/openai.yaml`,
-        content: `# ${MARK}
-policy:
-  allow_implicit_invocation: false
-`
-      });
-    }
-  }
-  return outputs;
-}
-function ruleOutputs(spec) {
-  if (!spec.tools.has("claude")) return [];
-  const dir = join2(spec.root, ".agents/rules");
-  if (!existsSync3(dir)) return [];
-  const outputs = [];
-  for (const file of readdirSync2(dir).filter((f) => f.endsWith(".md")).sort()) {
-    const rel = `.agents/rules/${file}`;
-    const { meta, body } = splitFrontmatter(
-      readFileSync(join2(spec.root, rel), "utf8")
-    );
-    const globs = [meta["globs"] ?? []].flat().filter((g) => typeof g === "string" && g !== "");
-    const head = globs.length > 0 ? renderFrontmatter({ paths: globs }) : "";
-    outputs.push({
-      kind: "file",
-      path: `${RULES_DIR}/pmcp/${file}`,
-      content: `${head}
-<!-- ${MARK} from ${rel} -->
-${body}`
-    });
-  }
-  return outputs;
-}
-function agentOutputs(spec) {
-  const outputs = [];
-  for (const name of agentNames(spec.root)) {
-    const rel = `.agents/agents/${name}/agent.md`;
-    const { meta, body } = splitFrontmatter(
-      readFileSync(join2(spec.root, rel), "utf8")
-    );
-    const overrides = spec.agents[name] ?? {};
-    const note = `<!-- ${MARK} from ${rel} -->
-`;
-    const pick = (tool) => {
-      const merged = {
-        ...meta,
-        ...overrides[tool] ?? {}
-      };
-      const kept = {};
-      for (const key of AGENT_FIELDS[tool] ?? []) {
-        if (merged[key] !== void 0) kept[key] = merged[key];
-      }
-      return kept;
-    };
-    for (const tool of ["claude", "gemini"]) {
-      if (!spec.tools.has(tool)) continue;
-      outputs.push({
-        kind: "file",
-        path: `.${tool}/agents/${name}.md`,
-        content: `${renderFrontmatter(pick(tool))}
-${note}${body}`
-      });
-    }
-    if (spec.tools.has("codex")) {
-      const toml = [
-        `# ${MARK} from ${rel}`,
-        `name = ${tomlString(meta["name"])}`,
-        `description = ${tomlString(meta["description"])}`,
-        `developer_instructions = ${tomlString(body.trim())}`,
-        ""
-      ].join("\n");
-      outputs.push({
-        kind: "file",
-        path: `.codex/agents/${name}.toml`,
-        content: toml
-      });
-    }
-  }
-  return outputs;
-}
-function plan(spec, owned = /* @__PURE__ */ new Map()) {
-  const outputs = [
-    ...skillOutputs(spec),
-    ...ruleOutputs(spec),
-    ...agentOutputs(spec),
-    ...mcpOutputs(spec)
-  ];
-  if (spec.packageRules && spec.tools.has("claude")) {
-    outputs.push(...packageRuleOutputs(spec.root, spec.packageRules, owned));
-  }
-  return outputs;
-}
-function censusDirs(spec) {
-  const dirs = [
-    ".claude/skills",
-    ".claude/agents",
-    ".claude/commands",
-    ".gemini/agents",
-    ".codex/agents",
-    ".grok/skills",
-    `${RULES_DIR}/pmcp`
-  ];
-  if (spec.packageRules) dirs.push(`${RULES_DIR}/${spec.packageRules.dir}`);
-  return dirs;
-}
-
-// src/project/apply.ts
-import { createHash } from "crypto";
-import {
-  existsSync as existsSync4,
-  lstatSync as lstatSync2,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  readdirSync as readdirSync3,
-  readlinkSync as readlinkSync2,
-  rmSync,
-  symlinkSync,
-  writeFileSync
-} from "fs";
-import { dirname as dirname2, join as join3, posix as posix2 } from "path";
-var LOCK_FILE = "pmcp.lock";
-var BEGIN = "# >>> pmcp project (edit pmcp.toml, not this block) >>>";
-var END = "# <<< pmcp project <<<";
-var PREDECESSORS = [
-  "by sync-claude-projection.sh",
-  "AUTO-GENERATED by scripts/agent/project.mjs"
-];
-var sha = (text) => createHash("sha256").update(text).digest("hex");
-function readLock(root) {
-  const path = join3(root, LOCK_FILE);
-  if (!existsSync4(path)) return [];
-  const lock = JSON.parse(readFileSync2(path, "utf8"));
-  return lock.outputs ?? [];
-}
-function linkOf(abs) {
-  try {
-    return lstatSync2(abs).isSymbolicLink() ? readlinkSync2(abs) : null;
-  } catch {
-    return null;
-  }
-}
-var exists = (abs) => existsSync4(abs) || linkOf(abs) !== null;
-function readJson(abs) {
-  if (!existsSync4(abs)) return {};
-  const value = JSON.parse(readFileSync2(abs, "utf8"));
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function getKey(object, key) {
-  let node = object;
-  for (const part of key) {
-    if (node === null || typeof node !== "object") return void 0;
-    node = node[part];
-  }
-  return node;
-}
-function setKey(object, key, value) {
-  let node = object;
-  for (const part of key.slice(0, -1)) {
-    const next = node[part];
-    if (next === null || typeof next !== "object" || Array.isArray(next)) {
-      node[part] = {};
-    }
-    node = node[part];
-  }
-  node[key[key.length - 1] ?? ""] = value;
-}
-function deleteKey(object, key) {
-  const [head, ...rest] = key;
-  if (head === void 0 || !(head in object)) return;
-  if (rest.length === 0) {
-    delete object[head];
-    return;
-  }
-  const child = object[head];
-  if (child === null || typeof child !== "object") return;
-  deleteKey(child, rest);
-  if (Object.keys(child).length === 0) delete object[head];
-}
-var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-var block = (content) => `${BEGIN}
-${content}${END}
-`;
-function withoutBlock(text) {
-  const start = text.indexOf(BEGIN);
-  if (start === -1) return text;
-  const end = text.indexOf(END, start);
-  if (end === -1) return text;
-  const after = text.slice(end + END.length).replace(/^\n/u, "");
-  return `${text.slice(0, start).replace(/\n+$/u, "\n")}${after}`;
-}
-function present(root, output) {
-  const abs = join3(root, "file" in output ? output.file : output.path);
-  switch (output.kind) {
-    case "link":
-      return linkOf(abs) === output.target;
-    case "file":
-      return existsSync4(abs) && linkOf(abs) === null && readFileSync2(abs, "utf8") === output.content;
-    case "json":
-      return same(getKey(readJson(abs), output.key), output.value);
-    case "block":
-      return existsSync4(abs) && readFileSync2(abs, "utf8").includes(block(output.content));
-  }
-}
-function replaceable(root, output, owned) {
-  if (output.kind === "json" || output.kind === "block") return true;
-  if (owned.has(output.path)) return true;
-  const abs = join3(root, output.path);
-  if (!exists(abs)) return true;
-  const target = linkOf(abs);
-  if (target !== null) {
-    return output.kind === "link" && target === output.target;
-  }
-  if (lstatSync2(abs).isDirectory()) return false;
-  const text = readFileSync2(abs, "utf8");
-  if (output.kind === "file" && text === output.content) return true;
-  return PREDECESSORS.some((mark) => text.includes(mark));
-}
-function undeclared(spec, outputs) {
-  const declared = new Set(outputs.map((o) => o.path));
-  const found = [];
-  for (const dir of censusDirs(spec)) {
-    const abs = join3(spec.root, dir);
-    if (!existsSync4(abs)) continue;
-    for (const entry2 of readdirSync3(abs)) {
-      const path = `${dir}/${entry2}`;
-      if (!declared.has(path)) found.push(path);
-    }
-  }
-  const rules = join3(spec.root, RULES_DIR);
-  if (spec.tools.has("grok") && existsSync4(rules)) {
-    for (const entry2 of readdirSync3(rules, { withFileTypes: true })) {
-      if (entry2.isDirectory()) continue;
-      found.push(`${RULES_DIR}/${entry2.name}`);
-    }
-  }
-  return found.sort();
-}
-function deadGlobs(root, outputs) {
-  const rules = outputs.filter(
-    (o) => (o.kind === "link" || o.kind === "file") && o.path.startsWith(`${RULES_DIR}/`)
-  );
-  if (rules.length === 0) return [];
-  const tracked = trackedFiles(root, true);
-  if (tracked.length === 0) return [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const file of tracked) {
-    const parts = file.split("/");
-    for (let i = 1; i <= parts.length; i += 1)
-      seen.add(parts.slice(0, i).join("/"));
-  }
-  const dead = [];
-  for (const rule of rules) {
-    let text;
-    if (rule.kind === "file") {
-      text = rule.content;
-    } else if (rule.kind === "link") {
-      const abs = join3(root, posix2.join(posix2.dirname(rule.path), rule.target));
-      if (!existsSync4(abs)) continue;
-      text = readFileSync2(abs, "utf8");
-    } else {
-      continue;
-    }
-    const paths = splitFrontmatter(text).meta["paths"];
-    for (const glob of [paths ?? []].flat()) {
-      if (typeof glob !== "string") continue;
-      const prefix = glob.replace(/\*.*$/u, "").replace(/\/$/u, "");
-      if (prefix !== "" && !seen.has(prefix))
-        dead.push(`${rule.path}: ${glob}`);
-    }
-  }
-  return dead;
-}
-function lockEntry(output) {
-  switch (output.kind) {
-    case "link":
-      return { path: output.path, kind: "link", target: output.target };
-    case "file":
-      return { path: output.path, kind: "file", sha256: sha(output.content) };
-    case "json":
-      return {
-        path: output.path,
-        kind: "json",
-        sha256: sha(JSON.stringify(output.value))
-      };
-    case "block":
-      return { path: output.path, kind: "block", sha256: sha(output.content) };
-  }
-}
-function project(spec, options) {
-  const lock = readLock(spec.root);
-  const ownedTargets = new Map(
-    lock.filter((e) => e.kind === "link" && e.target !== void 0).map((e) => [e.path, e.target])
-  );
-  const outputs = plan(spec, ownedTargets);
-  const owned = new Set(lock.map((e) => e.path));
-  const planned = new Set(outputs.map((o) => o.path));
-  const stale = lock.filter((e) => !planned.has(e.path));
-  if (options.check) {
-    const problems = [
-      ...outputs.filter((o) => !present(spec.root, o)).map((o) => `drift: ${o.path}`),
-      ...stale.map((e) => `stale: ${e.path}`),
-      ...undeclared(spec, outputs).map((p) => `undeclared: ${p}`),
-      ...deadGlobs(spec.root, outputs).map((p) => `dead glob: ${p}`)
-    ];
-    return {
-      code: problems.length > 0 ? 2 : 0,
-      problems,
-      outputs: outputs.length,
-      pruned: 0
-    };
-  }
-  const refused = outputs.filter((o) => !replaceable(spec.root, o, owned)).map((o) => `refusing to overwrite a file it did not write: ${o.path}`);
-  if (refused.length > 0) {
-    return { code: 3, problems: refused, outputs: outputs.length, pruned: 0 };
-  }
-  for (const output of outputs) {
-    if (output.kind !== "link" && output.kind !== "file") continue;
-    if (present(spec.root, output)) continue;
-    const abs = join3(spec.root, output.path);
-    mkdirSync(dirname2(abs), { recursive: true });
-    rmSync(abs, { force: true, recursive: true });
-    if (output.kind === "link") symlinkSync(output.target, abs);
-    else writeFileSync(abs, output.content);
-  }
-  let pruned = 0;
-  const jsonFiles = /* @__PURE__ */ new Map();
-  const blockFiles = /* @__PURE__ */ new Map();
-  for (const output of outputs) {
-    if (output.kind === "json") {
-      const entry2 = jsonFiles.get(output.file) ?? { sets: [], drops: [] };
-      entry2.sets.push(output);
-      jsonFiles.set(output.file, entry2);
-    }
-    if (output.kind === "block") blockFiles.set(output.file, output.content);
-  }
-  for (const entry2 of stale) {
-    const keyed = splitKeyed(entry2.path);
-    if (keyed && keyed.key.length === 1 && keyed.key[0] === "pmcp") {
-      if (!blockFiles.has(keyed.file)) blockFiles.set(keyed.file, null);
-    } else if (keyed) {
-      const group = jsonFiles.get(keyed.file) ?? { sets: [], drops: [] };
-      group.drops.push(keyed.key);
-      jsonFiles.set(keyed.file, group);
-    } else {
-      rmSync(join3(spec.root, entry2.path), { force: true, recursive: true });
-    }
-    pruned += 1;
-  }
-  for (const [file, { sets, drops }] of jsonFiles) {
-    const abs = join3(spec.root, file);
-    const before = readJson(abs);
-    const after = structuredClone(before);
-    for (const key of drops) deleteKey(after, key);
-    for (const output of sets) {
-      if (output.kind === "json") setKey(after, output.key, output.value);
-    }
-    if (same(before, after)) continue;
-    if (!existsSync4(abs) && Object.keys(after).length === 0) continue;
-    mkdirSync(dirname2(abs), { recursive: true });
-    writeFileSync(abs, `${JSON.stringify(after, null, 2)}
-`);
-  }
-  for (const [file, content] of blockFiles) {
-    const abs = join3(spec.root, file);
-    const before = existsSync4(abs) ? readFileSync2(abs, "utf8") : "";
-    let after = withoutBlock(before);
-    if (content !== null) {
-      const sep = after === "" || after.endsWith("\n\n") ? "" : after.endsWith("\n") ? "\n" : "\n\n";
-      after = `${after}${sep}${block(content)}`;
-    }
-    if (after === before) continue;
-    mkdirSync(dirname2(abs), { recursive: true });
-    writeFileSync(abs, after);
-  }
-  if (spec.packageRules) {
-    const linkedDirs = new Set(
-      outputs.filter(
-        (o) => o.kind === "link" && o.path.startsWith(`${RULES_DIR}/${spec.packageRules?.dir}/`)
-      ).map(
-        (o) => o.kind === "link" ? posix2.dirname(o.target.replace(/^(\.\.\/)+/u, "")) : ""
-      )
-    );
-    for (const [name, target] of legacyLinks(spec.root)) {
-      const abs = join3(spec.root, RULES_DIR, `${name}.md`);
-      const broken = !existsSync4(abs);
-      if (!broken && !linkedDirs.has(posix2.dirname(target))) continue;
-      rmSync(abs, { force: true });
-      pruned += 1;
-    }
-  }
-  writeFileSync(
-    join3(spec.root, LOCK_FILE),
-    `${JSON.stringify({ version: 1, outputs: outputs.map(lockEntry) }, null, 2)}
-`
-  );
-  return { code: 0, problems: [], outputs: outputs.length, pruned };
-}
-
-// src/project/doctor.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
-import { parse as parse2 } from "smol-toml";
-var spawnRunner = (command, args, cwd) => {
-  const result = spawnSync(command, [...args], {
-    cwd,
-    encoding: "utf8",
-    timeout: 18e4,
-    maxBuffer: 1 << 26
-  });
-  const code = result.error?.code;
-  return {
-    missing: code === "ENOENT",
-    status: result.status,
-    stdout: `${result.stdout ?? ""}${result.stderr ?? ""}`
-  };
-};
-var missingFrom = (names, present2) => names.filter((name) => !present2(name));
-function verdict(tool, check, missing) {
-  if (missing.length === 0) return { tool, check, status: "ok" };
-  return {
-    tool,
-    check,
-    status: "fail",
-    detail: `missing: ${missing.join(", ")}`
-  };
-}
-function listed(tool, check, result, names, present2) {
-  if (result.missing)
-    return { tool, check, status: "skip", detail: "not installed" };
-  if (result.status !== 0) {
-    return {
-      tool,
-      check,
-      status: "fail",
-      detail: `exit ${result.status}: ${result.stdout.trim().split("\n").pop() ?? ""}`
-    };
-  }
-  return verdict(
-    tool,
-    check,
-    missingFrom(names, (name) => present2(result.stdout, name))
-  );
-}
-var lines = (out) => out.split("\n").map((l) => l.trim());
-function claude(spec, o) {
-  const aliases = Object.keys(spec.mcp);
-  if (aliases.length === 0) return [];
-  const result = o.run("claude", ["mcp", "list"], spec.root);
-  return [
-    listed(
-      "claude",
-      "mcp servers connected",
-      result,
-      aliases,
-      (out, alias) => lines(out).some(
-        (l) => l.startsWith(`${alias}:`) && /connected/iu.test(l) && !/failed/iu.test(l)
-      )
-    )
-  ];
-}
-function codex(spec, o) {
-  const findings = [];
-  const config = join4(o.home, ".codex/config.toml");
-  let trusted = false;
-  if (existsSync5(config)) {
-    const projects = parse2(readFileSync3(config, "utf8")).projects ?? {};
-    const root = spec.root.replace(/\/$/u, "");
-    trusted = projects[root]?.trust_level === "trusted" || projects[`${root}/`]?.trust_level === "trusted";
-  }
-  findings.push(
-    trusted ? { tool: "codex", check: "project trusted", status: "ok" } : {
-      tool: "codex",
-      check: "project trusted",
-      status: "fail",
-      detail: "untrusted projects skip .codex/ and .agents/"
-    }
-  );
-  const aliases = Object.keys(spec.mcp);
-  if (aliases.length > 0) {
-    const result = o.run("codex", ["mcp", "list"], spec.root);
-    findings.push(
-      listed(
-        "codex",
-        "mcp servers listed",
-        result,
-        aliases,
-        (out, alias) => lines(out).some((l) => l.split(/\s+/u)[0] === alias)
-      )
-    );
-  }
-  return findings;
-}
-function gemini(spec, o) {
-  const findings = [];
-  const skills = skillNames(spec.root);
-  if (skills.length > 0) {
-    const result = o.run("gemini", ["skills", "list"], spec.root);
-    findings.push(
-      listed(
-        "gemini",
-        "project skills listed",
-        result,
-        skills,
-        (out, name) => lines(out).some((l) => l.startsWith(`${name} [`))
-      )
-    );
-  }
-  const aliases = Object.keys(spec.mcp);
-  if (aliases.length > 0) {
-    const result = o.run("gemini", ["mcp", "list"], spec.root);
-    findings.push(
-      listed(
-        "gemini",
-        "mcp servers connected",
-        result,
-        aliases,
-        (out, alias) => lines(out).some(
-          (l) => l.includes(`${alias}:`) && /connected/iu.test(l) && !/disconnected/iu.test(l)
-        )
-      )
-    );
-  }
-  return findings;
-}
-function grok(spec, o) {
-  const result = o.run("grok", ["inspect", "--json"], spec.root);
-  if (result.missing)
-    return [
-      {
-        tool: "grok",
-        check: "inspect",
-        status: "skip",
-        detail: "not installed"
-      }
-    ];
-  let report;
-  try {
-    report = JSON.parse(
-      result.stdout.slice(result.stdout.indexOf("{"))
-    );
-  } catch {
-    return [
-      {
-        tool: "grok",
-        check: "inspect",
-        status: "fail",
-        detail: "grok inspect --json did not return JSON"
-      }
-    ];
-  }
-  const findings = [];
-  findings.push(
-    report.projectTrusted ? { tool: "grok", check: "project trusted", status: "ok" } : {
-      tool: "grok",
-      check: "project trusted",
-      status: "fail",
-      detail: "untrusted projects skip .grok/ MCP and hooks"
-    }
-  );
-  const skills = new Set((report.skills ?? []).map((s) => s.name));
-  findings.push(
-    verdict(
-      "grok",
-      "project skills listed",
-      missingFrom(skillNames(spec.root), (n) => skills.has(n))
-    )
-  );
-  const leaked = (report.projectInstructions ?? []).filter(
-    (i) => i.path.includes("/.claude/rules/")
-  );
-  findings.push(
-    leaked.length === 0 ? { tool: "grok", check: "no .claude/rules loaded", status: "ok" } : {
-      tool: "grok",
-      check: "no .claude/rules loaded",
-      status: "fail",
-      detail: `${leaked.length} rule files load unscoped`
-    }
-  );
-  const servers = new Set((report.mcpServers ?? []).map((s) => s.name));
-  if (Object.keys(spec.mcp).length > 0) {
-    findings.push(
-      verdict(
-        "grok",
-        "mcp servers listed",
-        missingFrom(Object.keys(spec.mcp), (n) => servers.has(n))
-      )
-    );
-  }
-  return findings;
-}
-function antigravity(spec) {
-  const foreign = agentNames(spec.root).filter((name) => {
-    const text = readFileSync3(
-      join4(spec.root, ".agents/agents", name, "agent.md"),
-      "utf8"
-    );
-    return splitFrontmatter(text).meta["tools"] !== void 0;
-  });
-  return [
-    foreign.length === 0 ? {
-      tool: "antigravity",
-      check: "agents carry no tool lists",
-      status: "ok"
-    } : {
-      tool: "antigravity",
-      check: "agents carry no tool lists",
-      status: "fail",
-      detail: `move tools to pmcp.toml [agents.<name>.<tool>]: ${foreign.join(", ")}`
-    }
-  ];
-}
-function doctor(spec, options) {
-  const check = project(spec, { check: true });
-  const findings = [
-    check.code === 0 ? { tool: "project", check: "outputs match sources", status: "ok" } : {
-      tool: "project",
-      check: "outputs match sources",
-      status: "fail",
-      detail: check.problems.slice(0, 5).join("; ")
-    }
-  ];
-  const wanted = (tool) => spec.tools.has(tool) && (options.only === void 0 || options.only.has(tool));
-  if (wanted("claude")) findings.push(...claude(spec, options));
-  if (wanted("codex")) findings.push(...codex(spec, options));
-  if (wanted("gemini")) findings.push(...gemini(spec, options));
-  if (wanted("grok")) findings.push(...grok(spec, options));
-  if (wanted("antigravity")) findings.push(...antigravity(spec));
-  return findings;
-}
-
-// src/project/spec.ts
-var TOOLS = [
-  "claude",
-  "codex",
-  "gemini",
-  "grok",
-  "antigravity"
-];
-var NAME = /^[a-z0-9][a-z0-9-]*$/u;
-function table(path, where, value) {
-  if (value === void 0) return {};
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new ConfigError(path, `${where} must be a table`);
-  }
-  return value;
-}
-function strings(path, where, value) {
-  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
-    throw new ConfigError(path, `${where} must be a list of strings`);
-  }
-  return value;
-}
-function named(path, where, name) {
-  if (!NAME.test(name)) {
-    throw new ConfigError(
-      path,
-      `${where} ${name}: use lowercase, digits and -`
-    );
-  }
-  return name;
-}
-function readSpec(config) {
-  const path = config.path;
-  const raw = config.raw;
-  const targets = table(path, "[targets]", raw["targets"]);
-  const tools = /* @__PURE__ */ new Set();
-  if (targets["tools"] !== void 0) {
-    for (const tool of strings(path, "[targets] tools", targets["tools"])) {
-      if (!TOOLS.includes(tool)) {
-        throw new ConfigError(path, `[targets] unknown tool ${tool}`);
-      }
-      tools.add(tool);
-    }
-  }
-  const skills = {};
-  for (const [name, value] of Object.entries(
-    table(path, "[skills]", raw["skills"])
-  )) {
-    const entry2 = table(path, `[skills.${name}]`, value);
-    const invocation = entry2["invocation"] ?? "any";
-    if (invocation !== "any" && invocation !== "user") {
-      throw new ConfigError(
-        path,
-        `[skills.${name}] invocation must be "any" or "user"`
-      );
-    }
-    skills[named(path, "[skills]", name)] = { invocation };
-  }
-  const agents = {};
-  for (const [name, value] of Object.entries(
-    table(path, "[agents]", raw["agents"])
-  )) {
-    const perTool = {};
-    for (const [tool, fields] of Object.entries(
-      table(path, `[agents.${name}]`, value)
-    )) {
-      if (!TOOLS.includes(tool)) {
-        throw new ConfigError(path, `[agents.${name}] unknown tool ${tool}`);
-      }
-      perTool[tool] = table(path, `[agents.${name}.${tool}]`, fields);
-    }
-    agents[named(path, "[agents]", name)] = perTool;
-  }
-  const rules = table(path, "[rules]", raw["rules"]);
-  let packageRules = null;
-  if (rules["packages"] !== void 0) {
-    const pkg = table(path, "[rules.packages]", rules["packages"]);
-    const file = pkg["file"];
-    if (typeof file !== "string" || file === "") {
-      throw new ConfigError(path, "[rules.packages] file is required");
-    }
-    const dir = pkg["dir"] ?? "pkg";
-    if (typeof dir !== "string" || !NAME.test(dir) || dir === "pmcp") {
-      throw new ConfigError(
-        path,
-        '[rules.packages] dir must be a plain name other than "pmcp"'
-      );
-    }
-    const strip = pkg["strip"] === void 0 ? [] : strings(path, "[rules.packages] strip", pkg["strip"]);
-    packageRules = { file, dir, strip };
-  }
-  const mcp = {};
-  for (const [alias, value] of Object.entries(
-    table(path, "[mcp]", raw["mcp"])
-  )) {
-    const where = `[mcp.${alias}]`;
-    const entry2 = table(path, where, value);
-    const command = entry2["command"];
-    if (typeof command !== "string" || command === "") {
-      throw new ConfigError(path, `${where} command is required`);
-    }
-    const env = {};
-    if (entry2["mailbox"] !== void 0 && typeof entry2["mailbox"] !== "boolean") {
-      throw new ConfigError(path, `${where} mailbox must be a boolean`);
-    }
-    for (const [key, v] of Object.entries(
-      table(path, `${where} env`, entry2["env"])
-    )) {
-      if (typeof v !== "string") {
-        throw new ConfigError(path, `${where} env ${key} must be a string`);
-      }
-      env[key] = v;
-    }
-    mcp[named(path, "[mcp]", alias)] = {
-      ...entry2["mailbox"] === true ? { mailbox: true } : {},
-      command,
-      args: entry2["args"] === void 0 ? [] : strings(path, `${where} args`, entry2["args"]),
-      env,
-      ...entry2["tools"] === void 0 ? {} : { tools: strings(path, `${where} tools`, entry2["tools"]) }
-    };
-  }
-  return { root: config.dir, tools, skills, agents, packageRules, mcp };
-}
-
-// src/validate.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, statSync } from "fs";
-import { basename, join as join5, resolve } from "path";
-function validateSkillDir(dir) {
-  const root = resolve(dir);
-  const skillMd = basename(root) === "SKILL.md" ? root : join5(root, "SKILL.md");
-  if (!existsSync6(skillMd) || !statSync(skillMd).isFile()) {
-    return [{ path: root, reason: "no SKILL.md", level: "error" }];
-  }
-  const front = frontmatterObject(readFileSync4(skillMd, "utf8"));
-  const directory = basename(skillMd === root ? join5(root, "..") : root);
-  return specProblems(front, directory).map((reason) => ({
-    path: skillMd,
-    reason,
-    level: "error"
-  }));
-}
-function validateCatalog(options) {
-  const findings = [];
-  readCatalog({
-    ...options,
-    onReject: (r) => findings.push({ ...r, level: "error" }),
-    onWarning: (w) => findings.push({ ...w, level: "warning" })
-  });
-  return findings;
-}
-
-export {
-  prepareSearch,
-  splitFrontmatter,
-  renderFrontmatter,
-  ProjectError,
-  deriveName,
-  plan,
-  LOCK_FILE,
-  deadGlobs,
-  project,
-  spawnRunner,
-  doctor,
-  TOOLS,
-  readSpec,
-  validateSkillDir,
-  validateCatalog
-};
-//# sourceMappingURL=chunk-ZUFFVIHQ.js.map