memento-mori-jester 0.1.59 → 0.1.60

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to Memento Mori Jester are tracked here.
 
 ## Unreleased
 
+## 0.1.60
+
+- Added rule-family slices to `npm run fixtures:report` so maintainers can compare built-in, structural, custom, configured sensitive-domain, and blocked-command coverage.
+- Added preset slices and curation-next guidance to fixture report text and `--json` output.
+- Updated fixture-report tests and docs so the coverage dashboard stays useful as the fixture suite grows.
+
 ## 0.1.59
 
 - Added quiet-pass fixtures for remaining sparse built-in and structural rules including missing verification, confidence theater, TypeScript suppressions, large removals, wildcard file operations, destructive commands, and untested finals.

package/README.md

@@ -501,7 +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, verdict, and quiet-pass boundaries before choosing the next fixture.
+Run `npm run fixtures:report` to see fixture coverage by rule, rule family, preset slice, kind, verdict, quiet-pass boundaries, and curation-next guidance before choosing the next 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,7 @@ Memento Mori Jester is usable today as a CLI, MCP server, GitHub Action, and git
 
 ## Recently Shipped
 
+- Fixture report rule-family slices, preset slices, and curation-next guidance in v0.1.60 so maintainers can see which fixture areas need real-world examples next.
 - Quiet-pass boundaries for remaining sparse built-in and structural rules in v0.1.59 so the fixture report now has no rules without quiet-pass coverage.
 - Quiet-pass boundaries for thin custom/preset rules in v0.1.58 so preset blocked commands, sensitive-domain checks, and custom stack rules now have safe near-miss examples.
 - Completed preset-kind fixture coverage in v0.1.57 so `default`, `node`, `python`, `web`, `api`, `infra`, `ai`, and `security` now all have plan, command, diff, and final examples.
@@ -49,7 +50,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 fixture report slices by rule family and preset so maintainers can spot which areas need real-world curation next.
+- Add a Markdown export for fixture reports so maintainers can paste coverage snapshots into issues or release notes.
 
 ## Quality And Safety
 

package/docs/DEMO.md

@@ -355,6 +355,8 @@ Preset packs:
 
 The fixture suite in `examples/fixtures/preset-review-cases.json` captures small real-usage examples with expected `pass`, `caution`, or `block` verdicts. It also includes quiet-pass `absentRuleIds` examples that prove noisy rules stay silent for safe near-misses, stack-specific coverage for every built-in preset, and quiet-pass boundaries across built-in, structural, custom, and preset/config-derived rules. These examples are run by `npm test`, so preset tuning changes stay visible.
 
+Maintainers can run `npm run fixtures:report` to see coverage by verdict, kind, preset, rule family, and preset slice. The report also includes a `Curation next` section that points at the next useful fixture batch, such as thin rules, no-pass evidence, rule-family gaps, or lower-count presets.
+
 Maintainers can use `docs/MAINTAINER_TRIAGE.md` to turn useful false-positive reports into redacted fixture cases.
 
 ## 14. Framework CI Examples

package/docs/MAINTAINER_TRIAGE.md

@@ -83,7 +83,7 @@ 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. Use `fixtures:report` to check whether the change improves pass-case, quiet-pass, preset, kind, or verdict coverage.
+6. Use `fixtures:report` to check whether the change improves pass-case, quiet-pass, preset, kind, rule-family, or verdict coverage. Start with the report's `Curation next` section when deciding which fixture batch to add first.
 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`.
 

package/docs/PRODUCTION_READINESS.md

@@ -53,7 +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, verdict, and quiet-pass rule boundaries so maintainers can pick the next fixture target.
+- `npm run fixtures:report` shows fixture coverage by rule, rule family, preset slice, kind, verdict, and quiet-pass rule boundaries so maintainers can pick the next fixture target.
 - npm publish has a manual workflow fallback, but the normal release path is tag-driven trusted publishing.
 
 ## Static Guard

package/docs/RELEASE_NOTES_v0.1.60.md

@@ -0,0 +1,30 @@
+# Memento Mori Jester v0.1.60
+
+This release makes `npm run fixtures:report` a more useful maintenance dashboard for fixture curation. It does not change review behavior, rule matching, MCP tools, presets, or release automation.
+
+## What Changed
+
+- Added `ruleFamilySlices` to fixture report JSON and a `By rule family` section to text output.
+- Added `presetSlices` to fixture report JSON and a `Preset slices` section to text output.
+- Added `curationNext` guidance so maintainers can quickly see whether to add thin-rule, no-pass, rule-family, or lower-count preset examples next.
+- Updated fixture-report tests and maintainer docs around the richer report output.
+
+## Public Interface
+
+- No CLI review behavior changes.
+- No config schema changes.
+- No MCP, playground, GitHub Action, or npm publishing changes.
+- `npm run fixtures:report -- --json` now includes additional stable fields: `ruleFamilySlices`, `presetSlices`, and `curationNext`.
+
+## Release Validation
+
+```powershell
+npm.cmd test
+npm.cmd run demo:svg:check
+npm.cmd run fixtures:report
+npm.cmd run fixtures:report -- --json
+npm.cmd run pack:dry
+git diff --check
+node .\dist\cli.js tune coverage --no-config
+git diff | node .\dist\cli.js diff --fail-on block --subject "v0.1.60 fixture report curation slices"
+```

package/examples/fixtures/README.md

@@ -48,4 +48,6 @@ Do not add secrets, private code, customer data, complete logs, or machine-speci
 
 `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, verdict, and quiet-pass rule boundaries. Use it to find rules without pass-case coverage, rules without quiet-pass coverage, thin rule coverage, preset/kind gaps, and quiet pass fixtures.
+`npm run fixtures:report` summarizes coverage by rule, rule family, preset slice, review kind, verdict, and quiet-pass rule boundaries. Use it to find rules without pass-case coverage, rules without quiet-pass coverage, thin rule coverage, preset/kind gaps, quiet pass fixtures, and the next curation target.
+
+The `Curation next` section is a maintainer shortcut: start there when deciding whether the next fixture batch should focus on thin rules, no-pass evidence, a specific rule family, or lower-count presets. The `--json` output includes the same `ruleFamilySlices`, `presetSlices`, and `curationNext` fields for scripts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memento-mori-jester",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "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": {

package/scripts/report-fixtures.mjs

@@ -8,6 +8,18 @@ const allowedPresets = ["default", "node", "python", "web", "api", "infra", "ai"
 const allowedKinds = ["plan", "command", "diff", "final"];
 const allowedVerdicts = ["pass", "caution", "block"];
 const sampleLimit = 3;
+const structuralRuleIds = new Set([
+  "large-removal",
+  "missing-verification-step",
+  "wildcard-file-operation"
+]);
+const ruleFamilyOrder = [
+  "built-in",
+  "structural",
+  "custom",
+  "configured-sensitive-domain",
+  "blocked-command"
+];
 
 const args = new Set(process.argv.slice(2));
 const json = args.has("--json");
@@ -43,6 +55,7 @@ function buildFixtureReport(rawFixtures) {
   const byVerdict = zeroCounts(allowedVerdicts);
   const rules = new Map();
   const quietPassRules = new Map();
+  const presetSlices = new Map(allowedPresets.map((preset) => [preset, createPresetSlice(preset)]));
   const quietPassFixtures = [];
 
   let totalWeight = 0;
@@ -72,9 +85,24 @@ function buildFixtureReport(rawFixtures) {
       edgeCaseFixtures += 1;
     }
 
+    const presetSlice = presetSlices.get(preset) ?? createPresetSlice(preset);
+    presetSlice.total += 1;
+    presetSlice.weight += weight;
+    presetSlice.byKind[kind] = (presetSlice.byKind[kind] ?? 0) + 1;
+    presetSlice.byVerdict[verdict] = (presetSlice.byVerdict[verdict] ?? 0) + 1;
+    presetSlice.expectedRuleReferences += expectedRuleIds.length;
+    if (verdict === "pass") {
+      presetSlice.quietPassRuleReferences += absentRuleIds.length;
+    }
+    if (edgeCase) {
+      presetSlice.edgeCases += 1;
+    }
+
     if (verdict === "pass" && expectedRuleIds.length === 0) {
       quietPassFixtures.push(sample);
+      presetSlice.quietPassFixtures += 1;
     }
+    presetSlices.set(preset, presetSlice);
 
     if (verdict === "pass") {
       for (const ruleId of absentRuleIds) {
@@ -154,11 +182,14 @@ function buildFixtureReport(rawFixtures) {
       .sort((a, b) => a.total - b.total || a.ruleId.localeCompare(b.ruleId))
       .map(ruleGapSummary),
     presetKindGaps: presetKindGaps(rawFixtures),
-    quietPassRuleCoverage: quietPassRuleSummaries,
-    quietPassFixtures: quietPassFixtures
-      .slice()
-      .sort((a, b) => a.id.localeCompare(b.id))
+      quietPassRuleCoverage: quietPassRuleSummaries,
+      quietPassFixtures: quietPassFixtures
+        .slice()
+        .sort((a, b) => a.id.localeCompare(b.id))
   };
+  const ruleFamilySlices = buildRuleFamilySlices(ruleSummaries, quietPassRuleSummaries);
+  const presetSliceSummaries = buildPresetSlices(presetSlices);
+  const curationNext = buildCurationNext(gaps, ruleFamilySlices, presetSliceSummaries);
 
   return {
     totalFixtures: rawFixtures.length,
@@ -167,6 +198,9 @@ function buildFixtureReport(rawFixtures) {
     byVerdict: orderedCounts(byVerdict, allowedVerdicts),
     byKind: orderedCounts(byKind, allowedKinds),
     byPreset: orderedCounts(byPreset, allowedPresets),
+    ruleFamilySlices,
+    presetSlices: presetSliceSummaries,
+    curationNext,
     quietPassRules: quietPassRuleSummaries,
     rules: ruleSummaries,
     gaps
@@ -186,9 +220,17 @@ function renderFixtureReport(report) {
     `By kind: ${formatCounts(report.byKind)}`,
     `By preset: ${formatCounts(report.byPreset)}`,
     "",
-    "Rules without pass-case coverage:"
+    "By rule family:"
   ];
 
+  lines.push(...formatRuleFamilySlices(report.ruleFamilySlices));
+  lines.push("", "Preset slices:");
+  lines.push(...formatPresetSlices(report.presetSlices));
+  lines.push(
+    "",
+    "Rules without pass-case coverage:"
+  );
+
   lines.push(...formatRuleGaps(report.gaps.rulesWithoutPassCases));
   lines.push("", "Rules without quiet-pass coverage:");
   lines.push(...formatRuleGaps(report.gaps.rulesWithoutQuietPassCoverage));
@@ -200,6 +242,8 @@ function renderFixtureReport(report) {
   lines.push(...formatPresetKindGaps(report.gaps.presetKindGaps));
   lines.push("", "Quiet pass fixtures:");
   lines.push(...formatFixtureSamples(report.gaps.quietPassFixtures));
+  lines.push("", "Curation next:");
+  lines.push(...formatCurationNext(report.curationNext));
   lines.push(
     "",
     "Next:",
@@ -236,6 +280,39 @@ function createQuietPassEntry(ruleId) {
   };
 }
 
+function createPresetSlice(preset) {
+  return {
+    preset,
+    total: 0,
+    weight: 0,
+    edgeCases: 0,
+    quietPassFixtures: 0,
+    expectedRuleReferences: 0,
+    quietPassRuleReferences: 0,
+    byKind: zeroCounts(allowedKinds),
+    byVerdict: zeroCounts(allowedVerdicts)
+  };
+}
+
+function createRuleFamilySlice(family) {
+  return {
+    family,
+    ruleCount: 0,
+    ruleIds: [],
+    fixtureReferences: 0,
+    weight: 0,
+    passCases: 0,
+    cautionCases: 0,
+    blockCases: 0,
+    quietPassCases: 0,
+    quietPassWeight: 0,
+    rulesWithoutPassCases: [],
+    rulesWithoutQuietPassCoverage: [],
+    thinRules: [],
+    sampleRules: []
+  };
+}
+
 function fixtureWeight(rawWeight) {
   if (typeof rawWeight === "number" && rawWeight > 0 && Number.isFinite(rawWeight)) {
     return Math.max(1, Math.min(3, Math.round(rawWeight)));
@@ -256,6 +333,204 @@ function orderedCounts(counts, keys) {
   return ordered;
 }
 
+function ruleFamily(ruleId) {
+  if (ruleId.startsWith("blocked-command-")) {
+    return "blocked-command";
+  }
+
+  if (ruleId.startsWith("configured-sensitive-domain-")) {
+    return "configured-sensitive-domain";
+  }
+
+  if (ruleId.startsWith("custom-")) {
+    return "custom";
+  }
+
+  if (structuralRuleIds.has(ruleId)) {
+    return "structural";
+  }
+
+  return "built-in";
+}
+
+function buildRuleFamilySlices(ruleSummaries, quietPassRuleSummaries) {
+  const slices = new Map(ruleFamilyOrder.map((family) => [family, createRuleFamilySlice(family)]));
+
+  for (const entry of ruleSummaries) {
+    const family = ruleFamily(entry.ruleId);
+    const slice = slices.get(family) ?? createRuleFamilySlice(family);
+
+    slice.ruleCount += 1;
+    slice.ruleIds.push(entry.ruleId);
+    slice.fixtureReferences += entry.total;
+    slice.weight += entry.weight;
+    slice.passCases += entry.passCases;
+    slice.cautionCases += entry.cautionCases;
+    slice.blockCases += entry.blockCases;
+    if (entry.passCases === 0) {
+      slice.rulesWithoutPassCases.push(ruleGapSummary(entry));
+    }
+    if (entry.quietPassCases === 0) {
+      slice.rulesWithoutQuietPassCoverage.push(ruleGapSummary(entry));
+    }
+    if (entry.total < 2) {
+      slice.thinRules.push(ruleGapSummary(entry));
+    }
+    if (slice.sampleRules.length < sampleLimit) {
+      slice.sampleRules.push({
+        ruleId: entry.ruleId,
+        total: entry.total,
+        quietPassCases: entry.quietPassCases
+      });
+    }
+
+    slices.set(family, slice);
+  }
+
+  for (const entry of quietPassRuleSummaries) {
+    const family = ruleFamily(entry.ruleId);
+    const slice = slices.get(family) ?? createRuleFamilySlice(family);
+
+    slice.quietPassCases += entry.total;
+    slice.quietPassWeight += entry.weight;
+    slices.set(family, slice);
+  }
+
+  return sortRuleFamilies([...slices.values()])
+    .filter((entry) => entry.ruleCount > 0 || entry.quietPassCases > 0)
+    .map((entry) => ({
+      ...entry,
+      ruleIds: entry.ruleIds.slice().sort((a, b) => a.localeCompare(b)),
+      rulesWithoutPassCases: entry.rulesWithoutPassCases
+        .slice()
+        .sort((a, b) => b.total - a.total || a.ruleId.localeCompare(b.ruleId)),
+      rulesWithoutQuietPassCoverage: entry.rulesWithoutQuietPassCoverage
+        .slice()
+        .sort((a, b) => b.total - a.total || a.ruleId.localeCompare(b.ruleId)),
+      thinRules: entry.thinRules
+        .slice()
+        .sort((a, b) => a.total - b.total || a.ruleId.localeCompare(b.ruleId)),
+      sampleRules: entry.sampleRules
+        .slice()
+        .sort((a, b) => b.total - a.total || a.ruleId.localeCompare(b.ruleId))
+    }));
+}
+
+function buildPresetSlices(presetSlices) {
+  return [...presetSlices.values()]
+    .map((entry) => ({
+      preset: entry.preset,
+      total: entry.total,
+      weight: entry.weight,
+      edgeCases: entry.edgeCases,
+      quietPassFixtures: entry.quietPassFixtures,
+      expectedRuleReferences: entry.expectedRuleReferences,
+      quietPassRuleReferences: entry.quietPassRuleReferences,
+      byKind: orderedCounts(entry.byKind, allowedKinds),
+      byVerdict: orderedCounts(entry.byVerdict, allowedVerdicts)
+    }))
+    .sort((a, b) => presetOrder(a.preset) - presetOrder(b.preset) || a.preset.localeCompare(b.preset));
+}
+
+function buildCurationNext(gaps, ruleFamilySlices, presetSlices) {
+  const items = [];
+
+  if (gaps.presetKindGaps.length > 0) {
+    items.push({
+      priority: "high",
+      area: "preset-kind-gaps",
+      title: "Fill missing preset/review-kind combinations",
+      count: gaps.presetKindGaps.length,
+      details: gaps.presetKindGaps
+        .slice(0, 6)
+        .map((entry) => `${entry.preset}: ${entry.missingKinds.join(", ")}`)
+    });
+  }
+
+  if (gaps.rulesWithoutQuietPassCoverage.length > 0) {
+    items.push({
+      priority: "high",
+      area: "quiet-pass-gaps",
+      title: "Add safe near-miss fixtures for rules without quiet-pass coverage",
+      count: gaps.rulesWithoutQuietPassCoverage.length,
+      ruleIds: gaps.rulesWithoutQuietPassCoverage.slice(0, 8).map((entry) => entry.ruleId)
+    });
+  }
+
+  if (gaps.thinRuleCoverage.length > 0) {
+    items.push({
+      priority: "medium",
+      area: "thin-rule-coverage",
+      title: "Add a second example for rules with only one firing fixture",
+      count: gaps.thinRuleCoverage.length,
+      ruleIds: gaps.thinRuleCoverage.slice(0, 8).map((entry) => entry.ruleId)
+    });
+  }
+
+  if (gaps.rulesWithoutPassCases.length > 0) {
+    items.push({
+      priority: "medium",
+      area: "pass-case-coverage",
+      title: "Add benign or docs-only examples for rules with no pass-case evidence",
+      count: gaps.rulesWithoutPassCases.length,
+      ruleIds: gaps.rulesWithoutPassCases.slice(0, 8).map((entry) => entry.ruleId)
+    });
+  }
+
+  const thinFamilies = ruleFamilySlices
+    .filter((entry) => entry.thinRules.length > 0)
+    .map((entry) => ({
+      family: entry.family,
+      thinRules: entry.thinRules.length,
+      ruleIds: entry.thinRules.slice(0, 4).map((rule) => rule.ruleId)
+    }));
+
+  if (thinFamilies.length > 0) {
+    items.push({
+      priority: "low",
+      area: "rule-family-curation",
+      title: "Use rule-family slices to batch similar thin rules",
+      count: thinFamilies.reduce((total, entry) => total + entry.thinRules, 0),
+      families: thinFamilies
+    });
+  }
+
+  const lowerPresetSlices = presetSlices
+    .filter((entry) => entry.total > 0)
+    .slice()
+    .sort((a, b) => a.total - b.total || presetOrder(a.preset) - presetOrder(b.preset) || a.preset.localeCompare(b.preset))
+    .slice(0, 4)
+    .map((entry) => ({
+      preset: entry.preset,
+      total: entry.total,
+      quietPassFixtures: entry.quietPassFixtures
+    }));
+
+  items.push({
+    priority: "low",
+    area: "preset-real-world-curation",
+    title: "Collect real-world reports for the lowest-count preset slices",
+    count: lowerPresetSlices.length,
+    presets: lowerPresetSlices
+  });
+
+  return items;
+}
+
+function sortRuleFamilies(entries) {
+  return entries.sort((a, b) => ruleFamilyIndex(a.family) - ruleFamilyIndex(b.family) || a.family.localeCompare(b.family));
+}
+
+function ruleFamilyIndex(family) {
+  const index = ruleFamilyOrder.indexOf(family);
+  return index === -1 ? ruleFamilyOrder.length : index;
+}
+
+function presetOrder(preset) {
+  const index = allowedPresets.indexOf(preset);
+  return index === -1 ? allowedPresets.length : index;
+}
+
 function presetKindGaps(fixtures) {
   const seen = new Set(fixtures.map((fixture) => `${fixture.preset}:${fixture.kind}`));
   return allowedPresets
@@ -294,6 +569,43 @@ function formatRuleGaps(entries) {
     .map((entry) => `- ${entry.ruleId}: ${entry.total} fixture(s), pass ${entry.passCases}, caution ${entry.cautionCases}, block ${entry.blockCases}, quiet-pass ${entry.quietPassCases}`);
 }
 
+function formatRuleFamilySlices(entries) {
+  if (entries.length === 0) {
+    return ["- none"];
+  }
+
+  return entries.map((entry) =>
+    [
+      `- ${entry.family}: ${entry.ruleCount} rule(s)`,
+      `${entry.fixtureReferences} fixture ref(s)`,
+      `pass ${entry.passCases}`,
+      `caution ${entry.cautionCases}`,
+      `block ${entry.blockCases}`,
+      `quiet-pass ${entry.quietPassCases}`,
+      `thin ${entry.thinRules.length}`
+    ].join(", ")
+  );
+}
+
+function formatPresetSlices(entries) {
+  if (entries.length === 0) {
+    return ["- none"];
+  }
+
+  return entries.map((entry) =>
+    [
+      `- ${entry.preset}: ${entry.total} fixture(s)`,
+      `weight ${entry.weight}`,
+      `pass ${entry.byVerdict.pass ?? 0}`,
+      `caution ${entry.byVerdict.caution ?? 0}`,
+      `block ${entry.byVerdict.block ?? 0}`,
+      `quiet-pass ${entry.quietPassFixtures}`,
+      `rule refs ${entry.expectedRuleReferences}`,
+      `absent refs ${entry.quietPassRuleReferences}`
+    ].join(", ")
+  );
+}
+
 function formatQuietPassRuleCoverage(entries) {
   if (entries.length === 0) {
     return ["- none"];
@@ -321,3 +633,34 @@ function formatFixtureSamples(entries) {
     .slice(0, 8)
     .map((entry) => `- ${entry.id}: ${entry.description}`);
 }
+
+function formatCurationNext(entries) {
+  if (entries.length === 0) {
+    return ["- none"];
+  }
+
+  return entries.map((entry) => {
+    const details = formatCurationDetails(entry);
+    return `- ${entry.priority} ${entry.area}: ${entry.title} (${entry.count})${details}`;
+  });
+}
+
+function formatCurationDetails(entry) {
+  if (Array.isArray(entry.ruleIds) && entry.ruleIds.length > 0) {
+    return `: ${entry.ruleIds.join(", ")}`;
+  }
+
+  if (Array.isArray(entry.details) && entry.details.length > 0) {
+    return `: ${entry.details.join("; ")}`;
+  }
+
+  if (Array.isArray(entry.families) && entry.families.length > 0) {
+    return `: ${entry.families.map((family) => `${family.family} ${family.thinRules}`).join(", ")}`;
+  }
+
+  if (Array.isArray(entry.presets) && entry.presets.length > 0) {
+    return `: ${entry.presets.map((preset) => `${preset.preset} ${preset.total}`).join(", ")}`;
+  }
+
+  return "";
+}