@modootoday/pmcp 0.5.1 → 0.6.0

package/dist/{chunk-ICHBC5FM.js → chunk-FXBLBKP6.js}

@@ -1,6 +1,6 @@
 import {
   createSkillServer
-} from "./chunk-76UKXVUE.js";
+} from "./chunk-5TX2IAVD.js";
 
 // src/stdio.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
@@ -35,4 +35,4 @@ export {
   serve,
   main
 };
-//# sourceMappingURL=chunk-ICHBC5FM.js.map
+//# sourceMappingURL=chunk-FXBLBKP6.js.map

package/dist/cli.js

@@ -1,16 +1,25 @@
 #!/usr/bin/env node
 import {
   ConfigError,
+  ProjectError,
+  TOOLS,
+  doctor,
   findConfig,
   openDatabase,
-  readConfig
-} from "./chunk-XTLANVRL.js";
+  project,
+  readConfig,
+  readSpec,
+  renderFrontmatter,
+  spawnRunner,
+  splitFrontmatter
+} from "./chunk-6TSHDCUY.js";
 import {
   serve
-} from "./chunk-ICHBC5FM.js";
+} from "./chunk-FXBLBKP6.js";
 import {
+  kindOf,
   readCatalog
-} from "./chunk-76UKXVUE.js";
+} from "./chunk-5TX2IAVD.js";
 
 // src/cli/command.ts
 var ArgumentError = class extends Error {
@@ -913,8 +922,8 @@ function absent(error) {
 function packageName(name) {
   return /^(?:@[a-z0-9._-]+\/)?[a-z0-9][a-z0-9._-]*$/u.test(name);
 }
-function locate(name, project) {
-  let directory = project;
+function locate(name, project2) {
+  let directory = project2;
   for (; ; ) {
     let source;
     try {
@@ -946,9 +955,9 @@ function locate(name, project) {
   }
 }
 function readInstalledDependencies(projectDirectory) {
-  const project = resolve(projectDirectory);
+  const project2 = resolve(projectDirectory);
   const manifest = JSON.parse(
-    readFileSync2(join2(project, "package.json"), "utf8")
+    readFileSync2(join2(project2, "package.json"), "utf8")
   );
   if (!object(manifest))
     throw new Error("project package.json must contain an object");
@@ -972,7 +981,7 @@ function readInstalledDependencies(projectDirectory) {
   const dependencies = [];
   const issues = [];
   for (const name of [...names].sort()) {
-    const result = locate(name, project);
+    const result = locate(name, project2);
     if ("reason" in result) issues.push(result);
     else dependencies.push(result);
   }
@@ -1034,12 +1043,12 @@ function manifestAt(directory) {
   return value;
 }
 function installContext(directory) {
-  const project = resolve2(directory);
-  const manifest = manifestAt(project);
-  let root = project;
-  let ancestor = project;
+  const project2 = resolve2(directory);
+  const manifest = manifestAt(project2);
+  let root = project2;
+  let ancestor = project2;
   for (; ; ) {
-    if (ancestor !== project && existsSync(join3(ancestor, "package.json"))) {
+    if (ancestor !== project2 && existsSync(join3(ancestor, "package.json"))) {
       const candidate = manifestAt(ancestor);
       if (candidate.workspaces !== void 0) {
         root = ancestor;
@@ -1076,7 +1085,7 @@ function installContext(directory) {
     throw new Error(
       "declare packageManager or install project dependencies first"
     );
-  if (root !== project && LOCKS.some((file) => existsSync(join3(project, file)))) {
+  if (root !== project2 && LOCKS.some((file) => existsSync(join3(project2, file)))) {
     throw new Error(
       "nested project has its own lockfile; resolve the workspace boundary first"
     );
@@ -1084,12 +1093,12 @@ function installContext(directory) {
   const files = [
     .../* @__PURE__ */ new Set([
       join3(root, "package.json"),
-      join3(project, "package.json"),
+      join3(project2, "package.json"),
       ...LOCKS.map((file) => join3(root, file))
     ])
   ];
   return {
-    project,
+    project: project2,
     root,
     manager,
     manifest,
@@ -1584,10 +1593,10 @@ function createPackageManagerRunner(userConfig, baseEnv = process.env, verifiedI
     integrity(packageSpec, plan) {
       const alreadyVerified = verifiedIntegrity?.get(packageSpec);
       if (alreadyVerified) return alreadyVerified;
-      const { manager, project } = plan.context;
+      const { manager, project: project2 } = plan.context;
       const args = manager === "npm" ? ["view", packageSpec, "dist.integrity", "--json"] : ["info", packageSpec, "dist.integrity", "--json"];
       const result = spawnSync(manager, args, {
-        cwd: project,
+        cwd: project2,
         env: environment(userConfig, baseEnv),
         encoding: "utf8",
         shell: false,
@@ -1701,8 +1710,8 @@ function contentDigest(files) {
   }
   return `sha256:${hash.digest("hex")}`;
 }
-function verifyInstalledContent(project, packageName2, expected) {
-  const root = resolve4(project, "node_modules", ...packageName2.split("/"));
+function verifyInstalledContent(project2, packageName2, expected) {
+  const root = resolve4(project2, "node_modules", ...packageName2.split("/"));
   const files = skillFiles(root);
   const actual = contentDigest(files);
   return {
@@ -1888,9 +1897,9 @@ async function manage(context, sync) {
   if (!sync && !context.args.positional.length && !context.args.flags.has("all")) {
     throw new ArgumentError("select a skill package or pass --all");
   }
-  const project = projectFrom(context);
-  const install = installContext(project);
-  const inventory = readInstalledDependencies(project);
+  const project2 = projectFrom(context);
+  const install = installContext(project2);
+  const inventory = readInstalledDependencies(project2);
   const catalog = await remoteCatalog(context);
   const plan = planInstall({
     context: install,
@@ -1907,7 +1916,7 @@ async function manage(context, sync) {
     ])
   );
   const mismatched = (packages) => packages.map(
-    (name) => verifyInstalledContent(project, name, digests.get(name) ?? "")
+    (name) => verifyInstalledContent(project2, name, digests.get(name) ?? "")
   ).filter((check) => !check.matched);
   const reportMismatch = (checks) => {
     for (const check of checks) {
@@ -1919,12 +1928,12 @@ async function manage(context, sync) {
   };
   const report = {
     catalogRevision: plan.catalogRevision,
-    project,
+    project: project2,
     changes: plan.changes,
     command: plan.command
   };
   if (!context.args.flags.has("json")) {
-    context.ui.info("project", project);
+    context.ui.info("project", project2);
     for (const entry2 of plan.changes)
       context.ui.line(`  ${entry2.packageName}@${entry2.version}`);
     if (plan.changes.length)
@@ -2078,6 +2087,267 @@ var syncCommand = {
   run: (context) => manage(context, true)
 };
 
+// src/commands/project.ts
+import { homedir as homedir2 } from "os";
+
+// src/project/edit.ts
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync7,
+  rmSync as rmSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { basename, dirname as dirname3, join as join7 } from "path";
+var CROSS_TOOL = ["name", "description"];
+var tomlValue = (value) => JSON.stringify(value);
+function findEntry(entries, wanted) {
+  const exact = entries.filter((e) => e.name === wanted);
+  if (exact.length === 1 && exact[0]) return exact[0];
+  const bySlug = entries.filter(
+    (e) => e.slug === wanted || e.slug.endsWith(`/${wanted}`)
+  );
+  if (bySlug.length === 1 && bySlug[0]) return bySlug[0];
+  if (bySlug.length > 1) {
+    throw new ProjectError(
+      `${wanted} is ambiguous: ${bySlug.map((e) => e.name).join(", ")}`
+    );
+  }
+  throw new ProjectError(`no catalog skill or agent named ${wanted}`);
+}
+function addEntry(root, entry2) {
+  const kind = kindOf(entry2);
+  if (kind !== "skill" && kind !== "agent") {
+    throw new ProjectError(
+      `${entry2.name} is a ${kind}; only skills and agents are added to .agents/`
+    );
+  }
+  const { meta, body } = splitFrontmatter(readFileSync7(entry2.path, "utf8"));
+  const name = basename(entry2.slug);
+  if (!/^[a-z0-9][a-z0-9-]*$/u.test(name)) {
+    throw new ProjectError(
+      `${entry2.name}: ${name} is not a usable directory name`
+    );
+  }
+  if (kind === "skill") {
+    const dest2 = join7(root, ".agents/skills", name);
+    if (existsSync2(dest2))
+      throw new ProjectError(`.agents/skills/${name} already exists`);
+    const source = entry2.root ?? dirname3(entry2.path);
+    mkdirSync3(dirname3(dest2), { recursive: true });
+    if (statSync3(source).isDirectory()) {
+      cpSync(source, dest2, { recursive: true });
+    } else {
+      mkdirSync3(dest2);
+    }
+    const head = renderFrontmatter({
+      ...meta,
+      name,
+      description: meta["description"] ?? entry2.description
+    });
+    writeFileSync3(
+      join7(dest2, "SKILL.md"),
+      `${head}
+${body.replace(/^\n/u, "")}`
+    );
+    return { kind, name, path: `.agents/skills/${name}` };
+  }
+  const dest = join7(root, ".agents/agents", name);
+  if (existsSync2(dest))
+    throw new ProjectError(`.agents/agents/${name} already exists`);
+  const kept = {};
+  const moved = {};
+  for (const [key, value] of Object.entries({ ...meta, name })) {
+    if (CROSS_TOOL.includes(key)) kept[key] = value;
+    else moved[key] = value;
+  }
+  mkdirSync3(dest, { recursive: true });
+  writeFileSync3(
+    join7(dest, "agent.md"),
+    `${renderFrontmatter(kept)}
+${body.replace(/^\n/u, "")}`
+  );
+  if (Object.keys(moved).length > 0) {
+    const config = join7(root, "pmcp.toml");
+    const lines = [
+      `[agents.${name}.claude]`,
+      ...Object.entries(moved).map(([k, v]) => `${k} = ${tomlValue(v)}`)
+    ];
+    const before = existsSync2(config) ? readFileSync7(config, "utf8") : "";
+    const sep3 = before === "" || before.endsWith("\n\n") ? "" : "\n";
+    writeFileSync3(config, `${before}${sep3}${lines.join("\n")}
+`);
+  }
+  return { kind, name, path: `.agents/agents/${name}/agent.md` };
+}
+function withoutTables(toml, name) {
+  const own = new RegExp(
+    `^\\[(skills\\.${name}|agents\\.${name}(\\.[a-z]+)?)\\]\\s*$`,
+    "u"
+  );
+  const out = [];
+  let skipping = false;
+  for (const line of toml.split("\n")) {
+    if (/^\[/u.test(line)) skipping = own.test(line);
+    if (!skipping) out.push(line);
+  }
+  return out.join("\n").replace(/\n{3,}/gu, "\n\n");
+}
+function removeAsset(root, name) {
+  const removed = [];
+  for (const rel of [`.agents/skills/${name}`, `.agents/agents/${name}`]) {
+    if (!existsSync2(join7(root, rel))) continue;
+    rmSync3(join7(root, rel), { recursive: true, force: true });
+    removed.push(rel);
+  }
+  if (removed.length === 0)
+    throw new ProjectError(`no skill or agent named ${name} in .agents/`);
+  const config = join7(root, "pmcp.toml");
+  if (existsSync2(config)) {
+    const before = readFileSync7(config, "utf8");
+    const after = withoutTables(before, name);
+    if (after !== before) writeFileSync3(config, after);
+  }
+  return removed;
+}
+
+// src/commands/project.ts
+function specFrom(context) {
+  const config = configFrom(context);
+  if (config === null) {
+    throw new ArgumentError(
+      "no pmcp.toml at or above this directory; pass --config <file>"
+    );
+  }
+  try {
+    return readSpec(config);
+  } catch (error) {
+    throw new ArgumentError(
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function reproject(context, spec) {
+  const result = project(spec, { check: false });
+  for (const problem of result.problems) context.ui.error(problem);
+  if (result.code !== 0) return 1;
+  context.ui.success(
+    `projected ${result.outputs} outputs`,
+    result.pruned > 0 ? `pruned ${result.pruned}` : void 0
+  );
+  return 0;
+}
+var projectCommand = {
+  name: "project",
+  describe: "Write each agent tool's native files from .agents/ and pmcp.toml",
+  usage: "pmcp project [--check] | pmcp project add <skill|agent> | pmcp project remove <name>",
+  options: [
+    ...CATALOG_OPTIONS,
+    {
+      name: "check",
+      describe: "Write nothing; exit 2 when an output drifted, went stale or is undeclared.",
+      boolean: true
+    }
+  ],
+  run(context) {
+    const [verb, name, ...extra] = context.args.positional;
+    if (extra.length > 0)
+      throw new ArgumentError(`unexpected ${extra.join(" ")}`);
+    try {
+      if (verb === void 0) {
+        const spec = specFrom(context);
+        if (!context.args.flags.has("check")) return reproject(context, spec);
+        const result = project(spec, { check: true });
+        for (const problem of result.problems) context.ui.error(problem);
+        if (result.code !== 0) {
+          context.ui.info(
+            "fix",
+            "pmcp project (edit .agents/ or pmcp.toml, never the outputs)"
+          );
+          return 2;
+        }
+        context.ui.success(`${result.outputs} outputs match`);
+        return 0;
+      }
+      if (context.args.flags.has("check"))
+        throw new ArgumentError("--check takes no subcommand");
+      if (name === void 0) throw new ArgumentError(`${verb} needs a name`);
+      if (verb === "add") {
+        const spec = specFrom(context);
+        const added = addEntry(
+          spec.root,
+          findEntry(catalogFrom(context), name)
+        );
+        context.ui.success(`added ${added.kind} ${added.name}`, added.path);
+        return reproject(context, specFrom(context));
+      }
+      if (verb === "remove") {
+        const spec = specFrom(context);
+        for (const path of removeAsset(spec.root, name))
+          context.ui.success("removed", path);
+        return reproject(context, specFrom(context));
+      }
+      throw new ArgumentError(`unknown subcommand ${verb}`);
+    } catch (error) {
+      if (error instanceof ProjectError) {
+        context.ui.error(error.message);
+        return 1;
+      }
+      throw error;
+    }
+  }
+};
+var MARKS = {
+  ok: "ok",
+  fail: "FAIL",
+  skip: "skip"
+};
+var doctorCommand = {
+  name: "doctor",
+  describe: "Ask each agent tool, through its own listing commands, whether it loads this project's assets",
+  usage: "pmcp doctor [--tool <name>] [--json]",
+  options: [
+    {
+      name: "config",
+      describe: "A pmcp.toml to read instead of the nearest one.",
+      placeholder: "<file>"
+    },
+    {
+      name: "tool",
+      describe: `Check only this tool (${TOOLS.join(", ")}). Repeatable.`,
+      repeat: true,
+      placeholder: "<name>"
+    },
+    { name: "json", describe: "Emit JSON rather than a table.", boolean: true }
+  ],
+  run(context) {
+    const only = many(context.args, "tool");
+    for (const tool of only) {
+      if (!TOOLS.includes(tool))
+        throw new ArgumentError(`unknown tool ${tool}`);
+    }
+    const findings = doctor(specFrom(context), {
+      run: spawnRunner,
+      home: context.env["HOME"] ?? homedir2(),
+      ...only.length > 0 ? { only: new Set(only) } : {}
+    });
+    if (context.args.flags.has("json")) {
+      context.ui.data(`${JSON.stringify({ findings }, null, 2)}
+`);
+    } else {
+      context.ui.table(
+        findings.map((f) => [
+          `${MARKS[f.status]}  ${f.tool}`,
+          f.detail ? `${f.check} (${f.detail})` : f.check
+        ])
+      );
+    }
+    return findings.some((f) => f.status === "fail") ? 1 : 0;
+  }
+};
+
 // src/commands/index.ts
 var COMMANDS = [
   serveCommand,
@@ -2089,7 +2359,9 @@ var COMMANDS = [
   availableCommand,
   previewCommand,
   installCommand,
-  syncCommand
+  syncCommand,
+  projectCommand,
+  doctorCommand
 ];
 var PLANNED = [];
 var GLOBAL = /* @__PURE__ */ new Set(["-q", "--quiet", "--no-color", "--color"]);
@@ -2135,7 +2407,7 @@ function dispatch(argv, options = {}) {
   }
   return run(command, rest, { ui, env, cwd });
 }
-var VERSION = "0.5.1";
+var VERSION = "0.6.0";
 async function run(command, argv, context) {
   try {
     return await command.run({

package/dist/http.js

@@ -1,7 +1,7 @@
 import {
   createSkillServer,
   readCatalog
-} from "./chunk-76UKXVUE.js";
+} from "./chunk-5TX2IAVD.js";
 
 // src/http.ts
 import {

package/dist/index.d.ts

@@ -99,6 +99,131 @@ declare function findConfig(start: string): string | null;
  */
 declare function readConfig(path: string): ProjectConfig;
 
+/** What the projector writes. A path is unique across a plan and is the lock key. */
+type Output = {
+    readonly kind: "link";
+    readonly path: string;
+    readonly target: string;
+} | {
+    readonly kind: "file";
+    readonly path: string;
+    readonly content: string;
+}
+/** One key inside a JSON file other content shares. path = file#a.b */
+ | {
+    readonly kind: "json";
+    readonly path: string;
+    readonly file: string;
+    readonly key: readonly string[];
+    readonly value: unknown;
+}
+/** A marked block inside a text file other content shares. path = file#pmcp */
+ | {
+    readonly kind: "block";
+    readonly path: string;
+    readonly file: string;
+    readonly content: string;
+};
+
+/**
+ * The projector's reading of pmcp.toml: which tools to write for, and the
+ * per-asset settings that do not belong in the cross-tool sources under .agents/.
+ */
+
+declare const TOOLS: readonly ["claude", "codex", "gemini", "grok", "antigravity"];
+type Tool = (typeof TOOLS)[number];
+type Invocation = "any" | "user";
+interface PackageRulesSpec {
+    /** Path of the rule file inside each package, e.g. `.agent/rules/PACKAGE.RULE.md`. */
+    readonly file: string;
+    /** Subdirectory of `.claude/rules` the links go in. */
+    readonly dir: string;
+    /** Leading path segments dropped when a link name is derived. */
+    readonly strip: readonly string[];
+}
+interface McpServerSpec {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+    /** Tools the server should expose where a host can narrow them. */
+    readonly tools?: readonly string[];
+}
+interface ProjectSpec {
+    readonly root: string;
+    readonly tools: ReadonlySet<Tool>;
+    readonly skills: Readonly<Record<string, {
+        invocation: Invocation;
+    }>>;
+    readonly agents: Readonly<Record<string, Partial<Record<Tool, Record<string, unknown>>>>>;
+    readonly packageRules: PackageRulesSpec | null;
+    readonly mcp: Readonly<Record<string, McpServerSpec>>;
+}
+declare function readSpec(config: ProjectConfig): ProjectSpec;
+
+/**
+ * Every output the sources imply, read from disk but written nowhere. Sources:
+ * .agents/skills, .agents/agents, .agents/rules, package rule files, and pmcp.toml.
+ */
+
+declare function plan(spec: ProjectSpec, owned?: ReadonlyMap<string, string>): Output[];
+
+/**
+ * Writes or checks a plan. The lock (pmcp.lock) records what this wrote, so a
+ * source removed later takes its outputs with it, and a file someone else wrote
+ * is never overwritten.
+ */
+
+declare const LOCK_FILE = "pmcp.lock";
+interface ProjectResult {
+    /** 0 done or clean, 2 check found problems, 3 refused to overwrite. */
+    readonly code: 0 | 2 | 3;
+    readonly problems: readonly string[];
+    readonly outputs: number;
+    readonly pruned: number;
+}
+/** paths: globs whose fixed prefix holds no tracked file: a rule that loads nowhere. */
+declare function deadGlobs(root: string, outputs: readonly Output[]): string[];
+declare function project(spec: ProjectSpec, options: {
+    readonly check: boolean;
+}): ProjectResult;
+
+/**
+ * Asks each tool what it loads, through its own listing commands only: no
+ * model is called. A tool whose CLI is not installed is skipped, not failed.
+ */
+
+interface RunResult {
+    /** The executable was not found. */
+    readonly missing: boolean;
+    readonly status: number | null;
+    readonly stdout: string;
+}
+type Runner = (command: string, args: readonly string[], cwd: string) => RunResult;
+type Status = "ok" | "fail" | "skip";
+interface Finding {
+    readonly tool: Tool | "project";
+    readonly check: string;
+    readonly status: Status;
+    readonly detail?: string;
+}
+interface DoctorOptions {
+    readonly run: Runner;
+    readonly home: string;
+    readonly only?: ReadonlySet<Tool>;
+}
+declare function doctor(spec: ProjectSpec, options: DoctorOptions): Finding[];
+
+/**
+ * Links each package's path-scoped rule file into .claude/rules/<dir>/. One level
+ * down because Grok Build loads every top-level .claude/rules/*.md unscoped.
+ * Names already in use are kept, so moving the links renames nothing.
+ */
+
+declare class ProjectError extends Error {
+    constructor(message: string);
+}
+declare function deriveName(dir: string, strip: readonly string[]): string;
+
 /**
  * The five tools, spoken over MCP.
  *
@@ -156,4 +281,4 @@ declare function extensionEntry(entry: SkillEntry): SkillExtensionEntry | null;
  */
 declare function registerSkillsExtension(server: McpServer, skills: () => readonly SkillEntry[]): void;
 
-export { CONFIG_FILE, type CatalogSection, ConfigError, DEFAULT_INTENT_CACHE_LIMIT, IntentCache, type IntentCacheOptions, type MetadataValue, type ProjectConfig, type Rejection, SERVER_NAME, SKILLS_EXTENSION, SkillEntry, type SkillExtensionEntry, type SkillResource, SkillServerOptions, SkillTools, assetRoot, createSkillServer, extensionEntry, findConfig, openIntentCache, readConfig, readFrontmatterText, readMarketplace, readMetadata, registerSkillTools, registerSkillsExtension, skillUri };
+export { CONFIG_FILE, type CatalogSection, ConfigError, DEFAULT_INTENT_CACHE_LIMIT, type Finding, IntentCache, type IntentCacheOptions, LOCK_FILE, type McpServerSpec, type MetadataValue, type Output, type PackageRulesSpec, type ProjectConfig, ProjectError, type ProjectResult, type ProjectSpec, type Rejection, type Runner, SERVER_NAME, SKILLS_EXTENSION, SkillEntry, type SkillExtensionEntry, type SkillResource, SkillServerOptions, SkillTools, TOOLS, type Tool, assetRoot, createSkillServer, deadGlobs, deriveName, doctor, extensionEntry, findConfig, openIntentCache, plan, project, readConfig, readFrontmatterText, readMarketplace, readMetadata, readSpec, registerSkillTools, registerSkillsExtension, skillUri };

package/dist/index.js

@@ -2,10 +2,19 @@ import {
   CONFIG_FILE,
   ConfigError,
   DEFAULT_INTENT_CACHE_LIMIT,
+  LOCK_FILE,
+  ProjectError,
+  TOOLS,
+  deadGlobs,
+  deriveName,
+  doctor,
   findConfig,
   openIntentCache,
-  readConfig
-} from "./chunk-XTLANVRL.js";
+  plan,
+  project,
+  readConfig,
+  readSpec
+} from "./chunk-6TSHDCUY.js";
 import {
   ASSET_KINDS,
   CATALOG_PAGE_MAX,
@@ -37,7 +46,7 @@ import {
   registerSkillsExtension,
   skillUri,
   withoutBody
-} from "./chunk-76UKXVUE.js";
+} from "./chunk-5TX2IAVD.js";
 export {
   ASSET_KINDS,
   CATALOG_PAGE_MAX,
@@ -47,16 +56,22 @@ export {
   DEFAULT_FIND_LIMIT,
   DEFAULT_INTENT_CACHE_LIMIT,
   DESCRIBE_FILE_LIMIT,
+  LOCK_FILE,
   MAX_SKILL_DEPTH,
+  ProjectError,
   READ_BUDGET_BYTES,
   SERVER_NAME,
   SKILLS_EXTENSION,
   SKIPPED_DIRS,
+  TOOLS,
   assetRoot,
   cosine,
   createSkillServer,
   createSkillTools,
+  deadGlobs,
+  deriveName,
   displayPath,
+  doctor,
   extensionEntry,
   find,
   findConfig,
@@ -64,6 +79,8 @@ export {
   lexicalScore,
   normaliseIntent,
   openIntentCache,
+  plan,
+  project,
   readBody,
   readCatalog,
   readConfig,
@@ -71,6 +88,7 @@ export {
   readFrontmatterText,
   readMarketplace,
   readMetadata,
+  readSpec,
   registerSkillTools,
   registerSkillsExtension,
   skillUri,

package/dist/stdio.js

@@ -3,8 +3,8 @@ import {
   main,
   resolveRoots,
   serve
-} from "./chunk-ICHBC5FM.js";
-import "./chunk-76UKXVUE.js";
+} from "./chunk-FXBLBKP6.js";
+import "./chunk-5TX2IAVD.js";
 export {
   main,
   resolveRoots,