@modootoday/pmcp 0.7.0 → 0.8.0

package/dist/{chunk-QHFORYIN.js → chunk-ZDV75HZN.js}

@@ -3,6 +3,109 @@ function normaliseIntent(intent) {
   return intent.toLowerCase().replaceAll(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/u).filter(Boolean).join(" ");
 }
 
+// src/frontmatter.ts
+import { parse } from "yaml";
+function frontmatterText(source) {
+  const text = source.replace(/^/u, "").replace(/\r\n/gu, "\n");
+  if (!text.startsWith("---\n") && text !== "---") return null;
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) return null;
+  return text.slice(4, end + 1);
+}
+function bodyOf(source) {
+  const text = source.replace(/^/u, "").replace(/\r\n/gu, "\n");
+  if (!text.startsWith("---\n")) return text;
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) return text;
+  return text.slice(end + 4).replace(/^\n+/u, "");
+}
+var asObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+function frontmatterObject(source) {
+  const text = frontmatterText(source);
+  if (text === null) return null;
+  try {
+    return asObject(parse(text));
+  } catch {
+    const quoted = text.split("\n").map((line) => {
+      const match = /^([A-Za-z][\w-]*):\s+(.*:\s.*)$/u.exec(line);
+      if (!match || /^["'|>[{]/u.test(match[2] ?? "")) return line;
+      return `${match[1]}: ${JSON.stringify(match[2])}`;
+    }).join("\n");
+    try {
+      return asObject(parse(quoted));
+    } catch {
+      return null;
+    }
+  }
+}
+function stringFields(front) {
+  const out = {};
+  for (const [key, value] of Object.entries(front ?? {})) {
+    if (typeof value === "string") out[key] = value.trim();
+    else if (typeof value === "number" || typeof value === "boolean")
+      out[key] = String(value);
+  }
+  return out;
+}
+function metadataOf(front) {
+  const out = {};
+  const meta = asObject(front?.["metadata"]);
+  for (const [key, value] of Object.entries(meta ?? {})) {
+    if (typeof value === "string") out[key] = value;
+    else if (typeof value === "number" || typeof value === "boolean")
+      out[key] = String(value);
+    else if (Array.isArray(value))
+      out[key] = value.filter((v) => typeof v === "string");
+  }
+  return out;
+}
+var SKILL_NAME = /^[a-z0-9](?:[a-z0-9]|-(?!-))*[a-z0-9]$|^[a-z0-9]$/u;
+var NAME_MAX = 64;
+var DESCRIPTION_MAX = 1024;
+var COMPATIBILITY_MAX = 500;
+function specProblems(front, directory) {
+  if (front === null) return ["frontmatter is missing or is not YAML"];
+  const problems = [];
+  const name = front["name"];
+  if (typeof name !== "string" || name === "") {
+    problems.push("name is required");
+  } else {
+    if (name.length > NAME_MAX)
+      problems.push(`name is longer than ${NAME_MAX} characters`);
+    if (!SKILL_NAME.test(name))
+      problems.push(
+        "name must be lowercase letters, digits and single hyphens, not starting or ending with one"
+      );
+    if (name !== directory)
+      problems.push(`name ${name} does not match its directory ${directory}`);
+  }
+  const description = front["description"];
+  if (typeof description !== "string" || description.trim() === "") {
+    problems.push("description is required");
+  } else if (description.length > DESCRIPTION_MAX) {
+    problems.push(`description is longer than ${DESCRIPTION_MAX} characters`);
+  }
+  const compatibility = front["compatibility"];
+  if (compatibility !== void 0) {
+    if (typeof compatibility !== "string")
+      problems.push("compatibility must be a string");
+    else if (compatibility.length > COMPATIBILITY_MAX)
+      problems.push(
+        `compatibility is longer than ${COMPATIBILITY_MAX} characters`
+      );
+  }
+  const license = front["license"];
+  if (license !== void 0 && typeof license !== "string")
+    problems.push("license must be a string");
+  const allowed = front["allowed-tools"];
+  if (allowed !== void 0 && typeof allowed !== "string")
+    problems.push("allowed-tools must be a space-separated string");
+  const metadata = front["metadata"];
+  if (metadata !== void 0 && asObject(metadata) === null)
+    problems.push("metadata must be a map");
+  return problems;
+}
+
 // src/marketplace.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
 import { basename as basename2, dirname as dirname2, join as join2, resolve } from "path";
@@ -23,24 +126,10 @@ var SKIPPED_DIRS = /* @__PURE__ */ new Set([
 ]);
 var MAX_SKILL_DEPTH = 3;
 function readFrontmatter(source) {
-  if (!source.startsWith("---")) return {};
-  const end = source.indexOf("\n---", 3);
-  if (end === -1) return {};
-  const fields = {};
-  for (const line of source.slice(3, end).split("\n")) {
-    const match = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/u.exec(line);
-    if (!match) continue;
-    const value = (match[2] ?? "").trim();
-    if (value === "" || value.startsWith("#")) continue;
-    fields[match[1]] = value.replace(/^["'](.*)["']$/u, "$1");
-  }
-  return fields;
+  return stringFields(frontmatterObject(source));
 }
 function readBody(source) {
-  if (!source.startsWith("---")) return source;
-  const end = source.indexOf("\n---", 3);
-  if (end === -1) return source;
-  return source.slice(end + 4).replace(/^(?:\r?\n)+/u, "");
+  return bodyOf(source);
 }
 function skillFiles(packageDir) {
   const found = [];
@@ -98,8 +187,8 @@ function readManifest(dir) {
     return null;
   }
 }
-function workspacePatterns(manifest) {
-  const field = manifest["workspaces"];
+function workspacePatterns(manifest2) {
+  const field = manifest2["workspaces"];
   const list = Array.isArray(field) ? field : field?.packages;
   if (!Array.isArray(list)) return [];
   return list.filter((p) => typeof p === "string");
@@ -155,11 +244,11 @@ function workspacePackageDirs(root) {
   const expand = (dir) => {
     if (visited.has(dir)) return;
     visited.add(dir);
-    const manifest = readManifest(dir);
-    if (manifest === null) return;
+    const manifest2 = readManifest(dir);
+    if (manifest2 === null) return;
     const included = /* @__PURE__ */ new Set();
     const excluded = /* @__PURE__ */ new Set();
-    for (const raw of workspacePatterns(manifest)) {
+    for (const raw of workspacePatterns(manifest2)) {
       const negated = raw.startsWith("!");
       const pattern = negated ? raw.slice(1) : raw;
       for (const alternative of expandBraces(pattern)) {
@@ -215,20 +304,32 @@ function readCatalog(options) {
       } catch {
         continue;
       }
-      const front = readFrontmatter(source);
+      const parsed = frontmatterObject(source);
+      const front = stringFields(parsed);
       const description = front["description"] ?? "";
       if (description === "") continue;
       const dirName = basename(dirname(path));
       const slug = front["name"] ?? (dirName === basename(packageDir) ? packageName : dirName);
       const name = `${packageName}/${slug}`;
-      if (seen.has(name)) continue;
+      if (seen.has(name)) {
+        if (!path.includes("/node_modules/"))
+          options.onWarning?.({
+            path,
+            reason: `duplicate name ${name}; the first one found is served`
+          });
+        continue;
+      }
       seen.add(name);
+      for (const problem of specProblems(parsed, dirName))
+        options.onWarning?.({ path, reason: problem });
+      const metadata = metadataOf(parsed);
       found.push({
         name,
         package: packageName,
         slug,
         description,
-        path
+        path,
+        ...Object.keys(metadata).length > 0 ? { metadata } : {}
       });
     }
   }
@@ -242,6 +343,14 @@ function readCatalog(options) {
         continue;
       }
       seen.add(entry.name);
+      if (kindOf(entry) === "skill" && basename(entry.path) === "SKILL.md") {
+        const parsed = frontmatterObject(readFileSync(entry.path, "utf8"));
+        for (const problem of specProblems(
+          parsed,
+          basename(dirname(entry.path))
+        ))
+          options.onWarning?.({ path: entry.path, reason: problem });
+      }
       found.push(entry);
     }
   }
@@ -259,38 +368,11 @@ function displayPath(root, entry) {
 }
 
 // src/marketplace.ts
-function parseScalar(raw) {
-  const value = raw.trim();
-  if (value.startsWith("[") && value.endsWith("]")) {
-    return value.slice(1, -1).split(",").map((item) => item.trim().replace(/^["'](.*)["']$/u, "$1")).filter(Boolean);
-  }
-  return value.replace(/^["'](.*)["']$/u, "$1");
-}
 function readMetadata(source) {
-  if (!source.startsWith("---")) return {};
-  const end = source.indexOf("\n---", 3);
-  if (end === -1) return {};
-  const out = {};
-  let inside = false;
-  for (const line of source.slice(3, end).split("\n")) {
-    if (/^metadata:\s*$/u.test(line)) {
-      inside = true;
-      continue;
-    }
-    if (!inside) continue;
-    if (!/^\s/u.test(line)) break;
-    const match = /^ {2}([A-Za-z][A-Za-z0-9_.-]*):\s*(.*)$/u.exec(line);
-    if (!match) continue;
-    const raw = match[2] ?? "";
-    if (raw.trim() === "" || raw.trim().startsWith("#")) continue;
-    out[match[1]] = parseScalar(raw);
-  }
-  return out;
+  return metadataOf(frontmatterObject(source));
 }
 function readFrontmatterText(source) {
-  if (!source.startsWith("---")) return "";
-  const end = source.indexOf("\n---", 3);
-  return end === -1 ? "" : source.slice(3, end).replace(/^\r?\n/u, "");
+  return frontmatterText(source) ?? "";
 }
 var asString = (value) => typeof value === "string" ? value : void 0;
 var asList = (value) => {
@@ -392,8 +474,8 @@ function agentEntries(context) {
   }
   return found;
 }
-function hookEntries(context, manifest) {
-  const declared = typeof manifest.hooks === "string" ? manifest.hooks : void 0;
+function hookEntries(context, manifest2) {
+  const declared = typeof manifest2.hooks === "string" ? manifest2.hooks : void 0;
   const path = resolve(context.pluginDir, declared ?? "hooks/hooks.json");
   if (!existsSync2(path)) return [];
   const hooks = readJson(path);
@@ -451,9 +533,9 @@ function readMarketplace(dir, onReject) {
     });
     return [];
   }
-  let manifest;
+  let manifest2;
   try {
-    manifest = JSON.parse(
+    manifest2 = JSON.parse(
       readFileSync2(manifestPath, "utf8")
     );
   } catch {
@@ -463,9 +545,9 @@ function readMarketplace(dir, onReject) {
     });
     return [];
   }
-  const marketplace = manifest.name ?? "marketplace";
+  const marketplace = manifest2.name ?? "marketplace";
   const found = [];
-  for (const plugin of manifest.plugins ?? []) {
+  for (const plugin of manifest2.plugins ?? []) {
     if (!plugin.name || !plugin.source) continue;
     const pluginDir = resolve(dir, plugin.source);
     if (!existsSync2(pluginDir)) continue;
@@ -477,7 +559,7 @@ function readMarketplace(dir, onReject) {
       plugin: plugin.name,
       pluginDir,
       pluginDescription: typeof pluginManifest.description === "string" ? pluginManifest.description : void 0,
-      tier: manifest.metadata?.tier,
+      tier: manifest2.metadata?.tier,
       onReject
     };
     found.push(
@@ -492,6 +574,316 @@ function readMarketplace(dir, onReject) {
 }
 var assetRoot = (entry) => entry.root ?? dirname2(entry.path);
 
+// src/prompts.ts
+import { z } from "zod";
+var promptName = (entry) => entry.name.replace(/^@/u, "").replace(/[^A-Za-z0-9_-]+/gu, "-");
+function messageText(tools, name, task) {
+  const found = tools.call(name);
+  if (!found) return `The skill ${name} is no longer in this catalog.`;
+  const files = found.files.map((file) => `- ${file.path}`);
+  const parts = [found.body];
+  if (files.length > 0)
+    parts.push(
+      `Files in skill ${found.name} (skill_read returns each by path):
+${files.join("\n")}`
+    );
+  if (task) parts.push(`Task: ${task}`);
+  return parts.join("\n\n");
+}
+function registerSkillPrompts(server, tools) {
+  const taken = /* @__PURE__ */ new Set();
+  for (const entry of tools.skills()) {
+    if (kindOf(entry) !== "skill") continue;
+    const name = promptName(entry);
+    if (taken.has(name)) continue;
+    taken.add(name);
+    server.registerPrompt(
+      name,
+      {
+        title: entry.name,
+        description: entry.description,
+        argsSchema: z.object({
+          task: z.string().optional().describe("What to apply the skill to.")
+        })
+      },
+      ({ task }) => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: messageText(tools, entry.name, task)
+            }
+          }
+        ]
+      })
+    );
+  }
+}
+
+// src/files/list.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync3, readdirSync as readdirSync3, statSync } from "fs";
+import { basename as basename3, join as join3, relative as relative2, sep } from "path";
+var FILE_LIST_LIMIT = 200;
+var sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function describe(path, full) {
+  const bytes = readFileSync3(full);
+  return { path, bytes: bytes.length, sha256: sha256(bytes) };
+}
+function listSkillFiles(root, limit = FILE_LIST_LIMIT) {
+  if (statSync(root).isFile()) {
+    return { files: [describe(basename3(root), root)], truncated: false };
+  }
+  const files = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      const full = join3(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(relative2(root, full).split(sep).join("/"), full));
+    }
+  }
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return { files, truncated: false };
+}
+
+// src/mime.ts
+var TYPES = {
+  ".md": "text/markdown",
+  ".markdown": "text/markdown",
+  ".txt": "text/plain",
+  ".json": "application/json",
+  ".jsonl": "application/jsonl",
+  ".yaml": "text/yaml",
+  ".yml": "text/yaml",
+  ".toml": "application/toml",
+  ".csv": "text/csv",
+  ".tsv": "text/tab-separated-values",
+  ".xml": "application/xml",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".cjs": "text/javascript",
+  ".jsx": "text/javascript",
+  ".ts": "text/typescript",
+  ".tsx": "text/typescript",
+  ".mts": "text/typescript",
+  ".cts": "text/typescript",
+  ".py": "text/x-python",
+  ".rb": "text/x-ruby",
+  ".go": "text/x-go",
+  ".rs": "text/x-rust",
+  ".java": "text/x-java",
+  ".sh": "text/x-shellscript",
+  ".bash": "text/x-shellscript",
+  ".zsh": "text/x-shellscript",
+  ".ps1": "text/x-powershell",
+  ".sql": "application/sql",
+  ".ejs": "text/x-ejs",
+  ".hbs": "text/x-handlebars-template",
+  ".mustache": "text/x-mustache",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".bmp": "image/bmp",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".flac": "audio/flac",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tar": "application/x-tar",
+  ".wasm": "application/wasm",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
+var TEXT_APPLICATION = /* @__PURE__ */ new Set([
+  "application/json",
+  "application/jsonl",
+  "application/toml",
+  "application/xml",
+  "application/sql",
+  "image/svg+xml"
+]);
+function mimeOf(path) {
+  const slash = path.lastIndexOf("/");
+  const dot = path.lastIndexOf(".");
+  if (dot === -1 || dot < slash) return null;
+  return TYPES[path.slice(dot).toLowerCase()] ?? null;
+}
+function isUtf8Text(bytes) {
+  if (bytes.includes(0)) return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function classify(path, bytes) {
+  const declared = mimeOf(path);
+  const textual = declared === null ? isUtf8Text(bytes) : declared.startsWith("text/") || TEXT_APPLICATION.has(declared);
+  if (textual && isUtf8Text(bytes)) {
+    return { kind: "text", mimeType: declared ?? "text/plain" };
+  }
+  if (declared?.startsWith("image/") && declared !== "image/svg+xml") {
+    return { kind: "image", mimeType: declared };
+  }
+  if (declared?.startsWith("audio/"))
+    return { kind: "audio", mimeType: declared };
+  return { kind: "blob", mimeType: declared ?? "application/octet-stream" };
+}
+
+// src/files/read.ts
+import { readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+
+// src/files/resolve.ts
+import { realpathSync, statSync as statSync2 } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute2, relative as relative3, resolve as resolve2, sep as sep2 } from "path";
+var ownFile = (entry) => relative3(assetRoot(entry), entry.path).split(sep2).join("/");
+function resolveSkillFile(entry, wanted = ownFile(entry)) {
+  if (isAbsolute2(wanted) || wanted.split(/[\\/]/u).includes("..")) {
+    return { ok: false, error: "path_outside_skill", detail: wanted };
+  }
+  const scope = realpathSync(assetRoot(entry));
+  const single = statSync2(scope).isFile();
+  const root = single ? dirname3(scope) : scope;
+  let target;
+  try {
+    target = realpathSync(
+      single && wanted === "" ? scope : resolve2(root, wanted)
+    );
+  } catch {
+    return { ok: false, error: "no_such_file", detail: wanted };
+  }
+  const inside = single ? target === scope : target === root || target.startsWith(root + sep2);
+  if (!inside)
+    return { ok: false, error: "path_outside_skill", detail: wanted };
+  return {
+    ok: true,
+    target,
+    path: relative3(root, target).split(sep2).join("/")
+  };
+}
+
+// src/files/read.ts
+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 = statSync3(resolved.target).size;
+  if (size > budget) {
+    return {
+      ok: false,
+      error: "over_budget",
+      detail: `${size} bytes > ${budget}`
+    };
+  }
+  const bytes = readFileSync4(resolved.target);
+  const { kind: kind2, mimeType } = classify(resolved.path, bytes);
+  return {
+    ok: true,
+    name: entry.name,
+    path: resolved.path,
+    bytes: bytes.length,
+    sha256: sha256(bytes),
+    mimeType,
+    kind: kind2,
+    ...kind2 === "text" ? { text: bytes.toString("utf8") } : { blob: bytes.toString("base64") }
+  };
+}
+
+// src/files/uri.ts
+var SKILL_URI_AUTHORITY = "pmcp";
+var PREFIX = `skill://${SKILL_URI_AUTHORITY}/`;
+var skillFileUri = (entry, file = "SKILL.md") => `${PREFIX}${entry.name}/${file}`;
+function resolveSkillFileUri(uri, entries) {
+  if (!uri.startsWith(PREFIX)) return null;
+  const rest = decodeURI(uri.slice(PREFIX.length));
+  let best = null;
+  for (const entry of entries) {
+    if (!rest.startsWith(`${entry.name}/`)) continue;
+    if (best === null || entry.name.length > best.name.length) best = entry;
+  }
+  if (best === null) return null;
+  const file = rest.slice(best.name.length + 1);
+  return file === "" ? null : { entry: best, file };
+}
+
+// src/resources.ts
+import { statSync as statSync4 } from "fs";
+import {
+  ResourceNotFoundError,
+  ResourceTemplate
+} from "@modelcontextprotocol/server";
+var RESOURCE_READ_BUDGET = 16 * 1024 * 1024;
+var COMPLETION_LIMIT = 100;
+function listing(entries) {
+  return entries.filter((entry) => kindOf(entry) === "skill").map((entry) => ({
+    uri: skillFileUri(entry, ownFile(entry)),
+    name: entry.name,
+    description: entry.description,
+    mimeType: "text/markdown",
+    size: statSync4(entry.path).size
+  }));
+}
+function complete(value, entries) {
+  const owner = entries.find((entry) => value.startsWith(`${entry.name}/`));
+  if (!owner) {
+    return entries.map((entry) => `${entry.name}/`).filter((name) => name.startsWith(value)).slice(0, COMPLETION_LIMIT);
+  }
+  return listSkillFiles(assetRoot(owner)).files.map((file) => `${owner.name}/${file.path}`).filter((path) => path.startsWith(value)).slice(0, COMPLETION_LIMIT);
+}
+function registerSkillResources(server, skills) {
+  server.registerResource(
+    "skill-files",
+    new ResourceTemplate(`skill://${SKILL_URI_AUTHORITY}/{+path}`, {
+      list: () => ({ resources: listing(skills()) }),
+      complete: { path: (value) => complete(value, skills()) }
+    }),
+    {
+      title: "Skill files",
+      description: "Files of the skills this catalog serves: SKILL.md, references, scripts and assets."
+    },
+    async (uri) => {
+      const href = uri.toString();
+      const found = resolveSkillFileUri(href, skills());
+      if (!found) throw new ResourceNotFoundError(href);
+      const file = readSkillFile(found.entry, found.file, RESOURCE_READ_BUDGET);
+      if (!file.ok) throw new ResourceNotFoundError(href);
+      return {
+        contents: [
+          file.kind === "text" ? { uri: href, mimeType: file.mimeType, text: file.text ?? "" } : { uri: href, mimeType: file.mimeType, blob: file.blob ?? "" }
+        ]
+      };
+    }
+  );
+}
+
 // src/find.ts
 var DEFAULT_FIND_LIMIT = 5;
 function tokens(text) {
@@ -575,25 +967,32 @@ function rank(matches2, limit) {
   return matches2.filter((match) => match.score > 0).sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, limit);
 }
 
+// src/files/bundle.ts
+import { readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+function bundleSkill(entry) {
+  const root = assetRoot(entry);
+  const base = statSync5(root).isFile() ? dirname4(root) : root;
+  const listing2 = listSkillFiles(root);
+  return {
+    name: entry.name,
+    truncated: listing2.truncated,
+    files: listing2.files.map((file) => ({
+      ...file,
+      uri: skillFileUri(entry, file.path),
+      mimeType: classify(file.path, readFileSync5(join4(base, file.path))).mimeType
+    }))
+  };
+}
+
 // src/server.ts
-import { createHash } from "crypto";
-import { readFileSync as readFileSync3, readdirSync as readdirSync3, realpathSync, statSync } from "fs";
-import {
-  basename as basename3,
-  dirname as dirname3,
-  isAbsolute as isAbsolute2,
-  join as join3,
-  relative as relative2,
-  resolve as resolve2,
-  sep
-} from "path";
-var READ_BUDGET_BYTES = 256 * 1024;
-var DESCRIBE_FILE_LIMIT = 200;
+import { readFileSync as readFileSync6 } from "fs";
+var DESCRIBE_FILE_LIMIT = FILE_LIST_LIMIT;
 var CATALOG_PAGE_SIZE = 8;
 var CATALOG_PAGE_MAX = 20;
 function matches(entry, filters) {
-  const kind = filters?.kind ?? "skill";
-  if (kind !== "any" && kindOf(entry) !== kind) return false;
+  const kind2 = filters?.kind ?? "skill";
+  if (kind2 !== "any" && kindOf(entry) !== kind2) return false;
   if (!filters) return true;
   const meta = entry.metadata ?? {};
   const field = (key) => {
@@ -611,42 +1010,6 @@ function matches(entry, filters) {
     return false;
   return true;
 }
-var sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
-function listFiles(root) {
-  const files = [];
-  if (statSync(root).isFile()) {
-    const bytes = readFileSync3(root);
-    const only = {
-      path: basename3(root),
-      bytes: bytes.length,
-      sha256: sha256(bytes)
-    };
-    return { files: [only], truncated: false };
-  }
-  const stack = [root];
-  while (stack.length > 0) {
-    const dir = stack.pop();
-    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join3(dir, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(full);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      if (files.length >= DESCRIBE_FILE_LIMIT)
-        return { files, truncated: true };
-      const bytes = readFileSync3(full);
-      files.push({
-        path: relative2(root, full).split(sep).join("/"),
-        bytes: bytes.length,
-        sha256: sha256(bytes)
-      });
-    }
-  }
-  files.sort((a, b) => a.path.localeCompare(b.path));
-  return { files, truncated: false };
-}
 function catalogItem(entry) {
   return {
     name: entry.name,
@@ -665,10 +1028,12 @@ function createSkillTools(options) {
       marketplaces: options.marketplaces,
       packages: options.packages,
       workspaces: options.workspaces,
-      onReject: options.onReject
+      onReject: options.onReject,
+      onWarning: options.onWarning
     });
     return entries;
   };
+  const byName = (name) => catalog().find((candidate) => candidate.name === name) ?? null;
   return {
     /**
      * Grouped, and without bodies. The cheap overview and the search's miss
@@ -693,13 +1058,13 @@ function createSkillTools(options) {
         CATALOG_PAGE_MAX
       );
       const totalPages = Math.max(1, Math.ceil(groups.length / size));
-      const page = Math.min(Math.max(request.page ?? 1, 1), totalPages);
+      const page2 = Math.min(Math.max(request.page ?? 1, 1), totalPages);
       return {
         count,
-        page,
+        page: page2,
         totalPages,
-        hasNext: page < totalPages,
-        packages: groups.slice((page - 1) * size, page * size).map(([pkg, skills]) => ({ package: pkg, skills }))
+        hasNext: page2 < totalPages,
+        packages: groups.slice((page2 - 1) * size, page2 * size).map(([pkg, skills]) => ({ package: pkg, skills }))
       };
     },
     /** Ranked names. Returns; never loads a body. */
@@ -727,20 +1092,20 @@ function createSkillTools(options) {
     },
     /** Every property of one skill and the files it carries, without bodies. */
     describe(name) {
-      const entry = catalog().find((candidate) => candidate.name === name);
+      const entry = byName(name);
       if (!entry) return null;
-      const source = readFileSync3(entry.path, "utf8");
-      const listing = listFiles(assetRoot(entry));
+      const source = readFileSync6(entry.path, "utf8");
+      const listing2 = listSkillFiles(assetRoot(entry));
       return {
         name: entry.name,
         kind: kindOf(entry),
         package: entry.package,
         description: entry.description,
-        tier: entry.tier,
+        ...entry.tier === void 0 ? {} : { tier: entry.tier },
         metadata: entry.metadata ?? {},
         frontmatter: readFrontmatterText(source),
-        files: listing.files,
-        filesTruncated: listing.truncated
+        files: [...listing2.files],
+        filesTruncated: listing2.truncated
       };
     },
     /**
@@ -748,54 +1113,30 @@ function createSkillTools(options) {
      * directly or through a link, are refused; nothing is ever executed.
      */
     read(name, path) {
-      const entry = catalog().find((candidate) => candidate.name === name);
+      const entry = byName(name);
       if (!entry) return { ok: false, error: "unknown_skill", detail: name };
-      const wanted = path ?? relative2(assetRoot(entry), entry.path);
-      if (isAbsolute2(wanted) || wanted.split(/[\\/]/u).includes("..")) {
-        return { ok: false, error: "path_outside_skill", detail: wanted };
-      }
-      const scope = realpathSync(assetRoot(entry));
-      const single = statSync(scope).isFile();
-      const root = single ? dirname3(scope) : scope;
-      let target;
-      try {
-        target = realpathSync(
-          single && wanted === "" ? scope : resolve2(root, wanted)
-        );
-      } catch {
-        return { ok: false, error: "no_such_file", detail: wanted };
-      }
-      const inside = single ? target === scope : target === root || target.startsWith(root + sep);
-      if (!inside) {
-        return { ok: false, error: "path_outside_skill", detail: wanted };
-      }
-      const size = statSync(target).size;
-      if (size > READ_BUDGET_BYTES) {
-        return {
-          ok: false,
-          error: "over_budget",
-          detail: `${size} bytes > ${READ_BUDGET_BYTES}`
-        };
-      }
-      const bytes = readFileSync3(target);
-      return {
-        ok: true,
-        name: entry.name,
-        path: relative2(root, target).split(sep).join("/"),
-        bytes: bytes.length,
-        sha256: sha256(bytes),
-        text: bytes.toString("utf8")
-      };
+      return readSkillFile(entry, path);
+    },
+    /** Every file of one skill as links; the bytes stay out of the answer. */
+    bundle(name) {
+      const entry = byName(name);
+      return entry ? bundleSkill(entry) : null;
     },
-    /** One body, at the moment it is needed. */
+    /** One body, at the moment it is needed, and the other files it carries. */
     call(name) {
-      const entry = catalog().find((candidate) => candidate.name === name);
+      const entry = byName(name);
       if (!entry) return null;
+      const bundle = bundleSkill(entry);
+      const own = ownFile(entry);
       return {
         name: entry.name,
-        body: readBody(readFileSync3(entry.path, "utf8"))
+        body: readBody(readFileSync6(entry.path, "utf8")),
+        files: bundle.files.filter((file) => file.path !== own),
+        filesTruncated: bundle.truncated
       };
     },
+    /** The catalog entry for a name, among those this caller may see. */
+    entry: (name) => byName(name),
     /** Drops the memoised catalog, so the next call re-reads the tree. */
     refresh() {
       entries = null;
@@ -806,32 +1147,19 @@ function createSkillTools(options) {
   };
 }
 
-// src/skills-extension.ts
+// src/extension/entry.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync4, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { basename as basename4, dirname as dirname4, join as join4, relative as relative3, sep as sep2 } from "path";
-import {
-  ProtocolError,
-  ProtocolErrorCode,
-  ResourceNotFoundError,
-  ResourceTemplate
-} from "@modelcontextprotocol/server";
-import { parse as parseYaml } from "yaml";
-import { z } from "zod";
-var SKILLS_EXTENSION = "io.modelcontextprotocol/skills";
-var AUTHORITY = "pmcp";
-var SKILL_NAME = /^[a-z0-9](?:[a-z0-9]|-(?!-))*[a-z0-9]$|^[a-z0-9]$/u;
+import { readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync6 } from "fs";
+import { basename as basename4, dirname as dirname5, join as join5, relative as relative4, sep as sep3 } from "path";
 var MAX_RESOURCES = 512;
 var MAX_SKILL_BYTES = 16 * 1024 * 1024;
-var PAGE_SIZE = 50;
-var LIST_TTL_MS = 6e4;
 var digests = /* @__PURE__ */ new Map();
 function facts(path) {
-  const stat = statSync2(path);
+  const stat = statSync6(path);
   const key = `${stat.mtimeMs}:${stat.size}`;
   const cached = digests.get(path);
   if (cached?.key === key) return cached;
-  const digest = `sha256:${createHash2("sha256").update(readFileSync4(path)).digest("hex")}`;
+  const digest = `sha256:${createHash2("sha256").update(readFileSync7(path)).digest("hex")}`;
   const fresh = { key, digest, size: stat.size };
   digests.set(path, fresh);
   return fresh;
@@ -843,7 +1171,7 @@ function filesUnder(root) {
     const dir = stack.pop();
     for (const entry of readdirSync4(dir, { withFileTypes: true })) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join4(dir, entry.name);
+      const full = join5(dir, entry.name);
       if (entry.isDirectory()) stack.push(full);
       else if (entry.isFile()) found.push(full);
       if (found.length > MAX_RESOURCES) return null;
@@ -851,117 +1179,85 @@ function filesUnder(root) {
   }
   return found.sort();
 }
-function frontmatterObject(source) {
-  if (!source.startsWith("---")) return null;
-  const end = source.indexOf("\n---", 3);
-  if (end === -1) return null;
-  try {
-    const parsed = parseYaml(source.slice(3, end));
-    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-var skillUri = (entry, file = "SKILL.md") => `skill://${AUTHORITY}/${entry.name}/${file}`;
 function extensionEntry(entry) {
   if (kindOf(entry) !== "skill" || basename4(entry.path) !== "SKILL.md")
     return null;
-  const frontmatter = frontmatterObject(readFileSync4(entry.path, "utf8"));
-  const name = frontmatter?.["name"];
-  if (typeof name !== "string" || name !== entry.slug || !SKILL_NAME.test(name))
-    return null;
-  if (basename4(dirname4(entry.path)) !== name) return null;
-  if (typeof frontmatter?.["description"] !== "string") return null;
-  const root = dirname4(entry.path);
+  const frontmatter = frontmatterObject(readFileSync7(entry.path, "utf8"));
+  const root = dirname5(entry.path);
+  if (specProblems(frontmatter, basename4(root)).length > 0) return null;
+  if (frontmatter?.["name"] !== entry.slug) return null;
   const files = filesUnder(root);
   if (files === null) return null;
   let total = 0;
   const resources = files.map((path) => {
     const fact = facts(path);
     total += fact.size;
-    const file = relative3(root, path).split(sep2).join("/");
-    return { uri: skillUri(entry, file), digest: fact.digest, size: fact.size };
+    const file = relative4(root, path).split(sep3).join("/");
+    return {
+      uri: skillFileUri(entry, file),
+      digest: fact.digest,
+      size: fact.size
+    };
   });
   if (total > MAX_SKILL_BYTES) return null;
-  return { uri: skillUri(entry), frontmatter, resources };
+  return { uri: skillFileUri(entry), frontmatter, resources };
 }
-var MIME = {
-  ".md": "text/markdown",
-  ".json": "application/json",
-  ".txt": "text/plain",
-  ".py": "text/x-python",
-  ".js": "text/javascript",
-  ".mjs": "text/javascript",
-  ".ts": "text/typescript",
-  ".sh": "text/x-shellscript",
-  ".yaml": "text/yaml",
-  ".yml": "text/yaml",
-  ".toml": "text/plain"
-};
-var mimeOf = (path) => {
-  const dot = path.lastIndexOf(".");
-  return dot === -1 ? void 0 : MIME[path.slice(dot).toLowerCase()];
-};
-function registerSkillsExtension(server, skills) {
+
+// src/extension/register.ts
+import {
+  ProtocolError,
+  ProtocolErrorCode
+} from "@modelcontextprotocol/server";
+import { z as z2 } from "zod";
+var SKILLS_EXTENSION = "io.modelcontextprotocol/skills";
+var PAGE_SIZE = 50;
+var TTL_MS = 6e4;
+function entriesOf(skills) {
   let memo = null;
-  const entries = () => {
+  return () => {
     const source = skills();
     if (memo?.source === source) return memo.entries;
     const map = /* @__PURE__ */ new Map();
     for (const entry of source) {
-      let served = null;
       try {
-        served = extensionEntry(entry);
+        const served = extensionEntry(entry);
+        if (served) map.set(served.uri, served);
       } catch {
       }
-      if (served) map.set(served.uri, served);
     }
     memo = { source, entries: map };
     return map;
   };
-  const pathOf = /* @__PURE__ */ new Map();
-  const locate = (uri) => {
-    if (pathOf.size === 0) {
-      for (const entry of skills()) {
-        if (kindOf(entry) === "skill" && basename4(entry.path) === "SKILL.md") {
-          pathOf.set(skillUri(entry), dirname4(entry.path));
-        }
-      }
-    }
-    for (const [skill, root] of pathOf) {
-      const prefix = skill.slice(0, -"SKILL.md".length);
-      if (uri.startsWith(prefix)) return join4(root, uri.slice(prefix.length));
-    }
-    return void 0;
+}
+function page(all, cursor) {
+  const start = cursor ? Number.parseInt(cursor, 10) : 0;
+  if (!Number.isInteger(start) || start < 0 || start > all.length) {
+    throw new ProtocolError(ProtocolErrorCode.InvalidParams, "invalid cursor");
+  }
+  const end = start + PAGE_SIZE;
+  return {
+    skills: all.slice(start, end),
+    ...end < all.length ? { nextCursor: String(end) } : {}
   };
+}
+function registerSkillsExtension(server, skills, options = {}) {
+  const entries = entriesOf(skills);
+  const cache = { ttlMs: TTL_MS, cacheScope: options.cacheScope ?? "public" };
   server.server.registerCapabilities({
     extensions: { [SKILLS_EXTENSION]: {} }
   });
   server.server.setRequestHandler(
     "skills/list",
-    { params: z.object({ cursor: z.string().optional() }).passthrough() },
-    async (params) => {
-      const all = [...entries().values()];
-      const start = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
-      if (!Number.isInteger(start) || start < 0 || start > all.length) {
-        throw new ProtocolError(
-          ProtocolErrorCode.InvalidParams,
-          "invalid cursor"
-        );
-      }
-      const end = start + PAGE_SIZE;
-      return {
-        resultType: "complete",
-        skills: all.slice(start, end),
-        ...end < all.length ? { nextCursor: String(end) } : {},
-        ttlMs: LIST_TTL_MS,
-        cacheScope: "public"
-      };
-    }
+    { params: z2.object({ cursor: z2.string().optional() }).passthrough() },
+    async (params) => ({
+      resultType: "complete",
+      ...page([...entries().values()], params.cursor),
+      ...cache
+    })
   );
   server.server.setRequestHandler(
     "skills/get",
-    { params: z.object({ uri: z.string() }).passthrough() },
+    { params: z2.object({ uri: z2.string() }).passthrough() },
     async (params) => {
       const skill = entries().get(params.uri);
       if (!skill) {
@@ -970,39 +1266,104 @@ function registerSkillsExtension(server, skills) {
           `not a skill this server serves: ${params.uri}`
         );
       }
-      return { resultType: "complete", skill };
-    }
-  );
-  server.registerResource(
-    "skill-files",
-    new ResourceTemplate(`skill://${AUTHORITY}/{+path}`, { list: void 0 }),
-    {
-      title: "Skill files",
-      description: "Files of the skills listed by skills/list."
-    },
-    async (uri) => {
-      const href = uri.toString();
-      const listed = [...entries().values()].some(
-        (skill) => skill.resources.some((resource) => resource.uri === href)
-      );
-      const path = listed ? locate(href) : void 0;
-      if (path === void 0) throw new ResourceNotFoundError(href);
-      const bytes = readFileSync4(path);
-      const mimeType = mimeOf(path);
-      const text = mimeType !== void 0;
-      return {
-        contents: [
-          text ? { uri: href, mimeType, text: bytes.toString("utf8") } : { uri: href, blob: bytes.toString("base64") }
-        ]
-      };
+      return { resultType: "complete", skill, ...cache };
     }
   );
 }
 
+// src/tools/schemas.ts
+import { z as z3 } from "zod";
+var kind = z3.enum(ASSET_KINDS);
+var catalogItemSchema = z3.object({
+  name: z3.string(),
+  description: z3.string(),
+  tier: z3.string().optional(),
+  kind: kind.optional()
+});
+var catalogResponseSchema = z3.object({
+  count: z3.number().int(),
+  page: z3.number().int(),
+  totalPages: z3.number().int(),
+  hasNext: z3.boolean(),
+  packages: z3.array(
+    z3.object({ package: z3.string(), skills: z3.array(catalogItemSchema) })
+  )
+});
+var findResultSchema = z3.object({
+  ranking: z3.enum(["semantic", "lexical"]),
+  matches: z3.array(
+    z3.object({
+      name: z3.string(),
+      package: z3.string(),
+      description: z3.string(),
+      score: z3.number()
+    })
+  )
+});
+var skillFileSchema = z3.object({
+  path: z3.string(),
+  bytes: z3.number().int(),
+  sha256: z3.string()
+});
+var describeResponseSchema = z3.object({
+  name: z3.string(),
+  kind,
+  package: z3.string(),
+  description: z3.string(),
+  tier: z3.string().optional(),
+  metadata: z3.record(
+    z3.string(),
+    z3.union([z3.string(), z3.array(z3.string()).readonly()])
+  ),
+  frontmatter: z3.string(),
+  files: z3.array(skillFileSchema),
+  filesTruncated: z3.boolean()
+});
+var bundleResponseSchema = z3.object({
+  name: z3.string(),
+  truncated: z3.boolean(),
+  files: z3.array(
+    skillFileSchema.extend({ uri: z3.string(), mimeType: z3.string() })
+  )
+});
+
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/server";
-import { z as z2 } from "zod";
-var SERVER_NAME = "pmcp";
+
+// src/tools/bundle.ts
+import { z as z5 } from "zod";
+
+// src/tools/content.ts
+function fileBlock(file) {
+  if (file.kind === "text") {
+    return { type: "text", text: file.text ?? "" };
+  }
+  if (file.kind === "image" || file.kind === "audio") {
+    return {
+      type: file.kind,
+      data: file.blob ?? "",
+      mimeType: file.mimeType
+    };
+  }
+  return {
+    type: "resource",
+    resource: {
+      uri: skillFileUri({ name: file.name }, file.path),
+      mimeType: file.mimeType,
+      blob: file.blob ?? ""
+    }
+  };
+}
+var resourceLink = (file) => ({
+  type: "resource_link",
+  uri: file.uri,
+  name: file.path,
+  mimeType: file.mimeType,
+  size: file.bytes
+});
+
+// src/tools/shared.ts
+import { z as z4 } from "zod";
 var readOnly = {
   readOnlyHint: true,
   destructiveHint: false,
@@ -1013,130 +1374,212 @@ var readOnlyTool = (title) => ({
   title,
   annotations: { ...readOnly, title }
 });
-var kindInput = z2.enum(["skill", "agent", "hook", "mcp", "any"]).optional().describe(
+var kindInput = z4.enum(["skill", "agent", "hook", "mcp", "any"]).optional().describe(
   "skill (default), agent, hook, mcp, or any. Commands are skills; agents, hooks and MCP servers are installed with pmcp add rather than read."
 );
+var tierInput = z4.enum(["open", "free", "paid", "internal"]).optional();
+var skillNameInput = z4.string().min(1).describe("A skill name as skill_find or skill_catalog returns it.");
 var asText = (value) => ({
   content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
 });
-function registerSkillTools(server, tools) {
+var structured = (value) => ({
+  ...asText(value),
+  structuredContent: { ...value }
+});
+var unknownSkill = (name) => ({
+  ...asText({
+    error: "unknown_skill",
+    name,
+    hint: "skill_catalog lists the names that exist."
+  }),
+  isError: true
+});
+
+// src/tools/bundle.ts
+function registerBundleTool(server, tools) {
   server.registerTool(
-    "skill_catalog",
+    "skill_bundle",
     {
-      ...readOnlyTool("List skills"),
-      description: "Every skill the installed packages and marketplaces ship, grouped by package or plugin, with names, one-line descriptions and tier, and no bodies. Paged by group. Use it to see what exists, or when skill_find returns nothing. Pass kind to list agents, hooks or MCP servers instead.",
-      inputSchema: z2.object({
-        page: z2.number().int().min(1).optional(),
-        pageSize: z2.number().int().min(1).max(20).optional(),
-        tier: z2.enum(["open", "free", "paid", "internal"]).optional(),
-        kind: kindInput
-      })
+      ...readOnlyTool("List a skill's files"),
+      description: "Every file of one skill with its path relative to the skill directory, size, media type and sha256, as resource links that resources/read returns. The bytes are not included in this result. Used to write a skill to a local skills directory.",
+      inputSchema: z5.object({ name: skillNameInput }),
+      outputSchema: bundleResponseSchema
     },
-    async (request) => asText(tools.catalog(request))
+    async ({ name }) => {
+      const bundle = tools.bundle(name);
+      if (!bundle) return unknownSkill(name);
+      const value = { ...bundle, files: [...bundle.files] };
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(value, null, 2) },
+          ...bundle.files.map(resourceLink)
+        ],
+        structuredContent: value
+      };
+    }
+  );
+}
+
+// src/tools/call.ts
+import { z as z6 } from "zod";
+function manifest(found) {
+  const lines = found.files.map(
+    (file) => `- ${file.path} (${file.bytes} bytes, ${file.mimeType}, sha256 ${file.sha256.slice(0, 12)})`
   );
+  if (found.filesTruncated)
+    lines.push("- (list cut; skill_bundle has the rest)");
+  return [
+    `Files in skill ${found.name}. skill_read returns one by this name and its path; skill_bundle returns every file with its path:`,
+    ...lines
+  ].join("\n");
+}
+function registerCallTool(server, tools) {
   server.registerTool(
-    "skill_find",
+    "skill_call",
     {
-      ...readOnlyTool("Find skills"),
-      description: "Ranked skill names for an intent. Describe the problem in a full sentence in English rather than a keyword: a single word matches far worse, and the ranking is over descriptions. Returns names only -- read one with skill_call.",
-      inputSchema: z2.object({
-        intent: z2.string().min(1).max(256).describe("What you are trying to do, as an English sentence."),
-        limit: z2.number().int().min(1).max(25).optional(),
-        filters: z2.object({
-          kind: kindInput,
-          tier: z2.enum(["open", "free", "paid", "internal"]).optional(),
-          package: z2.string().optional(),
-          level: z2.string().optional(),
-          domain: z2.string().optional(),
-          medium: z2.string().optional()
-        }).optional().describe("Exact-match filters over the catalog before ranking.")
+      ...readOnlyTool("Read a skill"),
+      description: "The body of a single skill, by the name skill_find or skill_catalog returned, followed by the list of reference, script and asset files the skill carries, if any, as text and as resource links. This is the only call that costs a document.",
+      inputSchema: z6.object({
+        name: z6.string().min(1).describe("The skill name, as <package>/<slug>.")
       })
     },
-    async ({ intent, limit, filters }) => asText(await tools.find(intent, limit, filters))
+    async ({ name }) => {
+      const found = tools.call(name);
+      if (!found) return unknownSkill(name);
+      const body = { type: "text", text: found.body };
+      if (found.files.length === 0) return { content: [body] };
+      return {
+        content: [
+          body,
+          { type: "text", text: manifest(found) },
+          ...found.files.map(resourceLink)
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/catalog.ts
+import { z as z7 } from "zod";
+function registerCatalogTool(server, tools) {
+  server.registerTool(
+    "skill_catalog",
+    {
+      ...readOnlyTool("List skills"),
+      description: "Every skill the installed packages and marketplaces ship, grouped by package or plugin, with names, one-line descriptions and tier, and no bodies. Paged by group. With kind it lists agents, hooks or MCP servers instead.",
+      inputSchema: z7.object({
+        page: z7.number().int().min(1).optional(),
+        pageSize: z7.number().int().min(1).max(20).optional(),
+        tier: tierInput,
+        kind: kindInput
+      }),
+      outputSchema: catalogResponseSchema
+    },
+    async (request) => structured(tools.catalog(request))
   );
+}
+
+// src/tools/describe.ts
+import { z as z8 } from "zod";
+function registerDescribeTool(server, tools) {
   server.registerTool(
     "skill_describe",
     {
       ...readOnlyTool("Describe a skill"),
-      description: "Frontmatter, metadata (tier, level, requirements, licence, approval), and the files the skill carries with sizes and sha256, without any body. Use it to decide between candidates before skill_call.",
-      inputSchema: z2.object({
-        name: z2.string().min(1).describe("The skill name skill_find or skill_catalog returned.")
-      })
+      description: "One skill's frontmatter, metadata (tier, level, requirements, licence, approval), and the files it carries with sizes and sha256, without any body.",
+      inputSchema: z8.object({ name: skillNameInput }),
+      outputSchema: describeResponseSchema
     },
     async ({ name }) => {
       const described = tools.describe(name);
-      if (!described) {
-        return {
-          ...asText({
-            error: "unknown_skill",
-            name,
-            hint: "Call skill_catalog for the names that exist."
-          }),
-          isError: true
-        };
-      }
-      return asText(described);
+      return described ? structured(described) : unknownSkill(name);
     }
   );
+}
+
+// src/tools/find.ts
+import { z as z9 } from "zod";
+function registerFindTool(server, tools) {
+  server.registerTool(
+    "skill_find",
+    {
+      ...readOnlyTool("Find skills"),
+      description: "Skill names ranked against an intent, with descriptions and scores, and no bodies. The ranking compares the intent with skill descriptions, so a full sentence matches better than a single keyword.",
+      inputSchema: z9.object({
+        intent: z9.string().min(1).max(256).describe("What the task is, as a sentence."),
+        limit: z9.number().int().min(1).max(25).optional(),
+        filters: z9.object({
+          kind: kindInput,
+          tier: tierInput,
+          package: z9.string().optional(),
+          level: z9.string().optional(),
+          domain: z9.string().optional(),
+          medium: z9.string().optional()
+        }).optional().describe("Exact-match filters over the catalog before ranking.")
+      }),
+      outputSchema: findResultSchema
+    },
+    async ({ intent, limit, filters }) => structured(await tools.find(intent, limit, filters))
+  );
+}
+
+// src/tools/read.ts
+import { z as z10 } from "zod";
+function registerReadTool(server, tools) {
   server.registerTool(
     "skill_read",
     {
       ...readOnlyTool("Read a skill file"),
-      description: "A reference or script file inside one skill's directory in this catalog, as text, with its sha256. It reads only files the catalog ships and calls no external API; path is relative to the skill, as skill_describe lists it (layout: https://pmcp.build). Read only when the skill body points at the file. Scripts are returned, never run. Files over 256 KiB and paths outside the skill are refused.",
-      inputSchema: z2.object({
-        name: z2.string().min(1),
-        path: z2.string().min(1).optional().describe(
-          "Path relative to the skill directory, as skill_describe lists it. Defaults to SKILL.md."
+      description: "One file inside a skill's directory in this catalog, with its sha256 and media type: text as text, images and audio as image and audio content, other binary files as an embedded resource. path is relative to the skill, as skill_call, skill_bundle and skill_describe list it (layout: https://pmcp.build). Scripts are returned as content, never run, and no external API is called. Files over 256 KiB and paths outside the skill are refused.",
+      inputSchema: z10.object({
+        name: skillNameInput,
+        path: z10.string().min(1).optional().describe(
+          "Path relative to the skill directory. Defaults to SKILL.md."
         )
       })
     },
     async ({ name, path }) => {
       const result = tools.read(name, path);
       if (!result.ok) return { ...asText(result), isError: true };
-      const { text, ...header } = result;
+      const { text: _text, blob: _blob, ...header } = result;
       return {
         content: [
           { type: "text", text: JSON.stringify(header) },
-          { type: "text", text }
+          fileBlock(result)
         ]
       };
     }
   );
-  server.registerTool(
-    "skill_call",
-    {
-      ...readOnlyTool("Read a skill"),
-      description: "The body of a single skill, by the name skill_find or skill_catalog returned. This is the only call that costs a document.",
-      inputSchema: z2.object({
-        name: z2.string().min(1).describe("The skill name, as <package>/<slug>.")
-      })
-    },
-    async ({ name }) => {
-      const found = tools.call(name);
-      if (!found) {
-        return {
-          ...asText({
-            error: "unknown_skill",
-            name,
-            hint: "Call skill_catalog for the names that exist."
-          }),
-          isError: true
-        };
-      }
-      return { content: [{ type: "text", text: found.body }] };
-    }
-  );
+}
+
+// src/mcp.ts
+var SERVER_NAME = "pmcp";
+var SERVER_VERSION = "0.8.0";
+function registerSkillTools(server, tools) {
+  registerCatalogTool(server, tools);
+  registerFindTool(server, tools);
+  registerDescribeTool(server, tools);
+  registerReadTool(server, tools);
+  registerCallTool(server, tools);
+  registerBundleTool(server, tools);
   return server;
 }
 function createSkillServer(options) {
-  const server = new McpServer({ name: SERVER_NAME, version: "0.7.0" });
+  const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION });
   const tools = createSkillTools(options);
-  registerSkillsExtension(server, tools.skills);
+  registerSkillsExtension(server, tools.skills, options.skillsExtension);
+  registerSkillResources(server, tools.skills);
+  if (options.prompts) registerSkillPrompts(server, tools);
   return registerSkillTools(server, tools);
 }
 
 export {
   normaliseIntent,
+  frontmatterObject,
+  NAME_MAX,
+  DESCRIPTION_MAX,
+  COMPATIBILITY_MAX,
+  specProblems,
   readMetadata,
   readFrontmatterText,
   readMarketplace,
@@ -1150,21 +1593,36 @@ export {
   readCatalog,
   withoutBody,
   displayPath,
+  promptName,
+  registerSkillPrompts,
+  listSkillFiles,
+  mimeOf,
+  isUtf8Text,
+  classify,
+  READ_BUDGET_BYTES,
+  readSkillFile,
+  skillFileUri,
+  resolveSkillFileUri,
+  registerSkillResources,
   DEFAULT_FIND_LIMIT,
   lexicalScore,
   cosine,
   find,
-  READ_BUDGET_BYTES,
+  bundleSkill,
   DESCRIBE_FILE_LIMIT,
   CATALOG_PAGE_SIZE,
   CATALOG_PAGE_MAX,
   createSkillTools,
-  SKILLS_EXTENSION,
-  skillUri,
   extensionEntry,
+  SKILLS_EXTENSION,
   registerSkillsExtension,
+  catalogResponseSchema,
+  findResultSchema,
+  describeResponseSchema,
+  bundleResponseSchema,
   SERVER_NAME,
+  SERVER_VERSION,
   registerSkillTools,
   createSkillServer
 };
-//# sourceMappingURL=chunk-QHFORYIN.js.map
+//# sourceMappingURL=chunk-ZDV75HZN.js.map