designwithai-mcp 0.12.0 → 0.13.0

package/dist/cli.js

@@ -0,0 +1,135 @@
+/**
+ * LE MÊME MOTEUR, EN LIGNE DE COMMANDE.
+ *
+ * Une page d'état qui n'existe que dans un IDE ne sert pas l'équipe : elle sert
+ * la personne qui a l'IDE. La CI, elle, n'a pas de client MCP — elle a un shell.
+ * Ces sous-commandes exposent EXACTEMENT les mêmes fonctions de rendu que les
+ * outils MCP, sans en dupliquer une ligne. Une définition, un endroit : si la
+ * page change, elle change aux deux endroits parce qu'il n'y en a qu'un.
+ *
+ * Tout va sur la sortie standard, pour que `>` et `|` fassent leur travail.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { workspaceRoot } from "./paths.js";
+import { lireRegistre } from "./registry-read.js";
+import { rendreStatusPage } from "./status-page.js";
+import { dernierUpdate, enregistrerUpdate, rendreStatusUpdate } from "./status-update.js";
+import { delta, rendreDelta } from "./pr-delta.js";
+import { lireReviewsA } from "./registry-git.js";
+import { constats } from "./pr-delta.js";
+export const SOUS_COMMANDES = ["status-page", "status-update", "pr-delta", "--help", "-h"];
+const AIDE = `designwithai-mcp — le serveur MCP du Handbook, et trois rendus en ligne de commande.
+
+  designwithai-mcp                          démarre le serveur MCP (stdio)
+
+  designwithai-mcp status-page [--out F] [--product N]
+      Écrit la page d'état du produit, dérivée du registre.
+      Défaut : docs/etat-produit/index.html. --out - écrit sur la sortie standard.
+
+  designwithai-mcp status-update [--since ISO] [--product N] [--no-save]
+      Écrit le point d'avancement en Markdown sur la sortie standard.
+      Sans --since : depuis le dernier point enregistré.
+
+  designwithai-mcp pr-delta --base <ref> [--head <ref>] [--branch N]
+      Compare le registre de la base à celui du répertoire courant (ou de --head)
+      et rend le commentaire de PR. Suppose que .designwithai/ est VERSIONNÉ.
+
+Le registre vit dans .designwithai/ du projet courant (DWAI_WORKSPACE pour l'imposer).`;
+function option(argv, nom) {
+    const i = argv.indexOf(`--${nom}`);
+    if (i === -1)
+        return undefined;
+    const v = argv[i + 1];
+    return v && !v.startsWith("--") ? v : undefined;
+}
+/**
+ * Rend vrai quand une sous-commande a été traitée — le serveur ne doit alors
+ * PAS ouvrir stdio : un client MCP qui reçoit du Markdown sur stdout croit
+ * lire du protocole et se coupe sans message lisible.
+ */
+export async function traiterCli(argv) {
+    const cmd = argv[0];
+    if (!cmd)
+        return false;
+    if (cmd === "--help" || cmd === "-h") {
+        process.stdout.write(`${AIDE}\n`);
+        return true;
+    }
+    if (cmd === "status-page") {
+        const r = lireRegistre();
+        const produit = option(argv, "product");
+        const html = rendreStatusPage(r, {
+            maintenant: new Date().toISOString(),
+            ...(produit ? { produit } : {}),
+        });
+        const out = option(argv, "out") ?? "docs/etat-produit/index.html";
+        if (out === "-") {
+            process.stdout.write(html);
+            return true;
+        }
+        const cible = path.resolve(workspaceRoot(), out);
+        mkdirSync(path.dirname(cible), { recursive: true });
+        writeFileSync(cible, html, "utf8");
+        process.stderr.write(`Page écrite : ${path.relative(workspaceRoot(), cible)}\n`);
+        /* Les fichiers illisibles vont sur stderr ET dans la page. Un registre à
+           moitié lu qui rendrait une page sereine serait le pire de cette surface. */
+        for (const i of r.illisibles)
+            process.stderr.write(`⚠ illisible : ${i.chemin} — ${i.raison}\n`);
+        return true;
+    }
+    if (cmd === "status-update") {
+        const r = lireRegistre();
+        const maintenant = new Date();
+        const depuis = option(argv, "since") ??
+            dernierUpdate() ??
+            new Date(maintenant.getTime() - 30 * 24 * 3600 * 1000).toISOString();
+        const produit = option(argv, "product");
+        const md = rendreStatusUpdate(r, {
+            depuis,
+            maintenant: maintenant.toISOString(),
+            ...(produit ? { produit } : {}),
+        });
+        process.stdout.write(`${md}\n`);
+        if (!argv.includes("--no-save")) {
+            const chemin = enregistrerUpdate(md, maintenant);
+            process.stderr.write(`Point enregistré : ${path.relative(workspaceRoot(), chemin)}\n`);
+        }
+        return true;
+    }
+    if (cmd === "pr-delta") {
+        const base = option(argv, "base");
+        if (!base) {
+            process.stderr.write("pr-delta a besoin de --base <ref>.\n");
+            process.exitCode = 2;
+            return true;
+        }
+        const cwd = workspaceRoot();
+        let avant;
+        try {
+            avant = lireReviewsA(base, cwd);
+        }
+        catch (e) {
+            process.stderr.write(`${e instanceof Error ? e.message : String(e)}\n`);
+            process.exitCode = 2;
+            return true;
+        }
+        const tete = option(argv, "head");
+        const apres = tete ? lireReviewsA(tete, cwd).reviews : lireRegistre().reviews;
+        if (avant.absent) {
+            process.stdout.write(`${rendreDelta({ reglesProuves: [], declaresCorriges: [], nouveaux: [], deplaces: [], persistants: [] }, { base, baseSansRegistre: true })}\n`);
+            return true;
+        }
+        const d = delta(avant.reviews, apres);
+        const branche = option(argv, "branch");
+        process.stdout.write(`${rendreDelta(d, { ...(branche ? { branche } : {}), base })}\n`);
+        if (avant.illisibles.length > 0) {
+            process.stderr.write(`⚠ ${avant.illisibles.length} fichier(s) illisible(s) côté base : la comparaison est incomplète.\n`);
+        }
+        void constats;
+        return true;
+    }
+    process.stderr.write(`Sous-commande inconnue : ${cmd}\n\n${AIDE}\n`);
+    process.exitCode = 2;
+    return true;
+}

package/dist/craft-measures.js

@@ -462,7 +462,7 @@ export const TOLERANCE_TYPO = 1;
  * relie deux. En dessous de trois, la mesure le DIT au lieu de rendre un
  * chiffre qui ne veut rien dire.
  */
-export function echelleTypo(items) {
+export function echelleTypo(items, systeme) {
     const nonMesures = [];
     const vues = new Set();
     for (const it of items) {
@@ -476,11 +476,33 @@ export function echelleTypo(items) {
         vues.add(px);
     }
     const tailles = [...vues].sort((a, b) => a - b);
-    if (tailles.length < 3) {
+    /* L'ÉCHELLE ÉNUMÉRÉE PASSE AVANT TOUT LE RESTE, Y COMPRIS AVANT LE SEUIL DE
+       TROIS TAILLES. Ce seuil existe parce qu'on ne DÉDUIT rien de deux valeurs ;
+       ici on ne déduit pas, on compare à une liste écrite. Une équipe qui déclare
+       son échelle a droit à sa mesure même sur un fichier qui n'en emploie
+       qu'une. */
+    const declarees = (systeme?.taillesTypo ?? []).filter((n) => Number.isFinite(n) && n > 0);
+    if (declarees.length > 0) {
+        const attendues = [...new Set(declarees)].sort((a, b) => a - b);
+        /* Conformité = APPARTENANCE. Pas de tolérance : une liste ne se discute
+           pas, et « à un pixel près d'un pas déclaré » n'est pas le pas déclaré. */
+        const dansLaListe = new Set(attendues);
+        const orphelines = tailles.filter((t) => !dansLaListe.has(t));
+        return {
+            valeur: { ratio: null, ecartMoyen: null },
+            detail: { tailles, attendues, orphelines, essais: [], origine: "énumérée" },
+            completude: { lus: tailles.length, nonMesures },
+        };
+    }
+    /* UN RATIO DÉCLARÉ N'EST PAS UN RATIO À DEVINER. Tant que ce paramètre
+       n'existait pas, `ratioTypo` se déclarait et ne servait à rien : la mesure
+       cherchait le ratio le moins faux et ignorait celui de l'équipe. */
+    const ratioDeclare = systeme?.ratioTypo && systeme.ratioTypo > 1 && systeme.ratioTypo <= 3 ? systeme.ratioTypo : null;
+    if (tailles.length < 3 && !ratioDeclare) {
         nonMesures.push(`${tailles.length} taille(s) distincte(s) : en dessous de trois, n'importe quel ratio les relie — aucune échelle n'est déductible.`);
         return {
             valeur: { ratio: null, ecartMoyen: null },
-            detail: { tailles, attendues: [], orphelines: [], essais: [] },
+            detail: { tailles, attendues: [], orphelines: [], essais: [], origine: "déduite" },
             completude: { lus: tailles.length, nonMesures },
         };
     }
@@ -493,14 +515,16 @@ export function echelleTypo(items) {
         const ecart = tailles.reduce((somme, t) => somme + Math.min(...pas.map((p) => Math.abs(p - t))), 0) / tailles.length;
         return { ratio, ecart: Math.round(ecart * 1000) / 1000 };
     }).sort((a, b) => a.ecart - b.ecart);
-    const gagnant = essais[0];
+    const gagnant = ratioDeclare
+        ? (essais.find((e) => e.ratio === ratioDeclare) ?? { ratio: ratioDeclare, ecart: 0 })
+        : essais[0];
     const attendues = [];
     for (let v = base; v <= max * gagnant.ratio; v *= gagnant.ratio)
         attendues.push(Math.round(v * 10) / 10);
     const orphelines = tailles.filter((t) => Math.min(...attendues.map((p) => Math.abs(p - t))) > TOLERANCE_TYPO);
     return {
         valeur: { ratio: gagnant.ratio, ecartMoyen: gagnant.ecart },
-        detail: { tailles, attendues, orphelines, essais },
+        detail: { tailles, attendues, orphelines, essais, origine: ratioDeclare ? "ratio déclaré" : "déduite" },
         completude: { lus: tailles.length, nonMesures },
     };
 }

package/dist/craft-report.js

@@ -38,7 +38,7 @@ export function craftReport(brut, opts = {}) {
     const grille = conformiteGrille(items, reference.base);
     const pas = distinctes(items, estEspacement);
     const coherence = echelleCoherente(pas.detail, reference.base);
-    const typo = echelleTypo(items);
+    const typo = echelleTypo(items, opts.systeme);
     const tailles = distinctes(items, estTailleTypo);
     const doublons = quasiDoublonsCouleur(items);
     const couleurs = new Set(items.filter(estCouleur).map((i) => (i.value ?? "").trim().toLowerCase()));
@@ -71,6 +71,8 @@ export function craftReport(brut, opts = {}) {
             ratio: typo.valeur.ratio,
             ecartMoyen: typo.valeur.ecartMoyen,
             tailles: typo.detail.tailles,
+            attendues: typo.detail.attendues,
+            origine: typo.detail.origine,
             orphelines: typo.detail.orphelines,
             nonMesures: [...typo.completude.nonMesures, ...tailles.completude.nonMesures],
         },
@@ -193,13 +195,30 @@ export function rendreCraftReport(r, opts = {}) {
     l.push("");
     /* ── Typographie ── */
     l.push("LES TAILLES DE TEXTE");
-    if (r.typo.ratio === null) {
+    /* TROIS PHRASES, PARCE QU'IL Y A TROIS SITUATIONS — et les confondre revient
+       à opposer une supposition à une décision. « déduite » doit se lire comme
+       déduite : c'est le seul cas où l'échelle vient de nous et pas de l'équipe. */
+    if (r.typo.origine === "énumérée") {
+        l.push(`  ${r.typo.tailles.length} taille(s) employée(s) : ${r.typo.tailles.join(", ")}.` + cite("TYPO-02"));
+        l.push(`  Mesuré contre l'échelle ÉNUMÉRÉE que l'équipe a déclarée — ${r.typo.attendues.join(", ")}. ` +
+            "Aucun ratio n'est cherché : la conformité, ici, c'est d'être dans la liste." + cite("TYPO-01"));
+        if (r.typo.orphelines.length > 0) {
+            l.push(`  ${r.typo.orphelines.length} taille(s) hors de l'échelle déclarée : ${r.typo.orphelines.join(", ")}.`);
+        }
+        else {
+            l.push("  Toutes tombent sur un pas déclaré.");
+        }
+    }
+    else if (r.typo.ratio === null) {
         l.push(`  Pas assez de tailles distinctes pour déduire une échelle (${r.typo.tailles.length}).` + cite("TYPO-01"));
     }
     else {
         l.push(`  ${r.typo.tailles.length} taille(s) : ${r.typo.tailles.join(", ")}.` + cite("TYPO-02"));
-        l.push(`  L'échelle qui les explique le mieux est un ratio de ${r.typo.ratio} ` +
-            `(écart moyen ${r.typo.ecartMoyen} pixel).` + cite("TYPO-01"));
+        l.push(r.typo.origine === "ratio déclaré"
+            ? `  Mesuré contre le ratio de ${r.typo.ratio} que l'équipe a déclaré ` +
+                `(écart moyen ${r.typo.ecartMoyen} pixel).` + cite("TYPO-01")
+            : `  Aucune échelle déclarée : celle qui les explique le mieux est un ratio de ${r.typo.ratio} ` +
+                `(écart moyen ${r.typo.ecartMoyen} pixel). C'est une déduction, pas une décision.` + cite("TYPO-01"));
         if (r.typo.orphelines.length > 0) {
             l.push(`  ${r.typo.orphelines.length} taille(s) qu'aucun pas n'explique : ${r.typo.orphelines.join(", ")}.`);
         }

package/dist/craft-store.js

@@ -0,0 +1,76 @@
+/**
+ * LES INSTANTANÉS DE MESURE — sans historique, pas de tendance.
+ *
+ * `craft_report` calculait et oubliait. Une conformité de 97 % ne dit rien toute
+ * seule : c'est « 94 puis 97 » qui raconte quelque chose, et « 97 puis 91 » qui
+ * réveille quelqu'un. On garde donc chaque instantané, horodaté, dans le projet.
+ *
+ * Ce qu'on garde est VOLONTAIREMENT MAIGRE : les comptes, pas les listes. Un
+ * instantané n'a pas à rejouer le rapport — il sert à dire ce qui a bougé, et
+ * la liste exhaustive se recalcule en une seconde depuis le code courant.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { workspaceDir } from "./paths.js";
+export function craftDir() {
+    return process.env.DWAI_CRAFT_PATH ?? workspaceDir("craft");
+}
+export function horodatage(now) {
+    return now.toISOString().replace(/[:.]/g, "-").replace("T", "_").replace(/Z$/, "").slice(0, 16);
+}
+export function depuisRapport(r, now) {
+    return {
+        at: now.toISOString(),
+        reference: { niveau: r.reference.niveau, base: r.reference.base, contre: r.reference.contre },
+        espace: {
+            total: r.espace.total,
+            conformes: r.espace.conformes,
+            pct: Math.round(r.espace.pct * 1000) / 1000,
+            divergents: r.espace.divergents.length,
+            pas: r.espace.pas,
+        },
+        typo: { tailles: r.typo.tailles.length, ratio: r.typo.ratio, orphelines: r.typo.orphelines.length },
+        couleurs: { distinctes: r.couleurs.distinctes, doublons: r.couleurs.doublons },
+        rayons: r.rayons.distincts,
+        grille: {
+            bascules: r.grille.bascules.length,
+            horsPlages: r.grille.horsPlages.length,
+            plafonds: r.grille.plafonds,
+        },
+        lecture: { rencontrees: r.lecture.rencontrees, lues: r.lecture.lues },
+    };
+}
+export function enregistrerInstantane(i, now) {
+    const dir = craftDir();
+    mkdirSync(dir, { recursive: true });
+    const chemin = path.join(dir, `${horodatage(now)}.json`);
+    writeFileSync(chemin, `${JSON.stringify(i, null, 2)}\n`);
+    return chemin;
+}
+/** Tous les instantanés, du plus ancien au plus récent. Un abîmé disparaît. */
+export function lireInstantanes() {
+    const dir = craftDir();
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const f of readdirSync(dir).filter((x) => x.endsWith(".json")).sort()) {
+        try {
+            const o = JSON.parse(readFileSync(path.join(dir, f), "utf8"));
+            if (o && typeof o.at === "string" && o.espace)
+                out.push(o);
+        }
+        catch {
+            /* Un instantané illisible n'est pas une mesure. Le fil s'en charge : c'est
+               lui qui rend l'événement « illisible », pas ce lecteur. */
+        }
+    }
+    return out;
+}
+/** Le dernier et l'avant-dernier — de quoi dire ce qui a bougé, et rien de plus. */
+export function tendance() {
+    const tous = lireInstantanes();
+    return {
+        dernier: tous[tous.length - 1] ?? null,
+        precedent: tous[tous.length - 2] ?? null,
+    };
+}

package/dist/ds-inventory.js

@@ -38,9 +38,27 @@ export const SAIT_LIRE_STORIES = [
     "le composant documenté (dernier segment du `title`, ou nom du fichier)",
     "les états documentés (un export nommé par story)",
 ];
+/**
+ * CE QU'ON NE LIT PAS — et la fois où cette liste a menti.
+ *
+ * En faisant tourner la mesure sur NOTRE propre dépôt pour remplir le registre,
+ * elle est revenue à 100 % de conformité d'espacement. Le réflexe est écrit
+ * quelque part depuis le premier jour : à 100 %, c'est la mesure qui est
+ * fausse, pas nous qui sommes parfaits. Elle lisait le dossier `backups` — des
+ * copies de builds de production — et y trouvait la feuille CSS compilée de
+ * Tailwind. Les variables internes de Tailwind et son échelle nommée y tombent
+ * évidemment sur la grille : ils SONT la grille. On mesurait le générateur au
+ * lieu de mesurer l'usage, et on aurait archivé ce chiffre-là.
+ *
+ * `out`, `dist`, `build` et `.next` étaient déjà là ; il manquait les
+ * conventions de sauvegarde et le dossier de travail de ce produit. Aucune de
+ * ces entrées n'est un nom propre : ce sont des conventions, et un dépôt qui
+ * y range de la source a de plus gros soucis que sa grille.
+ */
 const IGNORE = new Set([
     "node_modules", ".git", ".next", "dist", "build", "out", "coverage",
     ".turbo", ".vercel", "vendor", "__snapshots__",
+    "backups", "backup", ".backups", "_next", ".designwithai", ".cache", "tmp",
 ]);
 /** Plafonds de parcours : un dépôt réel ne se lit pas entièrement à chaud. */
 const MAX_FICHIERS = 4000;

package/dist/pr-delta.js

@@ -0,0 +1,107 @@
+/**
+ * LE DELTA DE BRANCHE — ce que cette branche change au registre.
+ *
+ * Deux registres, celui de la base et celui de la branche, et la même
+ * `diffFindings` que partout ailleurs — avec ses DÉPLACÉS. C'est le point :
+ * un sélecteur renommé ne devient pas « réglé » dans un commentaire de PR
+ * plus qu'ailleurs, et la catégorie qui dit « je ne sais pas » existe ici
+ * aussi.
+ *
+ * AUCUN SERVICE À NOUS DANS LA BOUCLE. Les fichiers du registre sont dans git ;
+ * le calcul est déterministe et local. Le commentaire est posté par l'Action
+ * avec le jeton standard de GitHub — pas de secret designwithai, pas d'appel
+ * sortant, rien à héberger.
+ *
+ * Aucune dépendance de valeur hors des modules purs.
+ */
+import { diffFindings } from "./finding-identity.js";
+import { estProuve } from "./registry-events.js";
+/** Tous les constats d'un jeu de revues, à plat. */
+export function constats(reviews) {
+    return reviews.flatMap((r) => r.findings);
+}
+/**
+ * Ce que la branche change.
+ *
+ * « Réglé » se mesure sur DEUX conditions réunies : le constat a disparu de la
+ * branche, ET il portait une vérification. Un constat simplement absent est
+ * « résolu » au sens du diff — mais rien ne prouve qu'il a été corrigé, et
+ * c'est pourquoi il ne s'affiche pas comme réglé.
+ */
+export function delta(base, branche) {
+    const avant = constats(base);
+    const apres = constats(branche);
+    const d = diffFindings(avant, apres);
+    /* Un constat disparu de la branche : est-ce réglé ? On le dit seulement si la
+       branche porte sa vérification. Sinon il est simplement absent, et c'est un
+       autre mot. */
+    const versionApres = (f) => apres.find((x) => (x.title ?? x.summary) === (f.title ?? f.summary)) ?? f;
+    /* CE QUE LA BRANCHE CHANGE, PAS CE QU'ELLE CONTIENT. Un constat déjà prouvé
+       dans la base n'est pas réglé PAR cette branche : le recompter ferait
+       grossir le chiffre à chaque PR sans que personne ne corrige rien. */
+    const dejaProuve = new Set(avant.filter(estProuve).map((f) => f.title ?? f.summary ?? ""));
+    const reglesProuves = apres.filter((f) => estProuve(f) && !dejaProuve.has(f.title ?? f.summary ?? ""));
+    const declaresCorriges = apres.filter((f) => !estProuve(f) && (f.status === "fixed" || f.status === "partial"));
+    /* UN CONSTAT N'APPARAÎT QUE DANS UNE CASE. Un défaut trouvé ET corrigé dans
+       la même branche arrive « nouveau » au sens du diff, mais il est déjà
+       annoncé comme corrigé plus haut. Le laisser dans les deux gonflerait le
+       compte de deux façons opposées dans le même commentaire. */
+    const dejaDit = new Set([...reglesProuves, ...declaresCorriges]);
+    return {
+        reglesProuves,
+        declaresCorriges,
+        nouveaux: d.added.filter((f) => !dejaDit.has(f)),
+        deplaces: (d.deplaces ?? []).map((x) => ({ avant: x.avant, apres: versionApres(x.apres) })),
+        persistants: d.persisting.filter((f) => !dejaDit.has(f) && f.status !== "fixed"),
+    };
+}
+const titre = (f) => f.title || f.summary || "un constat";
+/** Le commentaire de PR, en Markdown. Une ligne de comptes, le détail dépliable. */
+export function rendreDelta(d, opts = {}) {
+    /* LA BASE SANS REGISTRE N'EST PAS UNE BASE VIDE. Rendre « 12 nouveaux » quand
+       la base n'a simplement jamais versionné son registre transforme une absence
+       d'information en accusation. On le dit, et on ne compte rien. */
+    if (opts.baseSansRegistre) {
+        return [
+            `**Pas de comparaison possible** — ${opts.base ? `\`${opts.base}\`` : "la base"} ne contient aucun fichier de registre.`,
+            "",
+            "Ce n'est pas « aucun constat » : c'est « rien à comparer ». Le delta suppose que " +
+                "`.designwithai/` est versionné des deux côtés. S'il est dans le `.gitignore`, " +
+                "cette comparaison ne peut pas exister — et un delta rendu quand même dirait le contraire de la vérité.",
+        ].join("\n");
+    }
+    const bouts = [
+        `${d.reglesProuves.length} réglé${d.reglesProuves.length > 1 ? "s" : ""} (vérifié${d.reglesProuves.length > 1 ? "s" : ""})`,
+        `${d.nouveaux.length} nouveau${d.nouveaux.length > 1 ? "x" : ""}`,
+        `${d.deplaces.length} déplacé${d.deplaces.length > 1 ? "s" : ""}`,
+        `${d.persistants.length} persistant${d.persistants.length > 1 ? "s" : ""}`,
+    ];
+    const l = [];
+    l.push(`**${opts.branche ? `${opts.branche} : ` : "Cette branche : "}${bouts.join(" · ")}**`);
+    if (d.declaresCorriges.length > 0) {
+        const n = d.declaresCorriges.length;
+        l.push("");
+        l.push(`${n} autre${n > 1 ? "s sont déclarés" : " est déclaré"} corrigé${n > 1 ? "s" : ""} ` +
+            `**sans vérification** — non compté${n > 1 ? "s" : ""} dans les réglés.`);
+    }
+    const bloc = (nom, lignes) => {
+        if (lignes.length === 0)
+            return;
+        l.push("");
+        l.push(`<details><summary>${nom} (${lignes.length})</summary>`);
+        l.push("");
+        for (const x of lignes)
+            l.push(`- ${x}`);
+        l.push("");
+        l.push("</details>");
+    };
+    bloc("Réglés, avec preuve", d.reglesProuves.map((f) => `${titre(f)} — vérifié contre ${f.verified_by}`));
+    bloc("Déclarés corrigés, sans vérification", d.declaresCorriges.map(titre));
+    bloc("Nouveaux", d.nouveaux.map((f) => `${titre(f)}${f.severity ? ` (${f.severity})` : ""}`));
+    bloc("Déplacés — ni réglés, ni nouveaux", d.deplaces.map((x) => `${titre(x.apres)} — « ${x.avant.ancre?.selector ?? "?"} » → « ${x.apres.ancre?.selector ?? "?"} ». ` +
+        "Même défaut renommé, ou deux éléments jumeaux : rien ici ne permet de trancher."));
+    bloc("Persistants", d.persistants.map((f) => `${titre(f)}${f.severity ? ` (${f.severity})` : ""}`));
+    l.push("");
+    l.push("<sub>Dérivé du registre versionné, en comparant la base et la branche. Aucun service tiers n'intervient.</sub>");
+    return l.join("\n");
+}