efaimo 0.1.0

package/dist/reporters/markdown.js

@@ -0,0 +1,121 @@
+import { VERSION } from "../version.js";
+const SEV_LABEL = { error: "🔴 error", warn: "🟡 warn", info: "🔵 info" };
+function esc(s) {
+    return s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+function findingsTable(lines, findings) {
+    lines.push("| severity | rule | finding |");
+    lines.push("|---|---|---|");
+    for (const f of findings) {
+        lines.push(`| ${SEV_LABEL[f.severity]} | ${f.ruleId} | ${esc(f.message)} |`);
+    }
+}
+export function renderCheckMarkdown(report) {
+    const lines = [];
+    lines.push(`## efaimo check (${report.surface}): grade ${report.grade.letter} (${report.grade.score})`);
+    lines.push("");
+    lines.push(`target: \`${report.target}\``);
+    lines.push("");
+    if (!report.findings.length) {
+        lines.push(report.readiness ? "no quality findings. clean." : "no findings. clean.");
+    }
+    else {
+        findingsTable(lines, report.findings);
+    }
+    if (report.readiness) {
+        lines.push("");
+        lines.push(`### 2026-07-28 readiness (a migration diff, not graded)`);
+        lines.push("");
+        if (report.readiness.findings.length) {
+            findingsTable(lines, report.readiness.findings);
+        }
+        else {
+            lines.push("clean, nothing to migrate.");
+        }
+    }
+    lines.push("");
+    for (const note of report.notes)
+        lines.push(`> ${esc(note)}`);
+    lines.push("");
+    lines.push(`<sub>generated by [efaimo](https://github.com/efaimo-ai/efaimo) v${report.version} | [rule docs](https://github.com/efaimo-ai/efaimo/blob/main/docs/RULES.md)</sub>`);
+    return lines.join("\n");
+}
+export function renderSkillSetMarkdown(res) {
+    const lines = [];
+    lines.push(`## efaimo check: ${res.perSkill.length} Agent Skills`);
+    lines.push("");
+    lines.push("| skill | grade | errors | warnings | info |");
+    lines.push("|---|---|---|---|---|");
+    for (const s of [...res.perSkill].sort((a, b) => a.report.grade.score - b.report.grade.score)) {
+        const c = s.report.counts;
+        lines.push(`| \`${esc(s.name)}\` | ${s.report.grade.letter} (${s.report.grade.score}) | ${c.error} | ${c.warn} | ${c.info} |`);
+    }
+    if (res.setFindings.length) {
+        lines.push("");
+        lines.push("**Across the set**");
+        for (const f of res.setFindings)
+            lines.push(`- ${SEV_LABEL[f.severity]} ${f.ruleId}: ${esc(f.message)}`);
+    }
+    lines.push("");
+    lines.push(`<sub>generated by [efaimo](https://github.com/efaimo-ai/efaimo) v${VERSION}</sub>`);
+    return lines.join("\n");
+}
+export function renderWeighMarkdown(w) {
+    const lines = [];
+    if (w.kind === "mcp") {
+        lines.push(`## efaimo weigh: \`${w.label}\``);
+        lines.push("");
+        lines.push(`tools ${w.toolCount} | resources ${w.resourceCount} | prompts ${w.promptCount}`);
+        lines.push("");
+        lines.push("| serialization | tokens (o200k, est.) |");
+        lines.push("|---|---|");
+        lines.push(`| raw JSON | ${w.totals.rawJson.toLocaleString("en-US")} |`);
+        lines.push(`| Claude-style | ${w.totals.claudeStyle.toLocaleString("en-US")} |`);
+        lines.push(`| OpenAI tools | ${w.totals.openaiTools.toLocaleString("en-US")} |`);
+        if (w.anthropicExactTotal !== undefined) {
+            lines.push(`| anthropic exact (API) | ${w.anthropicExactTotal.toLocaleString("en-US")} |`);
+        }
+        lines.push("");
+        if (w.perTool.length) {
+            lines.push("| heaviest tools | tokens | desc | schema |");
+            lines.push("|---|---|---|---|");
+            for (const t of w.perTool.slice(0, 10)) {
+                lines.push(`| \`${esc(t.name)}\` | ${t.tokens.claudeStyle} | ${t.descriptionTokens} | ${t.schemaTokens} |`);
+            }
+            if (w.framingTokens !== undefined && w.framingTokens > 0) {
+                lines.push(`| block framing (\`<functions>\` wrapper) | ${w.framingTokens} | - | - |`);
+            }
+        }
+    }
+    else {
+        lines.push(`## efaimo weigh (skills): \`${w.label}\``);
+        lines.push("");
+        lines.push("| skill | metadata (always) | body (on trigger) | lines | referenced files |");
+        lines.push("|---|---|---|---|---|");
+        for (const s of w.perSkill) {
+            lines.push(`| \`${esc(s.name)}\` | ${s.metadataTokens} | ${s.bodyTokens} | ${s.bodyLines} | ${s.refFileCount ? `${s.refFileCount} (${s.refFileTokens} tok)` : "-"} |`);
+        }
+        lines.push("");
+        lines.push(`totals: metadata **${w.totals.metadata}** | body **${w.totals.body}** | referenced **${w.totals.refFiles}**`);
+    }
+    lines.push("");
+    for (const note of w.notes)
+        lines.push(`> ${esc(note)}`);
+    return lines.join("\n");
+}
+export function renderDiffMarkdown(d) {
+    const sign = d.delta >= 0 ? "+" : "";
+    const lines = [];
+    lines.push(`## efaimo weigh diff`);
+    lines.push("");
+    lines.push(`Claude-style total: ${d.before.toLocaleString("en-US")} -> ${d.after.toLocaleString("en-US")} (**${sign}${d.delta.toLocaleString("en-US")}**, ${sign}${d.pct.toFixed(1)}%)`);
+    if (d.toolChanges.length) {
+        lines.push("");
+        lines.push("| tool | before | after |");
+        lines.push("|---|---|---|");
+        for (const t of d.toolChanges.slice(0, 15)) {
+            lines.push(`| \`${esc(t.name)}\` | ${t.before ?? "added"} | ${t.after ?? "removed"} |`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/reporters/pretty.d.ts

@@ -0,0 +1,15 @@
+import type { CheckReport, ServerWeighResult, SkillSetWeighResult } from "../core/types.js";
+import type { CheckSkillResult } from "../check/check.js";
+import type { Scenario, TestReport } from "../testing/harness.js";
+import type { WeighDiff } from "../weigh/diff.js";
+export declare function setColor(on: boolean): void;
+export declare function renderCheckPretty(report: CheckReport): string;
+export declare function renderScenarioPlan(s: Scenario): string;
+export declare function renderTestReportPretty(r: TestReport): string;
+export declare function renderSkillSetPretty(res: CheckSkillResult): string;
+export declare function renderServerWeighPretty(w: ServerWeighResult): string;
+export declare function renderSkillWeighPretty(w: SkillSetWeighResult): string;
+export declare function renderDiffPretty(d: WeighDiff, opts: {
+    maxTokens?: number;
+    allowIncreasePct?: number;
+}): string;

package/dist/reporters/pretty.js

@@ -0,0 +1,221 @@
+import pc from "picocolors";
+import { sortFindings } from "../core/grade.js";
+import { VERSION } from "../version.js";
+const DOCS_RULES = "https://github.com/efaimo-ai/efaimo/blob/main/docs/RULES.md";
+let colorOn = true;
+export function setColor(on) {
+    colorOn = on;
+}
+function paint(fn, s) {
+    return colorOn ? fn(s) : s;
+}
+function sevGlyph(f) {
+    if (f.severity === "error")
+        return paint(pc.red, "x");
+    if (f.severity === "warn")
+        return paint(pc.yellow, "!");
+    return paint(pc.cyan, "i");
+}
+function gradeColor(letter, text) {
+    if (letter === "A")
+        return paint(pc.green, text);
+    if (letter === "B")
+        return paint(pc.green, text);
+    if (letter === "C")
+        return paint(pc.yellow, text);
+    if (letter === "D")
+        return paint(pc.yellow, text);
+    return paint(pc.red, text);
+}
+function n(x) {
+    return x.toLocaleString("en-US");
+}
+function renderFinding(lines, f) {
+    lines.push(`  ${sevGlyph(f)} ${paint(pc.bold, f.ruleId)}  ${f.message}`);
+    if (f.detail) {
+        for (const d of f.detail.split("\n"))
+            lines.push(paint(pc.dim, `          ${d}`));
+    }
+    if (f.fixHint)
+        lines.push(paint(pc.dim, `          fix: ${f.fixHint}`));
+}
+export function renderCheckPretty(report) {
+    const lines = [];
+    lines.push(paint(pc.dim, `efaimo v${VERSION}`));
+    lines.push(`check ${report.surface}  ${paint(pc.bold, report.target)}`);
+    const g = report.grade;
+    const qualityLabel = report.readiness ? "quality: " : "";
+    lines.push(`grade ${gradeColor(g.letter, `${g.letter} (${g.score})`)}   ${qualityLabel}` +
+        `${paint(pc.red, String(report.counts.error))} error${report.counts.error === 1 ? "" : "s"}  ` +
+        `${paint(pc.yellow, String(report.counts.warn))} warning${report.counts.warn === 1 ? "" : "s"}  ` +
+        `${paint(pc.cyan, String(report.counts.info))} info`);
+    lines.push("");
+    if (!report.findings.length) {
+        lines.push(paint(pc.green, report.readiness ? "  no quality findings. clean." : "  no findings. clean."));
+    }
+    for (const f of report.findings)
+        renderFinding(lines, f);
+    if (report.readiness) {
+        const r = report.readiness;
+        lines.push("");
+        if (r.findings.length) {
+            lines.push(paint(pc.bold, `2026-07-28 readiness`) +
+                `  ${r.findings.length} item${r.findings.length === 1 ? "" : "s"} to migrate ` +
+                paint(pc.dim, "(a migration diff, not graded: the spec finalizes 2026-07-28)"));
+            for (const f of r.findings)
+                renderFinding(lines, f);
+        }
+        else {
+            lines.push(paint(pc.bold, `2026-07-28 readiness`) + paint(pc.green, "  clean, nothing to migrate"));
+        }
+    }
+    lines.push("");
+    for (const note of report.notes)
+        lines.push(paint(pc.dim, `note: ${note}`));
+    lines.push(paint(pc.dim, `rules: ${DOCS_RULES}`));
+    return lines.join("\n");
+}
+export function renderScenarioPlan(s) {
+    const calls = s.trials * 2 * 2;
+    const firstLine = s.task.split("\n")[0].slice(0, 60);
+    return [
+        paint(pc.dim, `efaimo v${VERSION}`),
+        `test (dry run)  ${paint(pc.bold, s.name)}`,
+        "",
+        `  skill   ${s.skillName}`,
+        `  model   ${s.model}`,
+        `  plan    ${s.trials} trials x 2 arms x (task + judge) = ${paint(pc.bold, String(calls))} API calls`,
+        `  task    ${paint(pc.dim, firstLine + (s.task.length > 60 ? "..." : ""))}`,
+        "",
+        paint(pc.yellow, "dry run: no API calls made. add --live to run it (Claude models need ANTHROPIC_API_KEY, GPT models need OPENAI_API_KEY)."),
+    ].join("\n");
+}
+export function renderTestReportPretty(r) {
+    const verdictColor = r.verdict === "helps" ? pc.green : r.verdict === "hurts" ? pc.red : pc.yellow;
+    const sign = r.deltaPoints >= 0 ? "+" : "";
+    const lines = [
+        paint(pc.dim, `efaimo v${VERSION}`),
+        `test  ${paint(pc.bold, r.scenario)}`,
+        `skill ${r.skill}   model ${r.model}`,
+        "",
+        `  with skill     ${r.withSkill.passes}/${r.withSkill.trials} pass  (${r.withSkill.passRate.toFixed(0)}%)`,
+        `  without skill  ${r.withoutSkill.passes}/${r.withoutSkill.trials} pass  (${r.withoutSkill.passRate.toFixed(0)}%)`,
+        `  delta          ${paint(pc.bold, `${sign}${r.deltaPoints} points`)}   ${paint(verdictColor, r.verdict)}`,
+        "",
+    ];
+    for (const n of r.notes)
+        lines.push(paint(pc.dim, `note: ${n}`));
+    return lines.join("\n");
+}
+export function renderSkillSetPretty(res) {
+    const lines = [];
+    lines.push(paint(pc.dim, `efaimo v${VERSION}`));
+    lines.push(`check skills  ${paint(pc.bold, res.label)}   ${res.perSkill.length} skill${res.perSkill.length === 1 ? "" : "s"}`);
+    const dist = { A: 0, B: 0, C: 0, D: 0, F: 0 };
+    for (const s of res.perSkill)
+        dist[s.report.grade.letter]++;
+    lines.push("");
+    lines.push("grades  " +
+        ["A", "B", "C", "D", "F"]
+            .map((g) => (dist[g] ? `${gradeColor(g, g)}x${dist[g]}` : ""))
+            .filter(Boolean)
+            .join("   "));
+    lines.push("");
+    const nameW = Math.min(34, Math.max(8, ...res.perSkill.map((s) => s.name.length)));
+    for (const s of [...res.perSkill].sort((a, b) => a.report.grade.score - b.report.grade.score)) {
+        const g = s.report.grade;
+        const c = s.report.counts;
+        lines.push(`  ${gradeColor(g.letter, `${g.letter} (${String(g.score).padStart(3)})`)}  ${s.name.padEnd(nameW)}  ` +
+            `${paint(pc.red, String(c.error))}e ${paint(pc.yellow, String(c.warn))}w ${paint(pc.cyan, String(c.info))}i`);
+    }
+    if (res.setFindings.length) {
+        lines.push("");
+        lines.push(paint(pc.bold, "across the set"));
+        for (const f of sortFindings(res.setFindings)) {
+            lines.push(`  ${sevGlyph(f)} ${paint(pc.bold, f.ruleId)}  ${f.message}`);
+        }
+    }
+    const flagged = res.perSkill.filter((s) => s.report.findings.length);
+    if (flagged.length) {
+        lines.push("");
+        for (const s of flagged) {
+            lines.push(paint(pc.bold, `${s.name}  ${gradeColor(s.report.grade.letter, s.report.grade.letter)}`));
+            for (const f of s.report.findings) {
+                lines.push(`  ${sevGlyph(f)} ${paint(pc.bold, f.ruleId)}  ${f.message}`);
+                if (f.fixHint)
+                    lines.push(paint(pc.dim, `          fix: ${f.fixHint}`));
+            }
+        }
+    }
+    lines.push("");
+    lines.push(paint(pc.dim, `${res.perSkill.length} skills under ${res.root}`));
+    lines.push(paint(pc.dim, `rules: ${DOCS_RULES}`));
+    return lines.join("\n");
+}
+export function renderServerWeighPretty(w) {
+    const lines = [];
+    lines.push(paint(pc.dim, `efaimo v${VERSION}`));
+    lines.push(`weigh mcp  ${paint(pc.bold, w.label)}`);
+    lines.push(`tools ${w.toolCount}   resources ${w.resourceCount}   prompts ${w.promptCount}`);
+    lines.push("");
+    lines.push("context cost of tool definitions (o200k tokens, estimated)");
+    const pct = ((w.totals.claudeStyle / 200000) * 100).toFixed(1);
+    lines.push(`  raw JSON        ${n(w.totals.rawJson).padStart(8)}`);
+    lines.push(`  Claude-style    ${n(w.totals.claudeStyle).padStart(8)}   (~${pct}% of a 200k window)`);
+    lines.push(`  OpenAI tools    ${n(w.totals.openaiTools).padStart(8)}`);
+    if (w.instructionsTokens > 0)
+        lines.push(`  server instructions ${n(w.instructionsTokens).padStart(4)}`);
+    if (w.anthropicExactTotal !== undefined) {
+        lines.push(`  ${paint(pc.green, "anthropic exact")} ${n(w.anthropicExactTotal).padStart(8)}   (count_tokens API)`);
+    }
+    if (w.perTool.length) {
+        lines.push("");
+        lines.push("heaviest tools (Claude-style)");
+        for (const [i, t] of w.perTool.slice(0, 8).entries()) {
+            lines.push(`  ${String(i + 1).padStart(2)}. ${t.name.padEnd(28)} ${n(t.tokens.claudeStyle).padStart(7)}   desc ${n(t.descriptionTokens)} | schema ${n(t.schemaTokens)}`);
+        }
+        if (w.perTool.length > 8)
+            lines.push(paint(pc.dim, `      (+${w.perTool.length - 8} more)`));
+        if (w.framingTokens !== undefined && w.framingTokens > 0) {
+            lines.push(paint(pc.dim, `      block framing ${" ".repeat(15)}${n(w.framingTokens).padStart(7)}   (<functions> wrapper; per-tool lines + this = total)`));
+        }
+    }
+    lines.push("");
+    for (const note of w.notes)
+        lines.push(paint(pc.dim, `note: ${note}`));
+    return lines.join("\n");
+}
+export function renderSkillWeighPretty(w) {
+    const lines = [];
+    lines.push(paint(pc.dim, `efaimo v${VERSION}`));
+    lines.push(`weigh skills  ${paint(pc.bold, w.label)}   ${w.perSkill.length} skill${w.perSkill.length === 1 ? "" : "s"}`);
+    lines.push("");
+    lines.push(`  ${"skill".padEnd(28)} ${"metadata".padStart(8)} ${"body".padStart(9)} ${"lines".padStart(6)}  refs`);
+    for (const s of w.perSkill) {
+        lines.push(`  ${s.name.padEnd(28)} ${n(s.metadataTokens).padStart(8)} ${n(s.bodyTokens).padStart(9)} ${String(s.bodyLines).padStart(6)}  ${s.refFileCount ? `${s.refFileCount} files ${n(s.refFileTokens)}` : "-"}`);
+    }
+    lines.push("");
+    lines.push(`totals: metadata ${paint(pc.bold, n(w.totals.metadata))} (always loaded) | body ${n(w.totals.body)} (on trigger) | referenced ${n(w.totals.refFiles)} (on demand)`);
+    lines.push("");
+    for (const note of w.notes)
+        lines.push(paint(pc.dim, `note: ${note}`));
+    return lines.join("\n");
+}
+export function renderDiffPretty(d, opts) {
+    const lines = [];
+    const sign = d.delta >= 0 ? "+" : "";
+    const deltaText = `${sign}${n(d.delta)} tokens (${sign}${d.pct.toFixed(1)}%)`;
+    lines.push(`context budget diff (Claude-style): ${n(d.before)} -> ${n(d.after)}  ${d.delta > 0 ? paint(pc.yellow, deltaText) : paint(pc.green, deltaText)}`);
+    for (const t of d.toolChanges.slice(0, 10)) {
+        const b = t.before === undefined ? "added" : n(t.before);
+        const a = t.after === undefined ? "removed" : n(t.after);
+        lines.push(`  ${t.name.padEnd(28)} ${b} -> ${a}`);
+    }
+    if (opts.maxTokens !== undefined && d.after > opts.maxTokens) {
+        lines.push(paint(pc.red, `budget exceeded: ${n(d.after)} > --max-tokens ${n(opts.maxTokens)}`));
+    }
+    if (opts.allowIncreasePct !== undefined && d.pct > opts.allowIncreasePct) {
+        lines.push(paint(pc.red, `increase ${d.pct.toFixed(1)}% > --allow-increase ${opts.allowIncreasePct}%`));
+    }
+    return lines.join("\n");
+}

package/dist/rules/injection.d.ts

@@ -0,0 +1,20 @@
+import type { Finding, Severity } from "../core/types.js";
+interface InjectionPattern {
+    key: string;
+    re: RegExp;
+    severity: Severity;
+    label: string;
+}
+/**
+ * Surface-level heuristics for instruction-injection patterns in text an agent
+ * will read (tool descriptions, skill bodies). This is intentionally a linter,
+ * not a security scanner: deep analysis belongs to dedicated tools
+ * (Snyk agent-scan, Cisco MCP Scanner). Patterns favor precision over recall.
+ */
+export declare const INJECTION_PATTERNS: InjectionPattern[];
+export declare function scanTextForInjection(text: string, opts: {
+    ruleId: string;
+    where: string;
+    cap?: number;
+}): Finding[];
+export {};

package/dist/rules/injection.js

@@ -0,0 +1,106 @@
+import { truncate } from "../util/misc.js";
+/**
+ * Surface-level heuristics for instruction-injection patterns in text an agent
+ * will read (tool descriptions, skill bodies). This is intentionally a linter,
+ * not a security scanner: deep analysis belongs to dedicated tools
+ * (Snyk agent-scan, Cisco MCP Scanner). Patterns favor precision over recall.
+ */
+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",
+    },
+    {
+        key: "credential-exfil",
+        // "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",
+    },
+];
+export function scanTextForInjection(text, opts) {
+    const findings = [];
+    const cap = opts.cap ?? 10;
+    // Bound the scanned text: these regexes are cheap but not worth running on
+    // megabytes, and anything this long is its own finding (body-size rules).
+    const scanned = text.length > 64 * 1024 ? text.slice(0, 64 * 1024) : text;
+    for (const p of INJECTION_PATTERNS) {
+        if (findings.length >= cap)
+            break;
+        const m = p.re.exec(scanned);
+        if (m) {
+            findings.push({
+                ruleId: opts.ruleId,
+                // Deliberately info: these are shallow heuristics an attacker evades
+                // trivially. Surfacing them must never move a grade or fail CI, or a
+                // clean report would read as a security pass (it is not one).
+                severity: "info",
+                title: "possible injection pattern (heuristic)",
+                message: `${opts.where}: ${p.label}`,
+                target: opts.where,
+                detail: `matched: "${truncate(m[0].replace(/\s+/g, " "), 100)}". This is a shallow lint hint, not a security verdict.`,
+                fixHint: "Remove instruction-like language from agent-readable text. efaimo is not a security scanner; for real supply-chain safety use a dedicated scanner (for example Snyk agent-scan).",
+            });
+        }
+    }
+    return findings;
+}

package/dist/rules/mcp/index.d.ts

@@ -0,0 +1,4 @@
+import type { McpRule } from "../../core/types.js";
+export declare const MCP_RULES: McpRule[];
+/** E101-E118 are 2026-07-28 readiness rules: reported as a migration diff, not graded. */
+export declare function isReadinessRuleId(id: string): boolean;