@modootoday/pmcp 0.4.0 → 0.5.1

package/dist/{chunk-BFET6MFN.js → chunk-76UKXVUE.js}

@@ -5,11 +5,13 @@ function normaliseIntent(intent) {
 
 // src/marketplace.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join2, resolve } from "path";
+import { basename as basename2, dirname as dirname2, join as join2, resolve } from "path";
 
 // src/catalog.ts
 import { existsSync, readFileSync, readdirSync } from "fs";
 import { basename, dirname, isAbsolute, join, relative } from "path";
+var ASSET_KINDS = ["skill", "agent", "hook", "mcp"];
+var kindOf = (entry) => entry.kind ?? "skill";
 var SKIPPED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -295,6 +297,151 @@ var asList = (value) => {
   if (value === void 0) return [];
   return typeof value === "string" ? [value] : value;
 };
+function readJson(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function markdownEntry(context, path, fallbackSlug, shape) {
+  const source = readFileSync2(path, "utf8");
+  const front = readFrontmatter(source);
+  const description = front["description"] ?? "";
+  if (description === "") {
+    context.onReject?.({ path, reason: "no description" });
+    return null;
+  }
+  const metadata = readMetadata(source);
+  const ownTier = asString(metadata["tier"]);
+  if (context.tier !== void 0 && ownTier !== void 0 && ownTier !== context.tier) {
+    context.onReject?.({
+      path,
+      reason: `metadata.tier ${ownTier} in a ${context.tier} marketplace`
+    });
+    return null;
+  }
+  const slug = front["name"] ?? fallbackSlug;
+  const prefix = `${context.marketplace}/${context.plugin}`;
+  return {
+    name: shape.namespace ? `${prefix}/${shape.namespace}/${slug}` : `${prefix}/${slug}`,
+    package: prefix,
+    slug,
+    description,
+    path,
+    tier: ownTier ?? context.tier,
+    metadata,
+    keywords: asList(metadata["keywords"]),
+    ...shape.kind ? { kind: shape.kind } : {},
+    ...shape.root ? { root: shape.root } : {}
+  };
+}
+function skillEntries(context) {
+  const dir = join2(context.pluginDir, "skills");
+  if (!existsSync2(dir)) return [];
+  const found = [];
+  for (const child of readdirSync2(dir, { withFileTypes: true })) {
+    if (!child.isDirectory()) continue;
+    const path = join2(dir, child.name, "SKILL.md");
+    if (!existsSync2(path)) continue;
+    const entry = markdownEntry(context, path, child.name, {});
+    if (entry) found.push(entry);
+  }
+  return found;
+}
+function commandEntries(context) {
+  const dir = join2(context.pluginDir, "commands");
+  if (!existsSync2(dir)) return [];
+  const found = [];
+  for (const child of readdirSync2(dir, { withFileTypes: true })) {
+    if (!child.isFile() || !child.name.endsWith(".md")) continue;
+    const path = join2(dir, child.name);
+    const entry = markdownEntry(context, path, basename2(child.name, ".md"), {
+      root: path
+    });
+    if (entry) found.push(entry);
+  }
+  return found;
+}
+function agentEntries(context) {
+  const dir = join2(context.pluginDir, "agents");
+  if (!existsSync2(dir)) return [];
+  const found = [];
+  for (const child of readdirSync2(dir, { withFileTypes: true })) {
+    let entry = null;
+    if (child.isFile() && child.name.endsWith(".md")) {
+      const path = join2(dir, child.name);
+      entry = markdownEntry(context, path, basename2(child.name, ".md"), {
+        kind: "agent",
+        root: path,
+        namespace: "agents"
+      });
+    } else if (child.isDirectory() && existsSync2(join2(dir, child.name, "agent.md"))) {
+      entry = markdownEntry(
+        context,
+        join2(dir, child.name, "agent.md"),
+        child.name,
+        {
+          kind: "agent",
+          namespace: "agents"
+        }
+      );
+    }
+    if (entry) found.push(entry);
+  }
+  return found;
+}
+function hookEntries(context, manifest) {
+  const declared = typeof manifest.hooks === "string" ? manifest.hooks : void 0;
+  const path = resolve(context.pluginDir, declared ?? "hooks/hooks.json");
+  if (!existsSync2(path)) return [];
+  const hooks = readJson(path);
+  if (hooks === null) {
+    context.onReject?.({ path, reason: "hooks.json is not a JSON object" });
+    return [];
+  }
+  const own = typeof hooks["description"] === "string" ? hooks["description"] : void 0;
+  const description = own ?? context.pluginDescription ?? "";
+  if (description === "") {
+    context.onReject?.({ path, reason: "no description" });
+    return [];
+  }
+  const prefix = `${context.marketplace}/${context.plugin}`;
+  return [
+    {
+      name: `${prefix}/hooks`,
+      package: prefix,
+      slug: "hooks",
+      description,
+      path,
+      tier: context.tier,
+      kind: "hook",
+      root: context.pluginDir
+    }
+  ];
+}
+function mcpEntries(context) {
+  const path = join2(context.pluginDir, ".mcp.json");
+  if (!existsSync2(path)) return [];
+  const config = readJson(path);
+  const servers = config?.["mcpServers"];
+  if (servers === null || typeof servers !== "object" || Array.isArray(servers)) {
+    context.onReject?.({ path, reason: ".mcp.json has no mcpServers object" });
+    return [];
+  }
+  const prefix = `${context.marketplace}/${context.plugin}`;
+  return Object.keys(servers).map((server) => ({
+    name: `${prefix}/mcp/${server}`,
+    package: prefix,
+    slug: server,
+    description: context.pluginDescription ? `MCP server ${server}. ${context.pluginDescription}` : `MCP server ${server} from plugin ${context.plugin}.`,
+    path,
+    tier: context.tier,
+    kind: "mcp",
+    root: path
+  }));
+}
 function readMarketplace(dir, onReject) {
   const manifestPath = join2(dir, ".claude-plugin", "marketplace.json");
   if (!existsSync2(manifestPath)) {
@@ -317,47 +464,33 @@ function readMarketplace(dir, onReject) {
     return [];
   }
   const marketplace = manifest.name ?? "marketplace";
-  const tier = manifest.metadata?.tier;
   const found = [];
   for (const plugin of manifest.plugins ?? []) {
     if (!plugin.name || !plugin.source) continue;
-    const skillsDir = join2(resolve(dir, plugin.source), "skills");
-    if (!existsSync2(skillsDir)) continue;
-    for (const child of readdirSync2(skillsDir, { withFileTypes: true })) {
-      if (!child.isDirectory()) continue;
-      const path = join2(skillsDir, child.name, "SKILL.md");
-      if (!existsSync2(path)) continue;
-      const source = readFileSync2(path, "utf8");
-      const front = readFrontmatter(source);
-      const description = front["description"] ?? "";
-      if (description === "") {
-        onReject?.({ path, reason: "no description" });
-        continue;
-      }
-      const metadata = readMetadata(source);
-      const ownTier = asString(metadata["tier"]);
-      if (tier !== void 0 && ownTier !== void 0 && ownTier !== tier) {
-        onReject?.({
-          path,
-          reason: `metadata.tier ${ownTier} in a ${tier} marketplace`
-        });
-        continue;
-      }
-      const slug = front["name"] ?? child.name;
-      found.push({
-        name: `${marketplace}/${plugin.name}/${slug}`,
-        package: `${marketplace}/${plugin.name}`,
-        slug,
-        description,
-        path,
-        tier: ownTier ?? tier,
-        metadata,
-        keywords: asList(metadata["keywords"])
-      });
-    }
+    const pluginDir = resolve(dir, plugin.source);
+    if (!existsSync2(pluginDir)) continue;
+    const pluginManifest = readJson(
+      join2(pluginDir, ".claude-plugin", "plugin.json")
+    ) ?? {};
+    const context = {
+      marketplace,
+      plugin: plugin.name,
+      pluginDir,
+      pluginDescription: typeof pluginManifest.description === "string" ? pluginManifest.description : void 0,
+      tier: manifest.metadata?.tier,
+      onReject
+    };
+    found.push(
+      ...skillEntries(context),
+      ...commandEntries(context),
+      ...agentEntries(context),
+      ...hookEntries(context, pluginManifest),
+      ...mcpEntries(context)
+    );
   }
   return found;
 }
+var assetRoot = (entry) => entry.root ?? dirname2(entry.path);
 
 // src/find.ts
 var DEFAULT_FIND_LIMIT = 5;
@@ -445,12 +578,22 @@ function rank(matches2, limit) {
 // src/server.ts
 import { createHash } from "crypto";
 import { readFileSync as readFileSync3, readdirSync as readdirSync3, realpathSync, statSync } from "fs";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve2, sep } from "path";
+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;
 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;
   if (!filters) return true;
   const meta = entry.metadata ?? {};
   const field = (key) => {
@@ -471,6 +614,15 @@ function matches(entry, filters) {
 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();
@@ -495,6 +647,14 @@ function listFiles(root) {
   files.sort((a, b) => a.path.localeCompare(b.path));
   return { files, truncated: false };
 }
+function catalogItem(entry) {
+  return {
+    name: entry.name,
+    description: entry.description,
+    ...entry.tier === void 0 ? {} : { tier: entry.tier },
+    ...kindOf(entry) === "skill" ? {} : { kind: kindOf(entry) }
+  };
+}
 function createSkillTools(options) {
   const load = options.loadCatalog ?? readCatalog;
   let entries = null;
@@ -518,16 +678,11 @@ function createSkillTools(options) {
       const byPackage = /* @__PURE__ */ new Map();
       let count = 0;
       for (const entry of catalog()) {
-        if (!matches(entry, { tier: request.tier })) continue;
+        if (!matches(entry, { tier: request.tier, kind: request.kind }))
+          continue;
         count += 1;
         const list = byPackage.get(entry.package) ?? [];
-        list.push(
-          entry.tier === void 0 ? { name: entry.name, description: entry.description } : {
-            name: entry.name,
-            description: entry.description,
-            tier: entry.tier
-          }
-        );
+        list.push(catalogItem(entry));
         byPackage.set(entry.package, list);
       }
       const groups = [...byPackage.entries()].sort(
@@ -575,9 +730,10 @@ function createSkillTools(options) {
       const entry = catalog().find((candidate) => candidate.name === name);
       if (!entry) return null;
       const source = readFileSync3(entry.path, "utf8");
-      const listing = listFiles(dirname2(entry.path));
+      const listing = listFiles(assetRoot(entry));
       return {
         name: entry.name,
+        kind: kindOf(entry),
         package: entry.package,
         description: entry.description,
         tier: entry.tier,
@@ -591,21 +747,27 @@ function createSkillTools(options) {
      * One file inside a skill's directory. Paths that leave the directory,
      * directly or through a link, are refused; nothing is ever executed.
      */
-    read(name, path = "SKILL.md") {
+    read(name, path) {
       const entry = catalog().find((candidate) => candidate.name === name);
       if (!entry) return { ok: false, error: "unknown_skill", detail: name };
-      if (isAbsolute2(path) || path.split(/[\\/]/u).includes("..")) {
-        return { ok: false, error: "path_outside_skill", detail: path };
+      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 root = realpathSync(dirname2(entry.path));
+      const scope = realpathSync(assetRoot(entry));
+      const single = statSync(scope).isFile();
+      const root = single ? dirname3(scope) : scope;
       let target;
       try {
-        target = realpathSync(resolve2(root, path));
+        target = realpathSync(
+          single && wanted === "" ? scope : resolve2(root, wanted)
+        );
       } catch {
-        return { ok: false, error: "no_such_file", detail: path };
+        return { ok: false, error: "no_such_file", detail: wanted };
       }
-      if (target !== root && !target.startsWith(root + sep)) {
-        return { ok: false, error: "path_outside_skill", detail: path };
+      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) {
@@ -638,13 +800,208 @@ function createSkillTools(options) {
     refresh() {
       entries = null;
     },
-    entries: () => catalog().map(withoutBody)
+    entries: () => catalog().map(withoutBody),
+    /** The catalog with paths, for the Skills extension. The same array until refresh. */
+    skills: () => catalog()
   };
 }
 
+// src/skills-extension.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;
+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 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 fresh = { key, digest, size: stat.size };
+  digests.set(path, fresh);
+  return fresh;
+}
+function filesUnder(root) {
+  const found = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    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);
+      if (entry.isDirectory()) stack.push(full);
+      else if (entry.isFile()) found.push(full);
+      if (found.length > MAX_RESOURCES) return null;
+    }
+  }
+  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 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 };
+  });
+  if (total > MAX_SKILL_BYTES) return null;
+  return { uri: skillUri(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) {
+  let memo = null;
+  const entries = () => {
+    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);
+      } 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;
+  };
+  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"
+      };
+    }
+  );
+  server.server.setRequestHandler(
+    "skills/get",
+    { params: z.object({ uri: z.string() }).passthrough() },
+    async (params) => {
+      const skill = entries().get(params.uri);
+      if (!skill) {
+        throw new ProtocolError(
+          ProtocolErrorCode.InvalidParams,
+          `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") }
+        ]
+      };
+    }
+  );
+}
+
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/server";
-import { z } from "zod";
+import { z as z2 } from "zod";
 var SERVER_NAME = "pmcp";
 var readOnly = {
   readOnlyHint: true,
@@ -652,6 +1009,13 @@ var readOnly = {
   idempotentHint: true,
   openWorldHint: false
 };
+var readOnlyTool = (title) => ({
+  title,
+  annotations: { ...readOnly, title }
+});
+var kindInput = z2.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 asText = (value) => ({
   content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
 });
@@ -659,46 +1023,45 @@ function registerSkillTools(server, tools) {
   server.registerTool(
     "skill_catalog",
     {
-      title: "List installed skills without their bodies",
-      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.",
-      inputSchema: z.object({
-        page: z.number().int().min(1).optional(),
-        pageSize: z.number().int().min(1).max(20).optional(),
-        tier: z.enum(["open", "free", "paid", "internal"]).optional()
-      }),
-      annotations: readOnly
+      ...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
+      })
     },
     async (request) => asText(tools.catalog(request))
   );
   server.registerTool(
     "skill_find",
     {
-      title: "Find skills by describing the problem",
+      ...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: z.object({
-        intent: z.string().min(1).max(256).describe("What you are trying to do, as an English sentence."),
-        limit: z.number().int().min(1).max(25).optional(),
-        filters: z.object({
-          tier: z.enum(["open", "free", "paid", "internal"]).optional(),
-          package: z.string().optional(),
-          level: z.string().optional(),
-          domain: z.string().optional(),
-          medium: z.string().optional()
+      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.")
-      }),
-      annotations: readOnly
+      })
     },
     async ({ intent, limit, filters }) => asText(await tools.find(intent, limit, filters))
   );
   server.registerTool(
     "skill_describe",
     {
-      title: "Check one skill's properties before loading it",
+      ...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: z.object({
-        name: z.string().min(1).describe("The skill name skill_find or skill_catalog returned.")
-      }),
-      annotations: readOnly
+      inputSchema: z2.object({
+        name: z2.string().min(1).describe("The skill name skill_find or skill_catalog returned.")
+      })
     },
     async ({ name }) => {
       const described = tools.describe(name);
@@ -718,15 +1081,14 @@ function registerSkillTools(server, tools) {
   server.registerTool(
     "skill_read",
     {
-      title: "Read one file a skill carries",
-      description: "A reference or script file inside one skill's directory, as text, with its sha256. 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: z.object({
-        name: z.string().min(1),
-        path: z.string().min(1).optional().describe(
+      ...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."
         )
-      }),
-      annotations: readOnly
+      })
     },
     async ({ name, path }) => {
       const result = tools.read(name, path);
@@ -743,12 +1105,11 @@ function registerSkillTools(server, tools) {
   server.registerTool(
     "skill_call",
     {
-      title: "Read one skill",
+      ...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: z.object({
-        name: z.string().min(1).describe("The skill name, as <package>/<slug>.")
-      }),
-      annotations: readOnly
+      inputSchema: z2.object({
+        name: z2.string().min(1).describe("The skill name, as <package>/<slug>.")
+      })
     },
     async ({ name }) => {
       const found = tools.call(name);
@@ -768,8 +1129,10 @@ function registerSkillTools(server, tools) {
   return server;
 }
 function createSkillServer(options) {
-  const server = new McpServer({ name: SERVER_NAME, version: "0.4.0" });
-  return registerSkillTools(server, createSkillTools(options));
+  const server = new McpServer({ name: SERVER_NAME, version: "0.5.1" });
+  const tools = createSkillTools(options);
+  registerSkillsExtension(server, tools.skills);
+  return registerSkillTools(server, tools);
 }
 
 export {
@@ -777,6 +1140,9 @@ export {
   readMetadata,
   readFrontmatterText,
   readMarketplace,
+  assetRoot,
+  ASSET_KINDS,
+  kindOf,
   SKIPPED_DIRS,
   MAX_SKILL_DEPTH,
   readFrontmatter,
@@ -793,8 +1159,12 @@ export {
   CATALOG_PAGE_SIZE,
   CATALOG_PAGE_MAX,
   createSkillTools,
+  SKILLS_EXTENSION,
+  skillUri,
+  extensionEntry,
+  registerSkillsExtension,
   SERVER_NAME,
   registerSkillTools,
   createSkillServer
 };
-//# sourceMappingURL=chunk-BFET6MFN.js.map
+//# sourceMappingURL=chunk-76UKXVUE.js.map