memento-mori-jester 0.1.52 → 0.1.54

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to Memento Mori Jester are tracked here.
 
 ## Unreleased
 
+## 0.1.54
+
+- Added `npm run fixtures:report`, a local fixture coverage report for rule, preset, review-kind, and verdict coverage.
+- The report highlights rules without pass-case coverage, thin rule coverage, preset/kind gaps, and quiet pass fixtures, with text and `--json` output.
+- Wired fixture coverage reporting into `npm test` and production-readiness checks so coverage gaps stay visible during maintenance.
+
+## 0.1.53
+
+- Made `npm run fixtures:check` self-contained so it works from the published npm package, where `src/` files are intentionally not shipped.
+- Added a production-readiness guard to prevent the fixture validator from depending on source-only files.
+
 ## 0.1.52
 
 - Added `npm run fixtures:check`, a local fixture authoring validator for duplicate IDs, weak metadata, unsafe-looking content, duplicate content, and explicit expected/absent rule intent.

package/README.md

@@ -501,6 +501,7 @@ Use the false-positive template for noisy cautions or blocks. Include `jester su
 
 Maintainers can use [docs/MAINTAINER_TRIAGE.md](docs/MAINTAINER_TRIAGE.md) to turn useful false-positive reports into redacted fixtures.
 Run `npm run fixtures:check` before merging fixture changes; it catches duplicate IDs, missing rule metadata, weak descriptions, unsafe-looking content, and duplicate content.
+Run `npm run fixtures:report` to see fixture coverage by rule, preset, kind, and verdict before choosing the next pass-case fixture.
 
 For vulnerabilities, private code exposure, or credential-handling concerns, follow [SECURITY.md](SECURITY.md) instead of opening a public issue with sensitive details.
 

package/ROADMAP.md

@@ -6,6 +6,8 @@ Memento Mori Jester is usable today as a CLI, MCP server, GitHub Action, and git
 
 ## Recently Shipped
 
+- Fixture coverage report generator in v0.1.54 for rule, preset, review-kind, verdict, and pass-case gaps.
+- Published-package fixture validator fix in v0.1.53 so `npm run fixtures:check` works outside a source checkout.
 - Fixture authoring validator in v0.1.52 for duplicate IDs, missing expected/absent rule intent, weak metadata, unsafe-looking content, and duplicate content.
 - Maintainer triage guide in v0.1.51 for turning useful false-positive reports into redacted fixture coverage.
 - Security policy and GitHub issue templates in v0.1.50 for bug reports, false positives, feature requests, and vulnerability intake.
@@ -42,7 +44,7 @@ Memento Mori Jester is usable today as a CLI, MCP server, GitHub Action, and git
 ## Product Ideas
 
 - Add more framework-specific false-positive examples from real reports so tuning guidance keeps getting sharper.
-- Add a fixture report generator that shows which rules, presets, and review kinds still need better pass-case coverage.
+- Add the first targeted pass-case fixture batch from the fixture coverage report.
 
 ## Quality And Safety
 

package/docs/MAINTAINER_TRIAGE.md

@@ -75,14 +75,17 @@ Avoid fixtures that:
 ```powershell
 npm.cmd test
 npm.cmd run fixtures:check
+npm.cmd run fixtures:report
+npm.cmd run fixtures:report -- --json
 node .\dist\cli.js tune <rule-id>
 node .\dist\cli.js tune <rule-id> --json
 node .\dist\cli.js tune coverage
 ```
 
 5. Fix any duplicate IDs, missing expected rule metadata, weak descriptions, unsafe content, or duplicate content reported by `fixtures:check`.
-6. Check whether support/confidence changed in the expected direction.
-7. If the fixture changes verdict behavior, mention the exact rule impact in `CHANGELOG.md`.
+6. Use `fixtures:report` to check whether the change improves pass-case, preset, kind, or verdict coverage.
+7. Check whether support/confidence changed in the expected direction.
+8. If the fixture changes verdict behavior, mention the exact rule impact in `CHANGELOG.md`.
 
 ## When To Change A Rule
 

package/docs/PRODUCTION_READINESS.md

@@ -53,6 +53,7 @@ This checklist defines what "production grade" means for Memento Mori Jester rig
 - `SECURITY.md` routes vulnerability reports away from public issues and asks for redacted diagnostics.
 - `docs/MAINTAINER_TRIAGE.md` explains how to turn useful false-positive reports into fixture coverage before changing rule logic.
 - `npm run fixtures:check` validates fixture IDs, metadata, unsafe-looking content, duplicate content, and explicit expected/absent rule intent.
+- `npm run fixtures:report` shows fixture coverage by rule, preset, kind, and verdict so maintainers can pick the next pass-case target.
 - npm publish has a manual workflow fallback, but the normal release path is tag-driven trusted publishing.
 
 ## Static Guard
@@ -67,6 +68,7 @@ This checklist defines what "production grade" means for Memento Mori Jester rig
 - `SECURITY.md` and GitHub issue templates exist and ask for the right diagnostics.
 - maintainer triage docs exist and link noisy-rule reports back to fixture coverage.
 - fixture authoring checks are wired into `npm test`.
+- fixture coverage reports are wired into `npm test`.
 
 `npm test` runs this check after the TypeScript build and unit tests.
 

package/docs/RELEASE.md

@@ -9,6 +9,8 @@ npm.cmd version 0.1.x --no-git-tag-version
 npm.cmd test
 npm.cmd run production:check
 npm.cmd run fixtures:check
+npm.cmd run fixtures:report
+npm.cmd run fixtures:report -- --json
 npm.cmd run pack:dry
 git diff --check
 ```

package/docs/RELEASE_NOTES_v0.1.53.md

@@ -0,0 +1,32 @@
+# v0.1.53 Release Notes
+
+This patch fixes the newly added fixture authoring validator so it works from the published npm package, not only from a source checkout.
+
+## What Changed
+
+- Made `scripts/check-fixtures.mjs` self-contained by removing its source-file reads.
+- Added a production-readiness guard that prevents `fixtures:check` from depending on `src/config.ts` or `src/types.ts`.
+
+## Behavior Notes
+
+- No CLI, MCP, config, rule, playground, GitHub Action runtime, or release automation behavior changed.
+- Review fixture expectations remain unchanged.
+
+## Release Validation
+
+```powershell
+npm.cmd test
+npm.cmd run fixtures:check
+npm.cmd run production:check
+npm.cmd run demo:svg:check
+npm.cmd run pack:dry
+git diff --check
+node .\dist\cli.js doctor --json
+git diff | node .\dist\cli.js diff --fail-on block --subject "v0.1.53 published fixture validator fix"
+```
+
+Post-publish smoke:
+
+```powershell
+npm.cmd exec --yes --package memento-mori-jester@latest -- npm run fixtures:check --prefix <published-package-path>
+```

package/docs/RELEASE_NOTES_v0.1.54.md

@@ -0,0 +1,39 @@
+# v0.1.54 Release Notes
+
+This release adds a fixture coverage report generator so maintainers can see which rules, presets, review kinds, and verdicts need stronger fixture coverage.
+
+## What Changed
+
+- Added `scripts/report-fixtures.mjs`.
+- Added `npm run fixtures:report`.
+- Added `npm run fixtures:report -- --json` for stable structured output.
+- Wired fixture reporting into `npm test`.
+- The report shows:
+  - total fixtures, weighted fixtures, and edge-case fixtures,
+  - coverage by verdict, review kind, and preset,
+  - rule coverage from `expectedRuleIds`,
+  - rules without pass-case coverage,
+  - thin rule coverage,
+  - preset/kind gaps,
+  - quiet pass fixtures.
+- Updated maintainer triage docs, fixture docs, release docs, roadmap, changelog, and production readiness checks.
+
+## Behavior Notes
+
+- No CLI, MCP, config, rule, playground, GitHub Action runtime, or release automation behavior changed.
+- Existing review fixture expectations remain unchanged.
+
+## Release Validation
+
+```powershell
+npm.cmd test
+npm.cmd run fixtures:check
+npm.cmd run fixtures:report
+npm.cmd run fixtures:report -- --json
+npm.cmd run production:check
+npm.cmd run demo:svg:check
+npm.cmd run pack:dry
+git diff --check
+node .\dist\cli.js doctor --json
+git diff | node .\dist\cli.js diff --fail-on block --subject "v0.1.54 fixture coverage report"
+```

package/examples/fixtures/README.md

@@ -20,6 +20,8 @@ Maintainer triage guidance lives in [docs/MAINTAINER_TRIAGE.md](../../docs/MAINT
 ```powershell
 npm.cmd test
 npm.cmd run fixtures:check
+npm.cmd run fixtures:report
+npm.cmd run fixtures:report -- --json
 ```
 
 For one-off manual review, paste a fixture `content` value into:
@@ -42,3 +44,5 @@ Use the smallest redacted example that still reproduces the behavior. A good fix
 Do not add secrets, private code, customer data, complete logs, or machine-specific paths. If a false-positive report is safe but broad, add a passing fixture before loosening a rule.
 
 `npm run fixtures:check` validates duplicate IDs, missing expected rule metadata, weak descriptions, unsafe-looking fixture content, and duplicate content before the fixture suite becomes tuning evidence.
+
+`npm run fixtures:report` summarizes coverage by rule, preset, review kind, and verdict. Use it to find rules without pass-case coverage, thin rule coverage, preset/kind gaps, and quiet pass fixtures.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memento-mori-jester",
-  "version": "0.1.52",
+  "version": "0.1.54",
   "description": "A local court-jester sidecar for AI coding agents: review plans, commands, diffs, and final claims before they get too pleased with themselves.",
   "type": "module",
   "repository": {
@@ -40,11 +40,12 @@
     "build": "tsc -p tsconfig.json",
     "start": "node dist/server.js",
     "start:mcp": "node dist/server.js",
-    "test": "npm run build && node scripts/run-tests.mjs && npm run fixtures:check && npm run production:check",
+    "test": "npm run build && node scripts/run-tests.mjs && npm run fixtures:check && npm run fixtures:report && npm run production:check",
     "doctor": "node dist/cli.js doctor",
     "demo:svg": "node scripts/render-demo-svg.mjs",
     "demo:svg:check": "node scripts/render-demo-svg.mjs --check",
     "fixtures:check": "node scripts/check-fixtures.mjs",
+    "fixtures:report": "node scripts/report-fixtures.mjs",
     "production:check": "node scripts/check-production-readiness.mjs",
     "pack:dry": "npm pack --dry-run",
     "prepare": "npm run build",

package/scripts/check-fixtures.mjs

@@ -10,20 +10,8 @@ function read(path) {
   return readFileSync(join(root, path), "utf8");
 }
 
-function readConstStringArray(path, constName) {
-  const source = read(path);
-  const match = source.match(new RegExp(`export const ${constName} = \\[([^\\]]+)\\] as const`));
-
-  if (!match) {
-    failures.push(`Could not read ${constName} from ${path}.`);
-    return [];
-  }
-
-  return [...match[1].matchAll(/"([^"]+)"/g)].map((entry) => entry[1]);
-}
-
-const allowedPresets = new Set(readConstStringArray("src/config.ts", "configPresetNames"));
-const allowedKinds = new Set(readConstStringArray("src/types.ts", "reviewKinds"));
+const allowedPresets = new Set(["default", "node", "python", "web", "api", "infra", "ai", "security"]);
+const allowedKinds = new Set(["plan", "command", "diff", "final"]);
 const allowedVerdicts = new Set(["pass", "caution", "block"]);
 const unsafeContentPatterns = [
   { name: "private key block", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },

package/scripts/check-production-readiness.mjs

@@ -26,6 +26,13 @@ function requireText(path, pattern, description) {
   }
 }
 
+function forbidText(path, pattern, description) {
+  const content = read(path);
+  if (pattern.test(content)) {
+    failures.push(`${path} should not include ${description}.`);
+  }
+}
+
 function requirePackageFile(packageJson, value) {
   if (!Array.isArray(packageJson.files) || !packageJson.files.includes(value)) {
     failures.push(`package.json files should include ${value}.`);
@@ -58,6 +65,7 @@ for (const path of [
   `docs/RELEASE_NOTES_${tag}.md`,
   "action.yml",
   "scripts/check-fixtures.mjs",
+  "scripts/report-fixtures.mjs",
   ".github/ISSUE_TEMPLATE/bug_report.yml",
   ".github/ISSUE_TEMPLATE/false_positive.yml",
   ".github/ISSUE_TEMPLATE/feature_request.yml",
@@ -85,6 +93,7 @@ requireText("README.md", /SECURITY\.md/, "security policy link");
 requireText("README.md", /false-positive/i, "false-positive support guidance");
 requireText("README.md", /MAINTAINER_TRIAGE\.md/, "maintainer triage guide link");
 requireText("README.md", /fixtures:check/, "fixture authoring check guidance");
+requireText("README.md", /fixtures:report/, "fixture coverage report guidance");
 requireText("README.md", /License: PolyForm Noncommercial/, "the noncommercial license badge");
 requireText("docs/PRODUCTION_READINESS.md", /npm package/i, "npm package readiness");
 requireText("docs/PRODUCTION_READINESS.md", /GitHub Action/i, "GitHub Action readiness");
@@ -96,6 +105,7 @@ requireText("docs/PRODUCTION_READINESS.md", /SECURITY\.md/, "security policy rea
 requireText("docs/PRODUCTION_READINESS.md", /issue templates/i, "issue template readiness");
 requireText("docs/PRODUCTION_READINESS.md", /MAINTAINER_TRIAGE\.md/, "maintainer triage readiness");
 requireText("docs/PRODUCTION_READINESS.md", /fixtures:check/, "fixture authoring check readiness");
+requireText("docs/PRODUCTION_READINESS.md", /fixtures:report/, "fixture coverage report readiness");
 requireText("docs/CLI.md", /jester doctor --json/, "doctor JSON CLI docs");
 requireText("docs/MAINTAINER_TRIAGE.md", /doctor --json/, "doctor JSON triage prompt");
 requireText("docs/MAINTAINER_TRIAGE.md", /tune <rule-id> --json/, "tune JSON triage prompt");
@@ -105,10 +115,17 @@ requireText("docs/MAINTAINER_TRIAGE.md", /absentRuleIds/, "fixture absent rule g
 requireText("examples/fixtures/README.md", /MAINTAINER_TRIAGE\.md/, "maintainer triage link");
 requireText("examples/fixtures/README.md", /Adding A Fixture From A Report/, "fixture report conversion guidance");
 requireText("examples/fixtures/README.md", /fixtures:check/, "fixture authoring check guidance");
+requireText("examples/fixtures/README.md", /fixtures:report/, "fixture coverage report guidance");
 requireText("scripts/check-fixtures.mjs", /duplicated/, "duplicate fixture id check");
 requireText("scripts/check-fixtures.mjs", /unsafeContentPatterns/, "unsafe fixture content checks");
+forbidText("scripts/check-fixtures.mjs", /src\/config\.ts|src\/types\.ts/, "source-only fixture validator dependencies");
+requireText("scripts/report-fixtures.mjs", /rulesWithoutPassCases/, "rules without pass-case coverage report");
+requireText("scripts/report-fixtures.mjs", /presetKindGaps/, "preset and kind gap report");
+forbidText("scripts/report-fixtures.mjs", /src\/config\.ts|src\/types\.ts/, "source-only fixture report dependencies");
 requireText("package.json", /"fixtures:check": "node scripts\/check-fixtures\.mjs"/, "fixture authoring check script");
+requireText("package.json", /"fixtures:report": "node scripts\/report-fixtures\.mjs"/, "fixture coverage report script");
 requireText("package.json", /npm run fixtures:check/, "fixture authoring check in npm test");
+requireText("package.json", /npm run fixtures:report/, "fixture coverage report in npm test");
 requireText("SECURITY.md", /doctor --json/, "doctor JSON redaction guidance");
 requireText("SECURITY.md", /security\/advisories\/new/, "private vulnerability report link");
 requireText(".github/ISSUE_TEMPLATE/bug_report.yml", /doctor --json/, "doctor JSON support prompt");

package/scripts/report-fixtures.mjs

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const root = process.cwd();
+const fixturePath = "examples/fixtures/preset-review-cases.json";
+const allowedPresets = ["default", "node", "python", "web", "api", "infra", "ai", "security"];
+const allowedKinds = ["plan", "command", "diff", "final"];
+const allowedVerdicts = ["pass", "caution", "block"];
+const sampleLimit = 3;
+
+const args = new Set(process.argv.slice(2));
+const json = args.has("--json");
+
+function read(path) {
+  return readFileSync(join(root, path), "utf8");
+}
+
+let fixtures;
+try {
+  fixtures = JSON.parse(read(fixturePath));
+} catch (error) {
+  process.stderr.write(`Could not parse ${fixturePath}: ${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+}
+
+if (!Array.isArray(fixtures)) {
+  process.stderr.write(`${fixturePath} should contain a JSON array.\n`);
+  process.exit(1);
+}
+
+const report = buildFixtureReport(fixtures);
+
+if (json) {
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+} else {
+  process.stdout.write(renderFixtureReport(report));
+}
+
+function buildFixtureReport(rawFixtures) {
+  const byPreset = zeroCounts(allowedPresets);
+  const byKind = zeroCounts(allowedKinds);
+  const byVerdict = zeroCounts(allowedVerdicts);
+  const rules = new Map();
+  const quietPassFixtures = [];
+
+  let totalWeight = 0;
+  let edgeCaseFixtures = 0;
+
+  for (const fixture of rawFixtures) {
+    const preset = typeof fixture.preset === "string" ? fixture.preset : "unknown";
+    const kind = typeof fixture.kind === "string" ? fixture.kind : "unknown";
+    const verdict = typeof fixture.expectedVerdict === "string" ? fixture.expectedVerdict : "unknown";
+    const expectedRuleIds = Array.isArray(fixture.expectedRuleIds) ? fixture.expectedRuleIds : [];
+    const weight = fixtureWeight(fixture.weight);
+    const edgeCase = fixture.edgeCase === true;
+    const sample = {
+      id: String(fixture.id ?? "unknown"),
+      description: String(fixture.description ?? ""),
+      preset,
+      kind,
+      verdict
+    };
+
+    byPreset[preset] = (byPreset[preset] ?? 0) + 1;
+    byKind[kind] = (byKind[kind] ?? 0) + 1;
+    byVerdict[verdict] = (byVerdict[verdict] ?? 0) + 1;
+    totalWeight += weight;
+    if (edgeCase) {
+      edgeCaseFixtures += 1;
+    }
+
+    if (verdict === "pass" && expectedRuleIds.length === 0) {
+      quietPassFixtures.push(sample);
+    }
+
+    for (const ruleId of expectedRuleIds) {
+      const entry = rules.get(ruleId) ?? createRuleEntry(ruleId);
+      entry.total += 1;
+      entry.weight += weight;
+      entry.verdicts[verdict] = (entry.verdicts[verdict] ?? 0) + 1;
+      entry.kinds[kind] = (entry.kinds[kind] ?? 0) + 1;
+      entry.presets[preset] = (entry.presets[preset] ?? 0) + 1;
+      if (edgeCase) {
+        entry.edgeCases += 1;
+      }
+      entry.samples.push(sample);
+      rules.set(ruleId, entry);
+    }
+  }
+
+  const ruleSummaries = [...rules.values()]
+    .map((entry) => ({
+      ruleId: entry.ruleId,
+      total: entry.total,
+      weight: entry.weight,
+      passCases: entry.verdicts.pass ?? 0,
+      cautionCases: entry.verdicts.caution ?? 0,
+      blockCases: entry.verdicts.block ?? 0,
+      edgeCases: entry.edgeCases,
+      verdicts: orderedCounts(entry.verdicts, allowedVerdicts),
+      kinds: orderedCounts(entry.kinds, allowedKinds),
+      presets: orderedCounts(entry.presets, allowedPresets),
+      samples: entry.samples
+        .slice()
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .slice(0, sampleLimit)
+    }))
+    .sort((a, b) => a.ruleId.localeCompare(b.ruleId));
+
+  const gaps = {
+    rulesWithoutPassCases: ruleSummaries
+      .filter((entry) => entry.passCases === 0)
+      .sort((a, b) => b.total - a.total || a.ruleId.localeCompare(b.ruleId))
+      .map(ruleGapSummary),
+    thinRuleCoverage: ruleSummaries
+      .filter((entry) => entry.total < 2)
+      .sort((a, b) => a.total - b.total || a.ruleId.localeCompare(b.ruleId))
+      .map(ruleGapSummary),
+    presetKindGaps: presetKindGaps(rawFixtures),
+    quietPassFixtures: quietPassFixtures
+      .slice()
+      .sort((a, b) => a.id.localeCompare(b.id))
+  };
+
+  return {
+    totalFixtures: rawFixtures.length,
+    totalWeight,
+    edgeCaseFixtures,
+    byVerdict: orderedCounts(byVerdict, allowedVerdicts),
+    byKind: orderedCounts(byKind, allowedKinds),
+    byPreset: orderedCounts(byPreset, allowedPresets),
+    rules: ruleSummaries,
+    gaps
+  };
+}
+
+function renderFixtureReport(report) {
+  const lines = [
+    "Fixture coverage report",
+    "",
+    `Fixtures: ${report.totalFixtures}`,
+    `Weighted fixtures: ${report.totalWeight}`,
+    `Edge-case fixtures: ${report.edgeCaseFixtures}`,
+    `Rules covered by expectedRuleIds: ${report.rules.length}`,
+    "",
+    `By verdict: ${formatCounts(report.byVerdict)}`,
+    `By kind: ${formatCounts(report.byKind)}`,
+    `By preset: ${formatCounts(report.byPreset)}`,
+    "",
+    "Rules without pass-case coverage:"
+  ];
+
+  lines.push(...formatRuleGaps(report.gaps.rulesWithoutPassCases));
+  lines.push("", "Thin rule coverage:");
+  lines.push(...formatRuleGaps(report.gaps.thinRuleCoverage));
+  lines.push("", "Preset/kind gaps:");
+  lines.push(...formatPresetKindGaps(report.gaps.presetKindGaps));
+  lines.push("", "Quiet pass fixtures:");
+  lines.push(...formatFixtureSamples(report.gaps.quietPassFixtures));
+  lines.push(
+    "",
+    "Next:",
+    "  npm run fixtures:check",
+    "  npm run fixtures:report -- --json",
+    "  node .\\dist\\cli.js tune coverage"
+  );
+
+  return `${lines.join("\n")}\n`;
+}
+
+function createRuleEntry(ruleId) {
+  return {
+    ruleId,
+    total: 0,
+    weight: 0,
+    edgeCases: 0,
+    verdicts: zeroCounts(allowedVerdicts),
+    kinds: zeroCounts(allowedKinds),
+    presets: zeroCounts(allowedPresets),
+    samples: []
+  };
+}
+
+function fixtureWeight(rawWeight) {
+  if (typeof rawWeight === "number" && rawWeight > 0 && Number.isFinite(rawWeight)) {
+    return Math.max(1, Math.min(3, Math.round(rawWeight)));
+  }
+
+  return 1;
+}
+
+function zeroCounts(keys) {
+  return Object.fromEntries(keys.map((key) => [key, 0]));
+}
+
+function orderedCounts(counts, keys) {
+  const ordered = zeroCounts(keys);
+  for (const [key, value] of Object.entries(counts)) {
+    ordered[key] = value;
+  }
+  return ordered;
+}
+
+function presetKindGaps(fixtures) {
+  const seen = new Set(fixtures.map((fixture) => `${fixture.preset}:${fixture.kind}`));
+  return allowedPresets
+    .map((preset) => ({
+      preset,
+      missingKinds: allowedKinds.filter((kind) => !seen.has(`${preset}:${kind}`))
+    }))
+    .filter((entry) => entry.missingKinds.length > 0);
+}
+
+function ruleGapSummary(entry) {
+  return {
+    ruleId: entry.ruleId,
+    total: entry.total,
+    passCases: entry.passCases,
+    cautionCases: entry.cautionCases,
+    blockCases: entry.blockCases,
+    samples: entry.samples
+  };
+}
+
+function formatCounts(counts) {
+  return Object.entries(counts)
+    .map(([key, value]) => `${key} ${value}`)
+    .join(", ");
+}
+
+function formatRuleGaps(entries) {
+  if (entries.length === 0) {
+    return ["- none"];
+  }
+
+  return entries
+    .slice(0, 12)
+    .map((entry) => `- ${entry.ruleId}: ${entry.total} fixture(s), pass ${entry.passCases}, caution ${entry.cautionCases}, block ${entry.blockCases}`);
+}
+
+function formatPresetKindGaps(entries) {
+  if (entries.length === 0) {
+    return ["- none"];
+  }
+
+  return entries.map((entry) => `- ${entry.preset}: ${entry.missingKinds.join(", ")}`);
+}
+
+function formatFixtureSamples(entries) {
+  if (entries.length === 0) {
+    return ["- none"];
+  }
+
+  return entries
+    .slice(0, 8)
+    .map((entry) => `- ${entry.id}: ${entry.description}`);
+}