efaimo 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -4,6 +4,65 @@ 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.1.2] - 2026-08-03
+
+The 0.1.2 code backlog: edge-case fixes surfaced by the five-agent review, none
+of which changes a published number or the documented command surface, plus the
+security and CI hardening already staged.
+
+### Fixed
+
+- `check --mcp <directory>` with no source files and no MCP SDK dependency now
+  fails instead of returning a clean A(100): an empty scan is a failure, never a
+  pass.
+- S101: a skill with no frontmatter reports its missing `name` and `description`
+  as errors, so a total absence no longer grades higher than a broken one.
+- E105: a server that exits on a bare stateless `tools/list` is flagged. The
+  crash outcome was unhandled, so a crashing server looked more migrated than
+  one that answers with a not-initialized error.
+- E124: the "N of M parameters lack descriptions" summary is no longer dropped
+  by the display cap on schemas with five or more oversized enums.
+- S106: the escape check is lexical (the resolved path), not a `..` substring,
+  so a file merely named `notes..md` is not flagged as escaping.
+- A Poetry `mcp = "^2.0"` constraint in `pyproject.toml` is read as the 2.x
+  line, not legacy; the version regex had captured the `=` assignment.
+- `weigh --diff` with a skill baseline fails with a clear message instead of a
+  raw TypeError; a server baseline is required.
+- `--max-tokens` and `--allow-increase` reject non-positive / negative values
+  instead of turning the gate into an always-fail with a nonsense message.
+- `efaimo test --live` against an OpenAI o-series reasoning model no longer
+  sends an unsupported `temperature` (a 400) and gives it token headroom.
+- The live test harness retries a transient 429 or 5xx with backoff instead of
+  discarding every already-paid trial on the first blip.
+- The test report prints a clean note instead of "95% interval NaN to NaN" when
+  an arm produces no scoreable trial.
+- A dead stdio target fails in about one `--timeout`, not two: the legacy
+  handshake and the stateless fallback now share the budget.
+- Internal: dropped a dead exported constant and the unused per-pattern
+  `severity` on the injection heuristics (every hit is info + ungraded by
+  design).
+
+### Security
+
+- The lockfile was re-resolved so the dev/CI tree carries
+  `@hono/node-server` 2.0.12 instead of the 1.19.x line that
+  GHSA-frvp-7c67-39w9 covers (moderate, path traversal in `serve-static`, in
+  the half of the MCP SDK this CLI never executes). A fresh `npx efaimo`
+  install already resolved the patched line; this aligns the committed tree
+  with what users actually get, and `pnpm audit --prod` is clean again.
+
+### Changed
+
+- `@modelcontextprotocol/sdk` floor moved within-range from ^1.29.0 to ^1.30.0
+  (what a fresh install resolves anyway). The full suite (136 tests) is green.
+- CI: the reference-server smoke is pinned to
+  `@modelcontextprotocol/server-everything@2026.7.4`. Per-commit CI should be
+  deterministic; news about the reference server's latest belongs to a
+  scheduled run, not to a push.
+- CI: `spec-drift.yml` and the example workflow now pin actions by commit SHA
+  like the other workflows, and the example declares least-privilege
+  `permissions`.
+
 ## [0.1.1] - 2026-08-02
 
 Everything below was on `main` and unpublished. That gap was itself the
@@ -32,7 +91,7 @@ that notices the next revision by itself.
   hostile server could put ESC[1A ESC[2K in a tool name and rewrite the grade
   line printed above its own finding, so the reader saw "grade A (100), 0
   errors" while the contradiction was erased. `--no-color` did not help; that
-  only suppresses colours efaimo adds.
+  only suppresses colors efaimo adds.
 - `.env` loading is restricted to `ANTHROPIC_API_KEY` and `OPENAI_API_KEY`.
   It previously set ANY key from a working-directory `.env`, so a cloned
   repository could set `NODE_TLS_REJECT_UNAUTHORIZED=0` and silently disable
@@ -40,8 +99,8 @@ that notices the next revision by itself.
   key.
 - Skill references that resolve outside the skill directory are no longer read
   by `weigh`. S106 already warned about them, but only after the read.
-- `SKILL.md` is read through the same 512KB-class cap as referenced files
-  (2MB), instead of an uncapped read.
+- `SKILL.md` is read through a capped read (2MB) on the same guarded path that
+  caps referenced files at 512KB, instead of an uncapped read.
 - The published composite Action no longer interpolates its inputs into a bash
   `run:` body, which was script injection in the consumer's runner.
 
@@ -101,7 +160,7 @@ that notices the next revision by itself.
   extend `CacheableResult`, so that surface is required now, is measured now,
   and the message names whichever surface failed.
 
-## [0.1.0]
+## [0.1.0] - 2026-07-18
 
 First release.
 
@@ -114,7 +173,7 @@ First release.
   broken or auth-gated server is skipped with a reason, not fatal.
   `--out`/`--diff`/`--max-tokens`/`--allow-increase` for CI budget gates,
   `--badge` for a shields endpoint.
-- `efaimo check --mcp`: a quality grade (E121-E130: descriptions, schemas,
+- `efaimo check --mcp`: a quality grade (E121-E128, E130: descriptions, schemas,
   annotations, cost) plus a separate, ungraded 2026-07-28 migration diff
   (E101-E118: what the stateless spec breaks and how to fix it, each item naming
   its SEP). Speaks both the legacy handshake and bare stateless requests, so
@@ -138,5 +197,7 @@ First release.
   Documented rule set (`docs/RULES.md`), token methodology (`docs/METHODOLOGY.md`),
   and integration guide (`docs/INTEGRATIONS.md`).
 
+[unreleased]: https://github.com/efaimo-ai/efaimo/compare/v0.1.2...HEAD
+[0.1.2]: https://github.com/efaimo-ai/efaimo/releases/tag/v0.1.2
 [0.1.1]: https://github.com/efaimo-ai/efaimo/releases/tag/v0.1.1
 [0.1.0]: https://github.com/efaimo-ai/efaimo/releases/tag/v0.1.0

package/README.md

@@ -53,7 +53,7 @@ hygiene. Run it on a folder and every skill gets its own grade, not one aggregat
 **We graded 36 public Agent Skills**: every skill in `anthropics/skills`,
 `anthropics/claude-cookbooks`, and `obra/superpowers`, at pinned commits. 97%
 score an A, but even this curated set has real issues: Anthropic's own
-`claude-api` scores a C with an over-limit description and ~18k-token
+`claude-api` scores a C (73) with an over-limit description and ~18k-token
 instructions, and the median skill's instructions run ~1,632 tokens loaded on
 every trigger. Full report, the corpus manifest, and the two commands that
 reproduce it: [the Skills Quality Index](./research/skills-index/REPORT.md).

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, or add an efaimo badge or CI gate.
 license: Apache-2.0
 metadata:
-  version: "0.1.1"
+  version: "0.1.2"
   homepage: "https://efaimo.ai"
 ---
 
@@ -26,8 +26,8 @@ you would be willing to run yourself. A remote target (`https://...`) is not
 executed and is the safe option for something you do not trust. `--client`
 reads the MCP config files in the current directory as well as your user
 config, so running it inside a repository you did not write means starting the
-servers that repository configured. This warning lives in `SECURITY.md` and did
-not live here, which is the wrong way round: the policy is where humans look,
+servers that repository configured. Until 2026-08-02 this warning lived only in
+`SECURITY.md`, which was the wrong way round: the policy is where humans look,
 and this file is where agents take orders.
 
 - **Weigh context cost of an MCP server**

package/dist/check/check.js

@@ -50,6 +50,14 @@ export async function checkMcpTarget(target, opts = {}) {
 }
 export function checkMcpRepoOnly(repoPath, label) {
     const repo = scanRepo(repoPath);
+    // An empty result is a failure, never a pass. With no source files read and no
+    // dependency manifest naming an MCP SDK, there was nothing to examine here, and
+    // a clean A(100) would be a grade for a directory we never looked inside. Fail
+    // loudly, the way checkSkillSet does for a missing SKILL.md.
+    if (repo.filesScanned === 0 && !repo.sdk) {
+        throw new Error(`no MCP server source found under "${repoPath}": no code files and no SDK dependency. ` +
+            `Point --mcp at the server's run command, or at a directory that contains its source.`);
+    }
     const emptyIntro = {
         targetLabel: label,
         transport: "stdio",

package/dist/cli.js

@@ -82,12 +82,18 @@ function seconds(value, label = "--timeout") {
         fail(`${label} must be a positive number of seconds, got "${value}"`);
     return n;
 }
-function parseNumberOpt(value, label) {
+function parseNumberOpt(value, label, bound) {
     if (value === undefined)
         return undefined;
     const n = Number(value);
     if (!Number.isFinite(n))
         fail(`${label} must be a number, got "${value}"`);
+    // A budget or a percentage below its floor is not a stricter gate, it is a
+    // nonsensical one: `--max-tokens -5` turned "over budget" into always-true
+    // with a negative ceiling in the message. Reject it at the boundary.
+    if (bound && (bound.exclusive ? n <= bound.min : n < bound.min)) {
+        fail(`${label} must be ${bound.exclusive ? "greater than" : "at least"} ${bound.min}, got "${value}"`);
+    }
     return n;
 }
 function anthropicKeyFor(opts) {
@@ -122,8 +128,8 @@ program
     colorSetup(opts);
     windowSetup(opts);
     const timeoutMs = seconds(opts.timeout) * 1000;
-    const maxTokens = parseNumberOpt(opts.maxTokens, "--max-tokens");
-    const allowIncreasePct = parseNumberOpt(opts.allowIncrease, "--allow-increase");
+    const maxTokens = parseNumberOpt(opts.maxTokens, "--max-tokens", { min: 0, exclusive: true });
+    const allowIncreasePct = parseNumberOpt(opts.allowIncrease, "--allow-increase", { min: 0 });
     const anthropic = anthropicKeyFor(opts);
     const targets = [];
     if (opts.client) {
@@ -239,8 +245,14 @@ program
             fail("--diff works on a single MCP server result");
         const baselineRaw = JSON.parse(fs.readFileSync(opts.diff, "utf8"));
         const baseline = ("data" in baselineRaw && baselineRaw.data ? baselineRaw.data : baselineRaw);
-        if (!baseline?.totals)
-            fail(`"${opts.diff}" is not a weigh baseline (write one with --out)`);
+        // A skill weigh baseline also carries a `totals` object, so a bare
+        // truthiness check passed it through and diffServerWeigh then died on the
+        // missing tool array with a raw TypeError. A server baseline is the one
+        // whose totals hold the three serializations; require the Claude-style
+        // total specifically so a skill baseline is rejected with a clear message.
+        if (!baseline?.totals || typeof baseline.totals.claudeStyle !== "number") {
+            fail(`"${opts.diff}" is not an MCP server weigh baseline; write one with: efaimo weigh <server> --out ${opts.diff}`);
+        }
         const d = diffServerWeigh(baseline, single);
         console.log("");
         console.log(opts.md ? renderDiffMarkdown(d) : renderDiffPretty(d, { maxTokens, allowIncreasePct }));

package/dist/clients/introspect.js

@@ -23,14 +23,22 @@ export async function introspectServer(target, opts = {}) {
             stderr: "pipe",
         });
         transport = stdio;
+        // Split the budget across the two attempts so a dead server fails in about
+        // one timeout, not two: the legacy handshake got the whole timeout AND the
+        // stateless fallback then re-waited the whole timeout again, so `--timeout 8`
+        // took ~16s wall. The handshake takes the larger share; the fallback gets
+        // what is left, with a floor so a genuinely stateless server still has time
+        // to answer a bare request.
+        const startedAt = Date.now();
         try {
-            await withTimeout(client.connect(stdio), timeoutMs, "connect (stdio)");
+            await withTimeout(client.connect(stdio), Math.max(1, Math.round(timeoutMs * 0.6)), "connect (stdio)");
         }
         catch (e) {
             await safeClose(client, stdio);
             // A 2026-07-28 stateless server has no initialize, so the SDK handshake
             // fails by design; try bare stateless requests before giving up.
-            const rc = await introspectStateless(target, { timeoutMs });
+            const remaining = Math.max(timeoutMs - (Date.now() - startedAt), Math.round(timeoutMs * 0.25));
+            const rc = await introspectStateless(target, { timeoutMs: remaining });
             if (rc)
                 return rc;
             throw connectError(e, target.label, stderrTail);

package/dist/reporters/pretty.js

@@ -103,7 +103,9 @@ export function renderTestReportPretty(r) {
         `  with skill     ${r.withSkill.passes}/${r.withSkill.scored} pass  (${r.withSkill.passRate.toFixed(0)}%)`,
         `  without skill  ${r.withoutSkill.passes}/${r.withoutSkill.scored} pass  (${r.withoutSkill.passRate.toFixed(0)}%)`,
         `  delta          ${paint(pc.bold, `${sign}${r.deltaPoints} points`)}   ${paint(verdictColor, r.verdict)}`,
-        `  significance   p = ${r.p < 0.0001 ? "<0.0001" : r.p.toFixed(4)}   95% CI ${r.ci.lo >= 0 ? "+" : ""}${r.ci.lo} to ${r.ci.hi >= 0 ? "+" : ""}${r.ci.hi} points`,
+        Number.isFinite(r.ci.lo)
+            ? `  significance   p = ${r.p < 0.0001 ? "<0.0001" : r.p.toFixed(4)}   95% CI ${r.ci.lo >= 0 ? "+" : ""}${r.ci.lo} to ${r.ci.hi >= 0 ? "+" : ""}${r.ci.hi} points`
+            : `  significance   not computable: an arm produced no scoreable trial`,
         "",
     ];
     for (const n of r.notes)

package/dist/rules/injection.d.ts

@@ -1,8 +1,7 @@
-import type { Finding, Severity } from "../core/types.js";
+import type { Finding } from "../core/types.js";
 interface InjectionPattern {
     key: string;
     re: RegExp;
-    severity: Severity;
     label: string;
 }
 /**

package/dist/rules/injection.js

@@ -9,19 +9,16 @@ export const INJECTION_PATTERNS = [
     {
         key: "override-instructions",
         re: /ignore\s+(?:all\s+|any\s+)?(?:previous|prior|earlier|above)\s+(?:instructions|messages|rules|prompts)/i,
-        severity: "error",
         label: "attempts to override prior instructions",
     },
     {
         key: "hide-from-user",
         re: /do\s+not\s+(?:tell|reveal|mention|inform|show|disclose)\b[\s\S]{0,40}\b(?:user|human|operator)/i,
-        severity: "error",
         label: "instructs the agent to hide behavior from the user",
     },
     {
         key: "act-without-consent",
         re: /without\s+(?:telling|asking|notifying|informing)\s+(?:the\s+)?(?:user|human)/i,
-        severity: "error",
         label: "instructs the agent to act without user consent",
     },
     {
@@ -29,51 +26,43 @@ export const INJECTION_PATTERNS = [
         // "post" and "token" dropped: they match API documentation ("Token counting
         // POST /v1/...") far more than exfiltration.
         re: /\b(?:api[_-]?key|secret|password|credential)s?\b[\s\S]{0,40}\b(?:send|forward|exfiltrat|upload|leak|transmit|include\s+it)\b/i,
-        severity: "error",
         label: "references sending credentials or secrets somewhere",
     },
     {
         key: "sensitive-file-read",
         re: /\b(?:read|open|cat|print|upload)\b[\s\S]{0,40}(?:\.env\b|\.ssh\b|id_rsa|credentials|\.aws\b|\.npmrc\b)/i,
-        severity: "error",
         label: "references reading sensitive local files",
     },
     {
         key: "disable-safety",
         re: /\b(?:disable|bypass|ignore|remove)\s+(?:safety|guardrails?|filters?|restrictions?|policy|policies)\b/i,
-        severity: "error",
         label: "asks to bypass safety or policy",
     },
     {
         key: "cross-tool-steering",
         re: /before\s+(?:using|calling|running)\b[^.?!]{0,40}?\btools?\b[\s,]{1,4}(?:always\s+|first\s+|please\s+)?(?:call|run|use|fetch|invoke)\b/i,
-        severity: "warn",
         label: "steers the agent to call another tool first (cross-tool steering)",
     },
     {
         key: "templated-exfil-url",
         // Bounded runs (no adjacent unbounded same-class quantifiers) to avoid ReDoS.
         re: /https?:\/\/[^\s"'<>]{1,150}[?&][^\s"'<>]{0,150}(?:\$\{[^}]{1,60}\}|\{\{[^}]{1,60}\}\}|\{[^}]{1,60}\})/,
-        severity: "warn",
         label: "URL with a templated query parameter (possible exfiltration channel)",
     },
     {
         key: "zero-width-chars",
         // eslint-disable-next-line no-control-regex
         re: /[​‌‍⁠]/,
-        severity: "warn",
         label: "zero-width or invisible characters present",
     },
     {
         key: "hidden-html-comment",
         re: /<!--[^>]{0,240}\b(?:must|always|never|call|run|fetch|send|ignore)\b[^>]{0,240}-->/i,
-        severity: "warn",
         label: "HTML comment containing imperative instructions (hidden from rendered view)",
     },
     {
         key: "persona-override",
         re: /\byou\s+are\s+now\b|\bpretend\s+to\s+be\b|\bnew\s+system\s+prompt\b/i,
-        severity: "warn",
         label: "persona or system-prompt override language",
     },
 ];

package/dist/rules/mcp/index.js

@@ -166,6 +166,23 @@ const e105 = {
                 },
             ];
         }
+        if (bare.kind === "exit") {
+            // A crash on the bare request is not a timeout and not a clean answer: the
+            // server did not serve a stateless tools/list, so a 2026-07-28 client
+            // cannot talk to it. Left unhandled, this outcome produced NO finding, so
+            // a crashing server looked one item MORE migrated than one that answers
+            // with a not-initialized error.
+            return [
+                {
+                    ruleId: "E105",
+                    severity: "warn",
+                    title: "requires the removed initialize handshake",
+                    message: `the server process exited on a bare stateless tools/list (${bare.errorMessage ?? "no reply"}), so it does not answer requests without a prior initialize`,
+                    detail: `${SPEC} removes initialize and sessions; a server that exits on a bare request cannot serve a ${SPEC} client. A server that answers, even with an error, is judged by E106/E107/E118 instead.`,
+                    fixHint: "upgrade to a 2.x SDK, or answer requests without a prior initialize instead of exiting",
+                },
+            ];
+        }
         if (bare.kind === "timeout") {
             return [
                 {
@@ -526,7 +543,10 @@ const e124 = {
             }
         }
         if (totalParams > 5 && undocumented / totalParams > 0.3) {
-            findings.push({
+            // Prepend, not append: capList keeps the first 5, and on the worst schemas
+            // (5+ oversized enums) an appended summary was exactly the line that got
+            // dropped. The aggregate is the headline, so it leads.
+            findings.unshift({
                 ruleId: "E124",
                 severity: "warn",
                 title: "schema issues",

package/dist/rules/skill/index.js

@@ -16,8 +16,10 @@ const s101 = {
         const push = (severity, message, fixHint) => findings.push({ ruleId: "S101", severity, title: "frontmatter does not match the spec", message, target: label, fixHint });
         if (skill.parseError) {
             push("error", `${skill.file}: ${skill.parseError}`, "SKILL.md must start with a --- YAML frontmatter block");
-            if (!skill.frontmatterRaw)
-                return findings;
+            // No early return on empty frontmatter. Returning here after one error let
+            // a skill with NO frontmatter grade higher than one with BROKEN frontmatter
+            // (the required-field checks below never ran), so total absence outscored a
+            // typo by two errors. Absent fields ARE missing fields; report them too.
         }
         const name = skill.frontmatter.name;
         if (typeof name !== "string" || !name.trim()) {
@@ -254,7 +256,7 @@ const s106 = {
                     fixHint: "agents will fail mid-task when they try to open it",
                 });
             }
-            else if (ref.raw.includes("..")) {
+            else if (ref.escapes) {
                 findings.push({
                     ruleId: "S106",
                     severity: "warn",

package/dist/testing/harness.d.ts

@@ -63,4 +63,5 @@ export declare function armSystems(scenario: Scenario): {
     withoutSkill: string | undefined;
     withSkill: string;
 };
+export declare function withRetry(runner: Runner, tries?: number, baseDelayMs?: number): Runner;
 export declare function runScenario(scenario: Scenario, runner: Runner): Promise<TestReport>;

package/dist/testing/harness.js

@@ -71,6 +71,32 @@ async function judgeOne(runner, scenario, answer) {
         return "fail";
     return "unparseable";
 }
+// A live run makes trials * 2 arms * 2 (answer + judge) API calls. One
+// transient 429 or 5xx among them used to throw and discard every trial already
+// paid for. Retry the transient failures with backoff; a non-429 4xx (bad key,
+// unknown model) is a real error and is not retried.
+function isTransient(err) {
+    const m = String(err?.message ?? err);
+    return (/\b(429|500|502|503|504)\b/.test(m) ||
+        /timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|fetch failed|network/i.test(m));
+}
+export function withRetry(runner, tries = 4, baseDelayMs = 500) {
+    return async (req) => {
+        let lastErr;
+        for (let attempt = 0; attempt < tries; attempt++) {
+            try {
+                return await runner(req);
+            }
+            catch (e) {
+                lastErr = e;
+                if (attempt === tries - 1 || !isTransient(e))
+                    throw e;
+                await new Promise((r) => setTimeout(r, baseDelayMs * 2 ** attempt));
+            }
+        }
+        throw lastErr;
+    };
+}
 async function runArm(runner, scenario, system) {
     let passes = 0;
     let unparseable = 0;
@@ -95,8 +121,11 @@ async function runArm(runner, scenario, system) {
 }
 export async function runScenario(scenario, runner) {
     const systems = armSystems(scenario);
-    const withoutSkill = await runArm(runner, scenario, systems.withoutSkill);
-    const withSkill = await runArm(runner, scenario, systems.withSkill);
+    // Wrap once so both the subject answers and the judge calls survive a
+    // transient blip instead of throwing away the whole (paid-for) scenario.
+    const r = withRetry(runner);
+    const withoutSkill = await runArm(r, scenario, systems.withoutSkill);
+    const withSkill = await runArm(r, scenario, systems.withSkill);
     const deltaPoints = Math.round((withSkill.passRate - withoutSkill.passRate) * 10) / 10;
     // The verdict is a significance test, not a threshold on the gap.
     //
@@ -108,9 +137,14 @@ export async function runScenario(scenario, runner) {
     // measuring sample size more than it was measuring the skill.
     const p = fisherExactTwoSided(withSkill.passes, withSkill.scored, withoutSkill.passes, withoutSkill.scored);
     const ci = deltaInterval(withSkill.passes, withSkill.scored, withoutSkill.passes, withoutSkill.scored);
+    // With no scoreable trial in an arm the pass rate and its interval are
+    // 0/0 = NaN; say so plainly instead of printing "NaN to NaN points".
+    const bothScored = withSkill.scored > 0 && withoutSkill.scored > 0;
     const notes = [
-        `${scenario.trials} trials per arm. Two-sided Fisher exact p = ${p < 0.0001 ? "<0.0001" : p.toFixed(4)}; ` +
-            `95% interval on the delta ${ci.lo >= 0 ? "+" : ""}${ci.lo} to ${ci.hi >= 0 ? "+" : ""}${ci.hi} points.`,
+        bothScored
+            ? `${scenario.trials} trials per arm. Two-sided Fisher exact p = ${p < 0.0001 ? "<0.0001" : p.toFixed(4)}; ` +
+                `95% interval on the delta ${ci.lo >= 0 ? "+" : ""}${ci.lo} to ${ci.hi >= 0 ? "+" : ""}${ci.hi} points.`
+            : `${scenario.trials} trials per arm. An arm produced no scoreable trial, so no p-value or delta interval can be computed.`,
     ];
     const unscored = withSkill.unparseable + withoutSkill.unparseable;
     if (unscored) {

package/dist/testing/openaiRunner.js

@@ -8,20 +8,27 @@ export function openaiRunner(apiKey) {
         if (req.system)
             messages.push({ role: "system", content: req.system });
         messages.push({ role: "user", content: req.user });
+        // o-series reasoning models (o1, o3, o4, ...) reject any non-default
+        // temperature with a 400, and a chat-sized 1024 cap starves them: their
+        // hidden reasoning tokens count against max_completion_tokens, so a small
+        // cap can return empty content. So omit temperature and give them headroom.
+        const isReasoning = /^o[0-9]/i.test(req.model);
+        const body = {
+            model: req.model,
+            messages,
+            max_completion_tokens: isReasoning ? 8192 : 1024,
+        };
+        // temperature: 0 for the judge, 1 for the subject (see
+        // RunnerRequest.deterministic), but only where the model accepts it.
+        if (!isReasoning)
+            body.temperature = req.deterministic ? 0 : 1;
         const res = await fetch("https://api.openai.com/v1/chat/completions", {
             method: "POST",
             headers: {
                 "content-type": "application/json",
                 authorization: `Bearer ${apiKey}`,
             },
-            // temperature: 0 for the judge, 1 for the subject. See
-            // RunnerRequest.deterministic in harness.ts.
-            body: JSON.stringify({
-                model: req.model,
-                temperature: req.deterministic ? 0 : 1,
-                messages,
-                max_completion_tokens: 1024,
-            }),
+            body: JSON.stringify(body),
             redirect: "error",
             signal: AbortSignal.timeout(60000),
         });

package/dist/testing/stats.d.ts

@@ -28,5 +28,3 @@ export declare function deltaInterval(withPass: number, withTrials: number, with
     lo: number;
     hi: number;
 };
-/** The smallest per-arm trial count at which a total separation (n/n vs 0/n) reaches p < 0.05. */
-export declare const MIN_TRIALS_FOR_SIGNIFICANCE = 4;

package/dist/testing/stats.js

@@ -87,5 +87,3 @@ export function deltaInterval(withPass, withTrials, withoutPass, withoutTrials)
     const hi = d + Math.sqrt((w.hi - p1) ** 2 + (p2 - o.lo) ** 2);
     return { lo: Math.round(Math.max(-1, lo) * 1000) / 10, hi: Math.round(Math.min(1, hi) * 1000) / 10 };
 }
-/** The smallest per-arm trial count at which a total separation (n/n vs 0/n) reaches p < 0.05. */
-export const MIN_TRIALS_FOR_SIGNIFICANCE = 4;

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.1.1";
+export declare const VERSION = "0.1.2";

package/dist/version.js

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

package/docs/METHODOLOGY.md

@@ -127,7 +127,7 @@ attached. The default is 20 trials per arm: below roughly that, a partial
 result cannot reach significance at all.
 
 Until 2026-08-02 the rule was `>= +15 points helps`, with a default of 5
-trials. At that size 5/5 against 4/5 is +20 points and p = 1.0000. See ADR-028.
+trials. At that size 5/5 against 4/5 is +20 points and p = 1.0000.
 
 Two things the judge does, which matter for reading a result:
 

package/docs/RULES.md

@@ -22,11 +22,11 @@ rules are heuristics and say so in their detail line.
 
 | id | sev | what it catches | source of truth |
 |---|---|---|---|
-| E101 | warn | depends on a pre-`2026-07-28` SDK line (TS `@modelcontextprotocol/sdk` 1.x, Python `mcp` 1.x) instead of the 2.x stateless line | changelog / SDK releases |
+| E101 | warn | depends on a pre-`2026-07-28` SDK line (TS `@modelcontextprotocol/sdk` 1.x, Python `mcp` 1.x) instead of the stateless successors (TS `@modelcontextprotocol/server` 2.x, Python `mcp` 2.x) | changelog / SDK releases |
 | E102 | warn | source uses **Sampling** (`sampling/createMessage`), deprecated (SEP-2577) | 2026-07-28 changelog |
 | E103 | warn | source uses **Roots** (`roots/list`), deprecated (SEP-2577) | 2026-07-28 changelog |
 | E104 | warn | server declares the **logging** capability or source uses MCP Logging, deprecated (SEP-2577); `logging/setLevel` is removed | 2026-07-28 changelog |
-| E105 | warn | the server does not answer a bare stateless `tools/list` (timeout, crash, or a not-initialized error), so it requires the removed `initialize` handshake. A server that answers (even with an error) is judged by E106/E107/E118 instead | SEP-2567 / stateless core |
+| E105 | warn | the server rejects a bare stateless `tools/list` with a not-initialized error, or exits on it, so it still requires the removed `initialize` handshake. A timeout is reported as unverified statelessness rather than as this warn, and a server that answers (even with another error) is judged by E106/E107/E118 instead | SEP-2567 / stateless core |
 | E106 | warn | `server/discover` is not implemented (MUST in 2026-07-28, SEP-2575) | 2026-07-28 changelog |
 | E107 | info | results omit the required `resultType` field (`"complete"` \| `"input_required"`) | 2026-07-28 changelog |
 | E108 | info | source relies on removed SSE resumability (`Last-Event-ID`) | 2026-07-28 changelog |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "efaimo",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Audit what your agent loads: quality and context cost for MCP servers and Agent Skills",
   "keywords": [
     "mcp",
@@ -63,7 +63,7 @@
     "prepublishOnly": "npm run typecheck && npm run build && npm run test"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "commander": "^15.0.0",
     "cross-spawn": "^7.0.6",
     "gpt-tokenizer": "^3.4.0",