efaimo 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -4,6 +4,98 @@ All notable changes to efaimo are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this project uses
 [Semantic Versioning](https://semver.org/).
 
+## [0.5.0] - 2026-09-04
+
+### Changed
+
+- **`efaimo mcp` is built on the 2.x SDK line and now satisfies the
+  specification this tool audits other servers against.** The 1.x line speaks
+  2025-11-25; it cannot answer `server/discover` and cannot carry the SEP-2549
+  cache fields, so the one MCP server this project ships failed two MUST-level
+  items of the 2026-07-28 revision, and `check --mcp` said so about it on every
+  run. The skill this project publishes about that migration opens with "upgrade
+  the SDK first". This is that.
+
+  Measured against the built server, before and after, with the same command:
+
+  ```
+  before   2026-07-28 readiness  3 items to migrate   E106, E118, E107
+  after    2026-07-28 readiness  clean, nothing to migrate
+  ```
+
+  Read off the wire rather than from our own tool as well: a modern opening now
+  answers `server/discover` with `supportedVersions`, `capabilities`,
+  `resultType: "complete"`, `ttlMs` and `cacheScope`, and `tools/list` carries
+  the same three fields. A 2025-era client that opens with `initialize` is still
+  served, unchanged, because `serveStdio` pins the era per connection rather
+  than making the server pick one.
+
+- **The client half moved with it**, from `@modelcontextprotocol/sdk` to
+  `@modelcontextprotocol/client`. Doing only the server half would have left
+  both generations installed, and E101 stops firing the moment any 2.x package
+  is present, so the half-migration would have silenced the rule that was
+  telling the truth.
+
+### Fixed
+
+- **Two moderate advisories, by subtraction.** `qs` arrived through
+  `body-parser` through `express` through the 1.x SDK, which pulls a whole HTTP
+  and OAuth stack that a stdio server never speaks. `pnpm audit --prod` now
+  reports no known vulnerabilities, and production dependencies went from 30 to
+  13.
+
+### Notes
+
+- No rule changed, so no grade moved. `rulesVersion` is untouched and the
+  published skills index does not need regenerating.
+- `check --skill`, `weigh`, `find` and `test` are byte-identical in behaviour;
+  the only thing that moved is what `efaimo mcp` puts on the wire.
+
+## [0.4.0] - 2026-09-03
+
+### Fixed
+
+- **`check --skill <dir>` finds skills it used to walk past**.
+  Two causes, both silent. The walk never entered a directory whose name starts
+  with a dot, so `.claude/skills/<name>/`, which is where a project keeps its
+  own skills, was invisible; and its depth bound of 3 missed layouts one level
+  deeper such as `skills/custom_skills/<name>/`. On the public corpus this
+  found 34 skills where `scripts/skills-index.mjs` found 38, and both numbers
+  were reported with confidence.
+
+  Dot directories are now entered for skill discovery and nowhere else, with
+  `.git` still excluded. The depth bound is 6 and is measured rather than
+  picked: the deepest real skill in that corpus sits 4 directories below a
+  directory of repositories and 3 below a repository root, so six leaves two
+  levels of headroom while still keeping an accidental `check --skill /` from
+  walking a disk.
+
+  **And when the bound does bite, it says so.** `SkillSet.truncatedAt` lists
+  the directories the walk refused to enter, because a bound that truncates in
+  silence is the same failure as a check that examines nothing. On the public
+  corpus it fires 16 times, all of them XML schema trees inside the `xlsx` and
+  `pptx` skills, which is the bound doing its job audibly.
+
+- **One walker instead of two**. `scripts/skills-index.mjs`
+  carried its own copy with different rules, which is why the two disagreed.
+  It now calls the CLI's discovery, so they cannot drift apart again, and it
+  passes the truncation warning through. The published July index regenerates
+  byte-identically under the shared walk, which is how this was checked.
+
+### Added
+
+- **S107: a filename one capitalisation away from a skill**.
+  Set-level and warn-level, so it moves no grade, in the same way S103 treats
+  a collision that belongs to a pair rather than to either member.
+
+  The spec names `SKILL.md` exactly and discovery matches it exactly, so
+  `skill.md` is not a skill here on any platform. It is not nothing anywhere:
+  a case-insensitive filesystem, the default on macOS and Windows, may hand it
+  to a host that opens it by name, so the same repository can carry a working
+  skill on the author's laptop and no skill at all in Linux CI. Nothing in
+  this tool would previously have mentioned such a file, which is the worst
+  property a near miss can have. Five exist in the public corpus.
+
 ## [0.3.0] - 2026-09-03
 
 ### Added
@@ -34,9 +126,17 @@ All notable changes to efaimo are documented here. Format follows
   both runs scored lower.
 
   Measured on the public skills corpus, 2026-07-17 pinned against 2026-09-03
-  HEAD, same ruleset both sides: metadata -0.8%, body +7.5%, referenced files
-  +61.4% with one skill at 96.5% of that movement; grades 0 improved and 4
-  worsened.
+  HEAD, same ruleset both sides, over the **32 skills `check --skill` pairs**:
+  metadata -0.8%, body +7.5%, referenced files +61.4% with one skill at 96.5%
+  of that movement; grades 0 improved and 4 worsened.
+
+  The population matters and is worth stating, because
+  `research/skills-delta-2026-09-03/REPORT.md` reports body **+7.0%** over
+  **36** paired skills for the same corpus on the same dates. Both are true.
+  `scripts/skills-index.mjs` finds four skills that `check --skill` does not,
+  for the walker reason in Known below, so the two are measuring slightly
+  different populations. Every other figure is identical between them; the
+  body percentage is the one the four missing skills move.
 
 - **`efaimo find` takes several servers**. Pass more than one
   and their catalogs are merged into one and measured together, each tool
@@ -355,6 +455,8 @@ First release.
   Documented rule set (`docs/RULES.md`), token methodology (`docs/METHODOLOGY.md`),
   and integration guide (`docs/INTEGRATIONS.md`).
 
+[0.5.0]: https://github.com/efaimo-ai/efaimo/releases/tag/v0.5.0
+[0.4.0]: https://github.com/efaimo-ai/efaimo/releases/tag/v0.4.0
 [0.3.0]: https://github.com/efaimo-ai/efaimo/releases/tag/v0.3.0
 [0.2.0]: https://github.com/efaimo-ai/efaimo/releases/tag/v0.2.0
 [0.1.2]: https://github.com/efaimo-ai/efaimo/releases/tag/v0.1.2

package/README.md

@@ -406,3 +406,7 @@ Built by [efaimo ai](https://efaimo.ai), open tooling for the space between host
 and tools. `efaimo` is the flagship CLI; capabilities grow as subcommands under one
 name. Apache-2.0. See [CONTRIBUTING.md](./CONTRIBUTING.md) and
 [docs/RULES.md](./docs/RULES.md) to add a rule.
+
+EFAIMO AI is a registered trademark of the publisher (KR 40-2585820, class 42).
+The lowercase `efaimo ai` used throughout is the same mark; the package name and
+the commands stay lowercase.

package/SKILL.md

@@ -3,7 +3,7 @@ name: efaimo
 description: Audit MCP servers and Agent Skills for quality and context-window cost. Use when the user wants to check an MCP server's token cost, lint a skill, verify 2026-07-28 MCP spec readiness, find out whether a search can single out a server's tools under deferred tool loading, or add an efaimo badge or CI gate.
 license: Apache-2.0
 metadata:
-  version: "0.3.0"
+  version: "0.5.0"
   homepage: "https://efaimo.ai"
 ---
 

package/dist/check/check.js

@@ -85,5 +85,20 @@ export async function checkSkillSet(pathInput, label) {
         return { name, dir: skill.dir, report: buildReport("skill", name, findings, []) };
     });
     const setFindings = set.skills.flatMap((skill) => runRules(setRules, { skill, set, weigh }));
+    // S107 is emitted here rather than by a SkillRule because its subject is a
+    // file that is NOT a skill: no rule that takes a parsed skill could ever see
+    // it. Set level and warn level on purpose, so it moves no grade, matching
+    // how S103 treats a collision that belongs to a pair rather than to either
+    // member.
+    for (const file of set.miscasedSkillFiles ?? []) {
+        setFindings.push({
+            ruleId: "S107",
+            severity: "warn",
+            title: "filename is one capitalisation away from a skill",
+            message: `"${path.relative(set.root, file)}" is not loaded here, because the spec names SKILL.md exactly. A case-insensitive filesystem (the macOS and Windows default) may still hand it to a host, so this can work on a laptop and be missing entirely in Linux CI.`,
+            target: path.relative(set.root, file),
+            fixHint: "rename it to SKILL.md, or delete it if it is not a skill",
+        });
+    }
     return { label, root: set.root, perSkill, setFindings, weigh };
 }

package/dist/clients/introspect.js

@@ -1,8 +1,8 @@
 import crossSpawn from "cross-spawn";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { Client } from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { SSEClientTransport } from "@modelcontextprotocol/client";
 import { introspectStateless } from "./stateless.js";
 import { minimalChildEnv } from "../util/childEnv.js";
 import { truncate, withTimeout } from "../util/misc.js";

package/dist/core/types.d.ts

@@ -339,6 +339,24 @@ export interface SkillInfo {
 export interface SkillSet {
     root: string;
     skills: SkillInfo[];
+    /**
+     * Directories the walk refused to enter because it hit its depth bound.
+     *
+     * Present only when the bound actually bit. A truncated search that reports
+     * a short list and no reason is the same failure as a check that examines
+     * nothing, so the caller is given the means to say what it did not look at.
+     */
+    truncatedAt?: string[];
+    /**
+     * Files one capitalisation away from being a skill, such as `skill.md`.
+     *
+     * The spec names `SKILL.md` exactly and discovery matches it exactly, so
+     * these are not skills here on any platform. They may still be skills to a
+     * host reading a case-insensitive filesystem, which is the default on macOS
+     * and Windows, so the same repository can work on a laptop and have no
+     * skills at all in Linux CI. Reported by S107.
+     */
+    miscasedSkillFiles?: string[];
 }
 export interface GradeInfo {
     score: number;

package/dist/mcp/server.d.ts

@@ -1,3 +1,3 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-export declare function buildMcpServer(): Server;
+import { McpServer } from "@modelcontextprotocol/server";
+export declare function buildMcpServer(): McpServer;
 export declare function runMcpServer(): Promise<void>;

package/dist/mcp/server.js

@@ -1,88 +1,94 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { z } from "zod";
 import { checkSkillSet } from "../check/check.js";
 import { weighSkills } from "../weigh/weigh.js";
 import { findSkills } from "../skills/parse.js";
 import { renderCheckMarkdown, renderSkillSetMarkdown, renderWeighMarkdown } from "../reporters/markdown.js";
 import { VERSION } from "../version.js";
+/**
+ * `efaimo mcp`: a small, read-only MCP server that exposes the skill checks to an
+ * agent, so it can lint or weigh a skill mid-session before committing it to
+ * context. Deliberately narrow: the tools only read files. They spawn no process
+ * and open no socket (unlike `check --mcp`, which connects to a live server), and
+ * `test` is not exposed at all because it spends tokens. That keeps the surface
+ * safe for an agent to call unattended.
+ *
+ * Built on the 2.x SDK line since 0.5.0. The 1.x line speaks 2025-11-25 and
+ * cannot answer `server/discover` or carry the SEP-2549 cache fields, so this
+ * server failed two MUST-level items of the specification the rest of this tool
+ * audits other servers against, and the skill this project publishes about that
+ * migration opens with "upgrade the SDK first". It was the only server we ship
+ * and the only one we had not migrated.
+ *
+ * `serveStdio` owns the era decision rather than this file: the opening exchange
+ * selects it, one instance is pinned for the connection, and a 2025-era client
+ * that opens with `initialize` is still served. Registering the tools once, on a
+ * factory that serves both eras, is the whole reason to use it instead of
+ * wiring a transport by hand.
+ */
 // Both tools only read local files, so the same hints apply: safe to call without
 // a confirmation, safe to repeat, and not reaching out to any external service.
 const READ_ONLY = { readOnlyHint: true, idempotentHint: true, openWorldHint: false };
-function requireString(args, key) {
-    const v = args[key];
-    if (typeof v !== "string" || v.trim() === "") {
-        throw new Error(`"${key}" is required and must be a non-empty string`);
-    }
-    return v;
-}
-const pathSchema = (what) => ({
-    type: "object",
-    properties: { path: { type: "string", description: what } },
-    required: ["path"],
-    additionalProperties: false,
+// One shared shape. `.min(1)` is the schema saying what `requireString` used to
+// say at runtime: an empty path is not a path. Under the 2.x registration the
+// SDK validates against this before the handler runs, so the check moved from
+// our code into the contract, which is where a client can also see it.
+const pathInput = (what) => z.object({ path: z.string().min(1).describe(what) });
+const CHECK_DESCRIPTION = "Lint an Agent Skill, or a folder of skills, for spec compliance, trigger quality, " +
+    "context-window cost, reference integrity, and injection hygiene. Returns a grade from " +
+    "A to F and the findings. Read-only: reads files only.";
+const WEIGH_DESCRIPTION = "Measure the context-window token cost of an Agent Skill: the metadata loaded into every " +
+    "session and the body loaded when the skill triggers. Returns token counts per skill. " +
+    "Read-only: reads files only.";
+const text = (s) => ({ content: [{ type: "text", text: s }] });
+const failure = (e) => ({
+    content: [{ type: "text", text: `error: ${e instanceof Error ? e.message : String(e)}` }],
+    isError: true,
 });
-const TOOLS = [
-    {
-        name: "efaimo_check_skill",
-        description: "Lint an Agent Skill, or a folder of skills, for spec compliance, trigger quality, " +
-            "context-window cost, reference integrity, and injection hygiene. Returns a grade from " +
-            "A to F and the findings. Read-only: reads files only.",
-        inputSchema: pathSchema("Path to a SKILL.md file or a directory that contains skills."),
+export function buildMcpServer() {
+    const server = new McpServer({ name: "efaimo", version: VERSION }, { capabilities: { tools: {} } });
+    server.registerTool("efaimo_check_skill", {
+        description: CHECK_DESCRIPTION,
+        inputSchema: pathInput("Path to a SKILL.md file or a directory that contains skills."),
         annotations: READ_ONLY,
-        async run(args) {
-            const p = requireString(args, "path");
-            const res = await checkSkillSet(p, p);
+    }, async ({ path }) => {
+        try {
+            const res = await checkSkillSet(path, path);
             if (res.perSkill.length === 1 && res.setFindings.length === 0) {
-                return renderCheckMarkdown(res.perSkill[0].report);
+                return text(renderCheckMarkdown(res.perSkill[0].report));
             }
-            return renderSkillSetMarkdown(res);
-        },
-    },
-    {
-        name: "efaimo_weigh_skill",
-        description: "Measure the context-window token cost of an Agent Skill: the metadata loaded into every " +
-            "session and the body loaded when the skill triggers. Returns token counts per skill. " +
-            "Read-only: reads files only.",
-        inputSchema: pathSchema("Path to a SKILL.md file or a directory that contains skills."),
-        annotations: READ_ONLY,
-        async run(args) {
-            const p = requireString(args, "path");
-            const set = findSkills(p);
-            if (!set.skills.length)
-                throw new Error(`no SKILL.md found under "${p}"`);
-            return renderWeighMarkdown(await weighSkills(set));
-        },
-    },
-];
-export function buildMcpServer() {
-    const server = new Server({ name: "efaimo", version: VERSION }, { capabilities: { tools: {} } });
-    server.setRequestHandler(ListToolsRequestSchema, () => ({
-        tools: TOOLS.map((t) => ({
-            name: t.name,
-            description: t.description,
-            inputSchema: t.inputSchema,
-            annotations: t.annotations,
-        })),
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (req) => {
-        const tool = TOOLS.find((t) => t.name === req.params.name);
-        if (!tool) {
-            return { content: [{ type: "text", text: `unknown tool: ${req.params.name}` }], isError: true };
+            return text(renderSkillSetMarkdown(res));
         }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("efaimo_weigh_skill", {
+        description: WEIGH_DESCRIPTION,
+        inputSchema: pathInput("Path to a SKILL.md file or a directory that contains skills."),
+        annotations: READ_ONLY,
+    }, async ({ path }) => {
         try {
-            const text = await tool.run(req.params.arguments ?? {});
-            return { content: [{ type: "text", text }] };
+            const set = findSkills(path);
+            if (!set.skills.length)
+                throw new Error(`no SKILL.md found under "${path}"`);
+            return text(renderWeighMarkdown(await weighSkills(set)));
         }
         catch (e) {
-            const message = e instanceof Error ? e.message : String(e);
-            return { content: [{ type: "text", text: `error: ${message}` }], isError: true };
+            return failure(e);
         }
     });
     return server;
 }
 export async function runMcpServer() {
-    const server = buildMcpServer();
-    await server.connect(new StdioServerTransport());
+    // A factory, not an instance: `serveStdio` pins one per connection after the
+    // opening exchange tells it which era it is talking to.
+    serveStdio(() => buildMcpServer(), {
+        onerror: (e) => console.error(`efaimo mcp: ${e.message}`),
+    });
     console.error(`efaimo mcp v${VERSION}: read-only skill tools ready on stdio`);
+    // stdin holds the process open; there is nothing to await. Returning a promise
+    // that never settles would only make the shutdown path harder to read.
+    await new Promise(() => { });
 }

package/dist/skills/parse.d.ts

@@ -1,4 +1,10 @@
 import type { SkillInfo, SkillSet } from "../core/types.js";
 export declare function parseSkillFile(file: string): SkillInfo;
 /** Resolve a path (SKILL.md file, skill dir, or a directory of skills) into a SkillSet. */
+/**
+ * How deep skill discovery walks. See the note inside `findSkills`: measured
+ * against the public corpus, where the deepest real skill is four directories
+ * below a directory of repositories.
+ */
+export declare const SKILL_WALK_MAX_DEPTH = 6;
 export declare function findSkills(input: string): SkillSet;

package/dist/skills/parse.js

@@ -129,6 +129,12 @@ export function parseSkillFile(file) {
     return base;
 }
 /** Resolve a path (SKILL.md file, skill dir, or a directory of skills) into a SkillSet. */
+/**
+ * How deep skill discovery walks. See the note inside `findSkills`: measured
+ * against the public corpus, where the deepest real skill is four directories
+ * below a directory of repositories.
+ */
+export const SKILL_WALK_MAX_DEPTH = 6;
 export function findSkills(input) {
     const abs = path.resolve(input);
     const stat = fs.statSync(abs);
@@ -139,11 +145,49 @@ export function findSkills(input) {
     if (fs.existsSync(direct)) {
         return { root: abs, skills: [parseSkillFile(direct)] };
     }
+    // Discovery is deliberate rather than incidental, because two walkers with
+    // different rules is what produced the 2026-09-03 defect: this found 34
+    // skills in a corpus where `scripts/skills-index.mjs` found 38, and both
+    // reported their own number with confidence.
+    //
+    // maxDepth 6 is measured, not picked. In the public corpus the deepest real
+    // skill sits 4 directories below a directory-of-repositories
+    // (`<corpus>/<repo>/skills/custom_skills/<name>/SKILL.md`) and 3 below a
+    // repository root. Six leaves two levels of headroom and keeps an accidental
+    // `check --skill /` from walking a disk. When the bound does bite it is
+    // reported rather than swallowed, in `truncatedAt`.
+    //
+    // Dot directories are entered here and nowhere else in this codebase:
+    // `.claude/skills/<name>/` is where a project keeps its own skills, so
+    // skipping them made this blind to the most common real layout. `.git` is
+    // still excluded by DEFAULT_SKIP_DIRS.
     const skills = [];
-    for (const f of walkFiles(abs, { maxDepth: 3 })) {
-        if (path.basename(f) === "SKILL.md")
+    const truncatedAt = [];
+    const miscased = [];
+    for (const f of walkFiles(abs, {
+        maxDepth: SKILL_WALK_MAX_DEPTH,
+        includeDotDirs: true,
+        onDepthLimit: (d) => truncatedAt.push(d),
+    })) {
+        const base = path.basename(f);
+        if (base === "SKILL.md")
             skills.push(parseSkillFile(f));
+        // A file that is only a capitalisation away from being a skill. The spec
+        // names SKILL.md exactly, and this comparison is exact, so `skill.md` is
+        // invisible here on every platform. It is not invisible everywhere: a
+        // case-insensitive filesystem, which is the default on macOS and Windows,
+        // may hand it to a host that opens it by name, so the same repository has
+        // a working skill on the author's laptop and no skill at all in Linux CI.
+        // Nothing else in this tool would ever mention it, which is the worst
+        // property a near miss can have.
+        else if (base.toLowerCase() === "skill.md")
+            miscased.push(f);
     }
     skills.sort((a, b) => a.file.localeCompare(b.file));
-    return { root: abs, skills };
+    return {
+        root: abs,
+        skills,
+        ...(truncatedAt.length ? { truncatedAt } : {}),
+        ...(miscased.length ? { miscasedSkillFiles: miscased.sort() } : {}),
+    };
 }

package/dist/util/misc.d.ts

@@ -3,10 +3,28 @@ export declare function parseCommandString(input: string): {
     command: string;
     args: string[];
 };
-export declare function walkFiles(root: string, opts?: {
+export interface WalkOptions {
     maxDepth?: number;
     skipDirs?: Set<string>;
-}): Generator<string>;
+    /**
+     * Descend into directories whose name starts with a dot.
+     *
+     * Off by default, because most of them are caches and metadata. On for skill
+     * discovery, because `.claude/skills/<name>/` is where a project keeps its
+     * own skills and a tool that cannot see the most common real layout is not
+     * auditing anything. `DEFAULT_SKIP_DIRS` still excludes `.git`.
+     */
+    includeDotDirs?: boolean;
+    /**
+     * Called once for each directory not entered because `maxDepth` was reached.
+     *
+     * A bound that truncates in silence is the same failure as a check that
+     * examines nothing: the caller sees a short list and no reason for it. This
+     * lets the caller say so.
+     */
+    onDepthLimit?: (dir: string) => void;
+}
+export declare function walkFiles(root: string, opts?: WalkOptions): Generator<string>;
 export declare function readTextSafe(file: string, maxBytes?: number): string | undefined;
 export declare function isBinaryPath(file: string): boolean;
 export declare function extractVersion(s: string): number[] | undefined;

package/dist/util/misc.js

@@ -59,9 +59,15 @@ export function* walkFiles(root, opts = {}) {
         for (const e of entries) {
             const full = path.join(dir, e.name);
             if (e.isDirectory()) {
-                if (depth < maxDepth && !skip.has(e.name) && !e.name.startsWith(".")) {
-                    stack.push({ dir: full, depth: depth + 1 });
+                if (skip.has(e.name))
+                    continue;
+                if (!opts.includeDotDirs && e.name.startsWith("."))
+                    continue;
+                if (depth >= maxDepth) {
+                    opts.onDepthLimit?.(full);
+                    continue;
                 }
+                stack.push({ dir: full, depth: depth + 1 });
             }
             else if (e.isFile()) {
                 yield full;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Kept in sync with package.json by test/meta.test.ts. */
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.5.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Kept in sync with package.json by test/meta.test.ts. */
-export const VERSION = "0.3.0";
+export const VERSION = "0.5.0";

package/docs/RULES.md

@@ -65,7 +65,7 @@ never reused, so a gap is permanent and is better stated than smoothed over.
 | E128 | warn | total tool-definition tax over ~10k / ~25k tokens, estimated (needs `weigh` data); hard CI failure is left to the `--max-tokens`/`--diff` gate |
 | E130 | info | instruction-injection patterns in a tool description or server instructions (shallow heuristic, never a security verdict; use a dedicated scanner for depth). **Reported but never scored** |
 
-## Skills (S101-S106)
+## Skills (S101-S107)
 
 | id | sev | what it catches | spec |
 |---|---|---|---|
@@ -75,6 +75,7 @@ never reused, so a gap is permanent and is better stated than smoothed over.
 | S104 | warn/info | metadata over ~100 tokens, body over ~5k tokens or 500 lines, or long body with no progressive disclosure | agentskills.io |
 | S105 | info | instruction-injection patterns in the skill body or description (shallow heuristic, never a security verdict). **Reported but never scored** | internal |
 | S106 | error/warn/info | referenced file missing, escaping the skill dir (`..`), or nested more than one level deep | agentskills.io |
+| S107 | warn | a file one capitalisation away from a skill, such as `skill.md`. Set-level and never scored: the spec names `SKILL.md` exactly, so it is not a skill here on any platform, but a case-insensitive filesystem (the macOS and Windows default) may hand it to a host, which makes a repository work on a laptop and have no skill at all in Linux CI | internal |
 
 ## Findability (E141-E145)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "efaimo",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Audit what your agent loads: quality and context cost for MCP servers and Agent Skills",
   "keywords": [
     "mcp",
@@ -65,12 +65,14 @@
     "prepublishOnly": "npm run typecheck && npm run build && npm run test"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@modelcontextprotocol/client": "2.0.0",
+    "@modelcontextprotocol/server": "2.0.0",
     "commander": "^15.0.0",
     "cross-spawn": "^7.0.6",
     "gpt-tokenizer": "^3.4.0",
     "picocolors": "^1.1.1",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.0",
+    "zod": "^4.5.4"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",