designwithai-mcp 0.12.0 → 0.14.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

@@ -174,8 +174,30 @@ export const LARGEUR_DEFAUT_REM = {
  * `h-auto`, `p-[7px]` ne se résolvent pas ici, et c'est très bien — ils ont
  * chacun leur chemin.
  */
-export function resoudrePasNomme(famille, pas, racine, theme = {}) {
+export function resoudrePasNomme(famille, pas, racine, theme = {}, 
+/**
+ * L'échelle typographique DÉCLARÉE, quand elle est énumérée.
+ *
+ * `--font-size-4` ne veut rien dire dans l'absolu : c'est le quatrième pas de
+ * l'échelle que l'équipe a choisie. Sans cette liste, la mesure ne peut que
+ * l'ignorer — et une échelle ignorée fait tomber le compte à zéro, ce qui
+ * ressemble à une victoire.
+ */
+echelleDeclaree, 
+/** L'échelle de rayons déclarée. Même rôle, même raison. */
+rayonsDeclares) {
     const cle = pas.toLowerCase();
+    /* Un pas du kit : `font-size-1` est le PREMIER de la liste, pas l'index 1. */
+    const kitTexte = cle.match(/^font-size-(\d+)$/);
+    if (kitTexte && echelleDeclaree?.length) {
+        const px = echelleDeclaree[Number(kitTexte[1]) - 1];
+        return px !== undefined ? { px, provenance: "theme" } : null;
+    }
+    const kitRayon = cle.match(/^radius-(\d+)$/);
+    if (kitRayon && rayonsDeclares?.length) {
+        const px = rayonsDeclares[Number(kitRayon[1]) - 1];
+        return px !== undefined ? { px, provenance: "theme" } : null;
+    }
     if (famille === "espacement") {
         if (cle in PAS_LITTERAUX) {
             const v = PAS_LITTERAUX[cle];
@@ -242,9 +264,76 @@ function lireTheme(items) {
  * C'est ce qui permet d'ajouter une unité ou une échelle sans rouvrir les huit
  * fonctions de mesure — et ce qui garantit que toutes convertissent pareil.
  */
-export function resoudreItems(brut) {
+/**
+ * LA TABLE DES ALIAS — `--radius-carte` vaut `var(--radius-4)` vaut 8 pixels.
+ *
+ * Un dépôt qui a fini sa migration n'écrit plus de valeurs : il écrit des noms
+ * qui pointent sur des noms. Sans suivre la chaîne, la mesure voit
+ * `var(--radius-carte)`, n'en tire rien, et rend « 0 rayon distinct » sur un
+ * produit qui en emploie six.
+ *
+ * ELLE NE REND JAMAIS « CONFORME » CE QU'ELLE NE SAIT PAS RÉSOUDRE. Une chaîne
+ * qui n'aboutit pas ressort en illisible AVEC la chaîne citée — c'est ce qui
+ * distingue « 0 divergent sur 13 résolus » de « 0 divergent parce que 13
+ * invisibles ». La deuxième phrase est un mensonge qui a l'air d'un succès.
+ */
+function tableDesAlias(brut) {
+    const t = new Map();
+    for (const it of brut) {
+        if (it.kind !== "token")
+            continue;
+        const v = (it.value ?? "").trim();
+        if (!v)
+            continue;
+        /* L'inventaire range les variables CSS SANS leurs deux tirets — `radius-sm`
+           et non `--radius-sm`. Chercher la forme écrite dans le code ne trouvait
+           donc jamais rien, et toute la table restait vide : la chaîne d'alias
+           échouait au premier maillon sans qu'on voie pourquoi. On indexe les deux
+           formes plutôt que d'en imposer une : les deux existent dans le dépôt. */
+        if (it.name.startsWith("--"))
+            t.set(it.name, v);
+        else if ((it.type ?? "") === "css-variable")
+            t.set(`--${it.name}`, v);
+    }
+    return t;
+}
+/** Le maillon final d'une chaîne, ou la chaîne parcourue si elle n'aboutit pas. */
+export function suivreAlias(valeur, alias, pasKit, profondeurMax = 8) {
+    const chaine = [valeur];
+    let courant = valeur.trim();
+    for (let i = 0; i < profondeurMax; i++) {
+        const m = courant.match(/^var\(\s*(--[a-zA-Z0-9-]+)\s*(?:,[^)]*)?\)$/);
+        if (!m)
+            break;
+        const nom = m[1];
+        /* Un pas du kit ne se trouve pas dans le fichier : il vient de l'échelle
+           DÉCLARÉE. C'est le bout de la chaîne, et le seul endroit où elle peut
+           aboutir sur un nombre sans que ce nombre soit écrit quelque part. */
+        const kit = pasKit(nom);
+        if (kit !== null)
+            return { px: kit };
+        const suivant = alias.get(nom);
+        if (suivant === undefined)
+            return { chaine };
+        courant = suivant.trim();
+        chaine.push(courant);
+    }
+    const px = brutEnPixels(courant, RACINE_PAR_DEFAUT);
+    return px === null ? { chaine } : { px };
+}
+export function resoudreItems(brut, echelleDeclaree, rayonsDeclares) {
     const racine = resoudreRacine(brut);
     const theme = lireTheme(brut);
+    const alias = tableDesAlias(brut);
+    const pasKit = (nom) => {
+        const r = nom.match(/^--radius-(\d+)$/);
+        if (r && rayonsDeclares?.length)
+            return rayonsDeclares[Number(r[1]) - 1] ?? null;
+        const t = nom.match(/^--font-size-(\d+)$/);
+        if (t && echelleDeclaree?.length)
+            return echelleDeclaree[Number(t[1]) - 1] ?? null;
+        return null;
+    };
     const items = [];
     const illisibles = [];
     const em = [];
@@ -276,7 +365,7 @@ export function resoudreItems(brut) {
         /* Un pas nommé : sa valeur ne se lit pas, elle se résout. */
         if (it.attrs?.provenance === "nomme") {
             const famille = (it.attrs.famille ?? type);
-            const r = resoudrePasNomme(famille, it.attrs.pas ?? "", racine.px, theme);
+            const r = resoudrePasNomme(famille, it.attrs.pas ?? "", racine.px, theme, echelleDeclaree, rayonsDeclares);
             if (!r) {
                 illisibles.push(`${it.name}${it.location ? ` (${it.location})` : ""} — pas nommé inconnu de l'échelle`);
                 continue;
@@ -290,7 +379,19 @@ export function resoudreItems(brut) {
             em.push(`${it.name} = ${v}${it.location ? ` (${it.location})` : ""}`);
             continue;
         }
-        const px = brutEnPixels(v, racine.px);
+        let px = brutEnPixels(v, racine.px);
+        if (px === null && v.startsWith("var(")) {
+            const suivi = suivreAlias(v, alias, pasKit);
+            if ("px" in suivi) {
+                px = suivi.px;
+            }
+            else {
+                /* La chaîne est CITÉE : sans elle, « illisible » n'aide personne à
+                   réparer, et le compte des non-résolues resterait un chiffre nu. */
+                illisibles.push(`${it.name}${it.location ? ` (${it.location})` : ""} — chaîne non résolue : ${suivi.chaine.join(" → ")}`);
+                continue;
+            }
+        }
         if (px === null) {
             illisibles.push(`${it.name} = « ${v || "(vide)"} »${it.location ? ` (${it.location})` : ""}`);
             continue;
@@ -462,7 +563,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 +577,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 +616,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

@@ -31,18 +31,30 @@ export function craftReport(brut, opts = {}) {
     /* UNE SEULE PASSE DE RÉSOLUTION, avant tout. Les mesures qui suivent ne
        voient plus que des pixels : la racine, le thème et l'échelle du cadre ont
        déjà fait leur travail, et de la même façon pour toutes. */
-    const resolution = resoudreItems(brut);
+    const resolution = resoudreItems(brut, opts.systeme?.taillesTypo, opts.systeme?.rayons);
     const items = resolution.items;
     const reference = referenceEspacement(items, opts.systeme);
     const refCibles = referenceCible(opts.systeme);
     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()));
-    const rayons = distinctes(items, estRayon);
+    /* L'EXCLUSION S'APPLIQUE ICI, ET ELLE SE COMPTE.
+       On ne retire pas des éléments en silence : on les met de côté, on compte
+       ce qu'on a mis de côté, et le rapport le dit fichier par fichier. Une
+       mesure qui rétrécit sans le dire ment plus efficacement qu'une mesure
+       fausse — elle a l'air juste. */
+    const exclusions = opts.systeme?.exclusions ?? [];
+    const estExclu = (it) => exclusions.some((e) => (it.location ?? "").includes(e.fichier));
+    const ecartes = exclusions.map((e) => ({
+        fichier: e.fichier,
+        raison: e.raison,
+        valeurs: items.filter((it) => estRayon(it) && (it.location ?? "").includes(e.fichier)).length,
+    }));
+    const rayons = distinctes(items.filter((it) => !estExclu(it)), estRayon);
     const bp = bascules(items);
     const plafonds = largeursMax(items);
     const cibles = opts.annotations ? ciblesTactiles(opts.annotations, refCibles.base) : null;
@@ -71,6 +83,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],
         },
@@ -80,7 +94,12 @@ export function craftReport(brut, opts = {}) {
             paires: doublons.detail.paires.map((p) => ({ a: p.a, b: p.b, ecart: p.ecart })),
             nonMesures: doublons.completude.nonMesures,
         },
-        rayons: { distincts: rayons.valeur, liste: rayons.detail, nonMesures: rayons.completude.nonMesures },
+        rayons: {
+            distincts: rayons.valeur,
+            liste: rayons.detail,
+            nonMesures: rayons.completude.nonMesures,
+            ecartes: ecartes.filter((e) => e.valeurs > 0),
+        },
         grille: {
             bascules: bp.detail.trouvees,
             horsPlages: bp.detail.horsPlages,
@@ -193,13 +212,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(", ")}.`);
         }
@@ -221,6 +257,13 @@ export function rendreCraftReport(r, opts = {}) {
         l.push("  Aucune paire trop proche pour être distinguée.");
     }
     l.push(`  ${r.rayons.distincts} rayon(s) distinct(s)${r.rayons.liste.length ? ` : ${r.rayons.liste.join(", ")}` : ""}.` + cite("RADIUS-01"));
+    /* CE BLOC N'EST PAS FACULTATIF. Un chiffre obtenu en écartant des valeurs ne
+       vaut que si le lecteur sait lesquelles, combien, et pourquoi — sinon il
+       compare une mesure rétrécie à une mesure pleine sans le savoir. */
+    for (const e of r.rayons.ecartes) {
+        l.push(`  1 fichier écarté de ce compte : ${e.fichier}, ${e.valeurs} valeur(s).`);
+        l.push(`    Raison déclarée : ${e.raison}`);
+    }
     l.push("");
     /* ── Grilles ── */
     l.push("LES BASCULES ET LES PLAFONDS");

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;
@@ -173,6 +191,30 @@ function lireTaillesTexte(etat, contenu, fichier) {
     const vus = new Set();
     for (const m of contenu.matchAll(/font-size\s*:\s*([^;}]+)/gi)) {
         const brut = m[1].trim();
+        /* UN PAS DU KIT SE RÉSOUT, IL NE SE JETTE PAS.
+           `font-size: var(--font-size-4)` partait dans `unread` avec les `clamp()`,
+           et les deux n'ont rien à voir. Un clamp dépend de la largeur de la
+           fenêtre : prendre une de ses bornes ferait entrer dans l'échelle un
+           chiffre que personne n'a choisi. Un pas nommé, lui, désigne une valeur
+           précise — celle que l'équipe a déclarée dans `taillesTypo`.
+           Tant qu'on les traitait pareil, migrer les valeurs sauvages vers
+           l'échelle faisait tomber le compte à zéro : la mesure devenait aveugle,
+           et le zéro ressemblait à une victoire. */
+        const pas = brut.match(/^var\(\s*--font-size-(\d+)\s*\)$/i);
+        if (pas) {
+            const cle = `font-size-${pas[1]}`;
+            if (vus.has(cle))
+                continue;
+            vus.add(cle);
+            etat.items.push({
+                kind: "token",
+                name: cle,
+                type: "typographie",
+                location: fichier,
+                attrs: { provenance: "nomme", famille: "typographie", pas: cle },
+            });
+            continue;
+        }
         const px = brut.match(/^([\d.]+)px$/i);
         if (!px) {
             if (/clamp|calc|var\(/i.test(brut)) {
@@ -392,8 +434,47 @@ function lireValeursArbitraires(etat, contenu, fichier) {
             attrs: { provenance: "arbitraire" },
         });
     }
+    lireVariablesEnClasse(etat, contenu, fichier);
     lirePasNommes(etat, contenu, fichier);
 }
+/**
+ * LES VARIABLES ÉCRITES DANS UNE CLASSE — `rounded-[var(--radius-carte)]`.
+ *
+ * C'est la forme que prend un dépôt qui a fini sa migration : plus une valeur
+ * en pixels dans le markup, rien que des noms. Tant qu'on ne la lisait pas, la
+ * mesure devenait AVEUGLE au moment précis où le travail était fait — elle
+ * rendait « 0 rayon distinct » sur un produit qui en emploie six, et le zéro
+ * ressemblait à une victoire.
+ *
+ * On note le nom ; la résolution se fait dans `craft-measures`, qui connaît la
+ * chaîne des alias et l'échelle déclarée. L'inventaire rapporte, il ne calcule
+ * pas.
+ */
+function lireVariablesEnClasse(etat, contenu, fichier) {
+    const vus = new Set();
+    for (const m of contenu.matchAll(/\b([a-z]+(?:-[a-z]+)?)-\[var\(\s*(--[a-z0-9-]+)\s*\)\]/gi)) {
+        const type = PREFIXE_TYPE.find(([re]) => re.test(m[1]))?.[1];
+        if (!type)
+            continue;
+        /* `text-[var(--color-…)]` est une COULEUR, pas une taille. Le préfixe est
+           le même — Tailwind s'en sert pour les deux — et la ranger en typographie
+           remplissait la liste des illisibles de fausses tailles de texte. */
+        if (type === "typographie" && /color|ink|brand|surface|border|pilier/i.test(m[2]))
+            continue;
+        const cle = `${m[1]}:${m[2]}`;
+        if (vus.has(cle))
+            continue;
+        vus.add(cle);
+        etat.items.push({
+            kind: "token",
+            name: `${m[1]}-[var(${m[2]})]`,
+            type,
+            value: `var(${m[2]})`,
+            location: fichier,
+            attrs: { provenance: "variable" },
+        });
+    }
+}
 /**
  * LES PAS NOMMÉS — la moitié du travail qui manquait.
  *