designwithai-mcp 0.1.0 → 0.4.0

package/dist/ds-diff.js

@@ -0,0 +1,268 @@
+/**
+ * LE DIFF D'ALIGNEMENT DS — comparateur déterministe, définition unique.
+ *
+ * Troisième module de ce dépôt à suivre le pattern de `finding-identity.ts`, et
+ * pour la même raison : deux surfaces ont besoin du MÊME calcul, et l'écrire
+ * deux fois garantit qu'elles diront un jour deux choses différentes des mêmes
+ * faits.
+ *
+ *   - le serveur MCP compare depuis l'éditeur, au moment où il lit le code ;
+ *   - le site compare depuis le cockpit, dès que les deux inventaires sont en
+ *     base — SANS repasser par l'éditeur.
+ *
+ * CONTRAINTE À TENIR : ce fichier ne dépend de rien. Ni `node:`, ni `Deno`, ni
+ * un autre module du dépôt. Il part dans un bundle navigateur.
+ *
+ * Ce qu'il fait, et rien d'autre : des ENSEMBLES. Présent des deux côtés,
+ * absent ici, absent là, divergent. Le rapprochement flou des noms
+ * (Button ↔ Btn ↔ bouton-primaire) n'est pas de son ressort : il arrive en
+ * entrée, sous forme de paires déjà établies et déjà prouvées.
+ */
+/** Normalisation POUR LA COMPARAISON seulement. Les noms d'origine sont gardés. */
+export function normaliser(nom) {
+    return nom
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^a-z0-9]+/g, "");
+}
+/** Deux valeurs disent-elles la même chose ? Les couleurs comprises. */
+export function memeValeur(a, b) {
+    if (a === undefined || b === undefined)
+        return true;
+    const c = (v) => v.trim().toLowerCase().replace(/\s+/g, "");
+    const x = c(a);
+    const y = c(b);
+    if (x === y)
+        return true;
+    const hex = (v) => {
+        const m = v.match(/^#([0-9a-f]{3,8})$/);
+        if (!m)
+            return null;
+        const h = m[1];
+        return h.length === 3 ? h.split("").map((d) => d + d).join("") : h;
+    };
+    const hx = hex(x);
+    const hy = hex(y);
+    if (hx && hy)
+        return hx.slice(0, 6) === hy.slice(0, 6);
+    /* 16px contre 1rem n'est PAS rapproché : une unité différente est un vrai
+       écart, et le deviner reviendrait à supposer une taille de base. */
+    return false;
+}
+const VIDE = {
+    aligne: 0,
+    "absent-figma": 0,
+    "absent-code": 0,
+    divergent: 0,
+    "non-jugeable": 0,
+};
+/**
+ * Compare deux inventaires. Déterministe, sans réseau, sans modèle.
+ *
+ * LA RÈGLE D'ABSENCE, appliquée ici comme partout : un écart « absent » n'est
+ * un constat que si l'inventaire d'en face est COMPLET. Sur un inventaire
+ * partiel, ce qu'on ne trouve pas est peut-être seulement ce qu'on n'a pas su
+ * lire — l'écart devient `non-jugeable`, et l'écran le dit au lieu de le
+ * compter comme une faute.
+ */
+export function comparer(figma, code, rapprochements = []) {
+    const parNom = (inv) => {
+        const m = new Map();
+        for (const it of inv.items)
+            m.set(`${it.kind} ${normaliser(it.name)}`, it);
+        return m;
+    };
+    const F = parNom(figma);
+    const C = parNom(code);
+    /* Les paires établies ailleurs, chacune avec sa preuve. */
+    const alias = new Map();
+    for (const r of rapprochements)
+        alias.set(normaliser(r.code), r);
+    const ecarts = [];
+    const vus = new Set();
+    for (const [cle, item] of F) {
+        const kind = cle.split(" ")[0];
+        let jumeau = C.get(cle);
+        let rapproche;
+        if (!jumeau) {
+            for (const [cCle, cItem] of C) {
+                if (!cCle.startsWith(`${kind} `))
+                    continue;
+                const r = alias.get(normaliser(cItem.name));
+                if (r && normaliser(r.figma) === normaliser(item.name)) {
+                    jumeau = cItem;
+                    rapproche = r.evidence;
+                    break;
+                }
+            }
+        }
+        if (jumeau) {
+            vus.add(`${jumeau.kind} ${normaliser(jumeau.name)}`);
+            const aligne = memeValeur(item.value, jumeau.value);
+            ecarts.push({
+                kind: aligne ? "aligne" : "divergent",
+                itemKind: item.kind,
+                name: item.name,
+                figma: item,
+                code: jumeau,
+                evidence: aligne
+                    ? `« ${item.name} » présent des deux côtés${item.value ? `, valeur ${item.value}` : ""}.`
+                    : `« ${item.name} » vaut ${item.value} côté maquette et ${jumeau.value} côté code.`,
+                rapproche,
+            });
+            continue;
+        }
+        ecarts.push({
+            kind: code.partial ? "non-jugeable" : "absent-code",
+            itemKind: item.kind,
+            name: item.name,
+            figma: item,
+            evidence: code.partial
+                ? `« ${item.name} » n'apparaît pas dans l'inventaire du code, mais cet inventaire est PARTIEL : son absence ne prouve rien.`
+                : `« ${item.name} » figure dans la maquette${item.location ? ` (${item.location})` : ""} et dans aucun des ${code.items.length} éléments lus côté code.`,
+        });
+    }
+    for (const [cle, item] of C) {
+        if (vus.has(cle))
+            continue;
+        ecarts.push({
+            kind: figma.partial ? "non-jugeable" : "absent-figma",
+            itemKind: item.kind,
+            name: item.name,
+            code: item,
+            evidence: figma.partial
+                ? `« ${item.name} » n'apparaît pas dans l'inventaire de la maquette, mais cette lecture est PARTIELLE : son absence ne prouve rien.`
+                : `« ${item.name} » existe en code${item.location ? ` (${item.location})` : ""} et dans aucun des ${figma.items.length} éléments lus côté maquette.`,
+        });
+    }
+    const compte = { ...VIDE };
+    for (const e of ecarts)
+        compte[e.kind]++;
+    const rang = {
+        divergent: 0,
+        "absent-code": 1,
+        "absent-figma": 2,
+        "non-jugeable": 3,
+        aligne: 4,
+    };
+    ecarts.sort((a, b) => rang[a.kind] - rang[b.kind] || a.name.localeCompare(b.name));
+    return {
+        ecarts,
+        compte,
+        partial: figma.partial || code.partial,
+        couverture: { figma: figma.covered, code: code.covered },
+        nonLu: { figma: figma.unread, code: code.unread },
+    };
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   LE RAPPROCHEMENT FLOU — quand les deux côtés parlent de la même chose sans
+   l'appeler pareil.
+
+   POURQUOI IL VIT DANS CE FICHIER ET PAS À CÔTÉ. Il était dans `ds-match.ts`,
+   et il y importait `normaliser` d'ici. Ça compile sous Node, ça casse au
+   bundle : `moduleResolution: NodeNext` exige l'extension `.js`, et le
+   bundler du site, lui, ne sait pas la faire pointer vers un `.ts`.
+
+   La règle du dépôt existait déjà, écrite en tête de `severity.ts` : un module
+   qui part dans le bundle navigateur NE DÉPEND DE RIEN. `ds-diff` et
+   `finding-identity` la tenaient ; le rapprochement a été le premier à
+   l'enfreindre, et le build l'a dit tout de suite.
+
+   Le remède aurait pu être une copie de `normaliser` de l'autre côté. C'eût
+   été le pire : deux normalisations qui dérivent, et un rapprochement qui
+   cesse silencieusement de trouver ce que la comparaison trouve. Rapprocher et
+   comparer sont deux moitiés d'une même opération et partagent déjà cette
+   fonction — elles vivent donc au même endroit.
+   ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * Le nom découpé en segments comparables.
+ *
+ * Un nom de design system est composé, pas rédigé : `brand/primary`,
+ * `--color-brand-primary`, `ColorBrandPrimary` disent la même chose avec trois
+ * conventions. On coupe donc sur les séparateurs ET sur les bosses de casse,
+ * puis on met à plat. Les suites de chiffres restent des segments : `space-4`
+ * et `space-8` ne doivent pas se rapprocher.
+ */
+export function segments(nom) {
+    return nom
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .split(/[^A-Za-z0-9]+/)
+        .flatMap((m) => m.split(/(?<=[a-zA-Z])(?=[0-9])|(?<=[0-9])(?=[a-zA-Z])/))
+        .map((m) => m.toLowerCase())
+        .filter((m) => m.length > 0);
+}
+/** Au moins deux segments communs. Un seul mot partagé ne prouve rien. */
+export const MIN_PARTAGES = 2;
+/**
+ * Le seuil de Dice.
+ *
+ * 0,5 veut dire : la moitié des segments des deux noms réunis sont communs.
+ * `brand/primary` contre `--color-brand-primary` fait 0,8 ; `text/body large`
+ * contre `--font-body-large` fait 0,67 ; `brand/primary` contre
+ * `--color-brand-secondary` tombe sous le plancher des deux segments avant même
+ * d'être mesuré. Le seuil est haut à dessein : ce module a le droit de rater un
+ * rapprochement, il n'a pas le droit d'en inventer un.
+ */
+export const SEUIL = 0.5;
+/** Dice sur les ensembles de segments : 2·|A∩B| / (|A|+|B|). */
+export function score(a, b) {
+    const A = new Set(segments(a));
+    const B = new Set(segments(b));
+    if (A.size === 0 || B.size === 0)
+        return { dice: 0, partages: [] };
+    const partages = [...A].filter((s) => B.has(s));
+    return { dice: (2 * partages.length) / (A.size + B.size), partages };
+}
+/**
+ * Les paires établies entre deux inventaires.
+ *
+ * Le résultat est stable : même entrée, même sortie, dans le même ordre. Les
+ * éléments dont les noms se normalisent à l'identique sont laissés au
+ * comparateur exact — les rapprocher ici les compterait deux fois.
+ */
+export function rapprocher(figma, code) {
+    const exacts = new Set(code.map((c) => `${c.kind} ${normaliser(c.name)}`));
+    const pris = new Set();
+    const paires = [];
+    for (const f of figma) {
+        const cle = `${f.kind} ${normaliser(f.name)}`;
+        if (exacts.has(cle))
+            continue; // le comparateur exact s'en charge
+        let meilleur = null;
+        let exaequo = false;
+        for (const c of code) {
+            if (c.kind !== f.kind)
+                continue; // garde-fou 1
+            if (pris.has(`${c.kind} ${normaliser(c.name)}`))
+                continue;
+            if (normaliser(c.name) === normaliser(f.name))
+                continue;
+            const { dice, partages } = score(f.name, c.name);
+            if (partages.length < MIN_PARTAGES || dice < SEUIL)
+                continue; // garde-fous 2
+            if (!meilleur || dice > meilleur.dice) {
+                meilleur = { item: c, dice, partages };
+                exaequo = false;
+            }
+            else if (dice === meilleur.dice) {
+                exaequo = true; // garde-fou 3
+            }
+        }
+        /* L'ambiguïté ne se tranche pas. Deux candidats au même score veut dire
+           qu'on ne sait pas — et « je ne sais pas » ne se déguise pas en paire. */
+        if (!meilleur || exaequo)
+            continue;
+        pris.add(`${meilleur.item.kind} ${normaliser(meilleur.item.name)}`);
+        paires.push({
+            figma: f.name,
+            code: meilleur.item.name,
+            evidence: `« ${f.name} » et « ${meilleur.item.name} » partagent ` +
+                `${meilleur.partages.map((p) => `« ${p} »`).join(", ")}.`,
+        });
+    }
+    return paires;
+}

package/dist/ds-inventory.js

@@ -0,0 +1,247 @@
+/**
+ * L'INVENTAIRE DU CODE — déterministe, et honnête sur ce qu'il ignore.
+ *
+ * Pas de repli sur un modèle. Cet extracteur sait lire une LISTE ÉCRITE de
+ * formats, et rien d'autre. Ce qu'il rencontre sans savoir le lire n'est pas
+ * deviné : il alimente `unread`, lève `partial`, et se dit à l'écran.
+ *
+ * Ce choix a une conséquence directe, et c'est tout l'intérêt : sur un
+ * inventaire partiel, le comparateur refuse de conclure à une absence (voir
+ * `ds-diff.ts`). Un extracteur qui prétendrait tout lire produirait des
+ * « composants manquants » qui ne sont que des fichiers non compris. Mieux vaut
+ * une couverture étroite et dite qu'une couverture large et supposée.
+ */
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+/**
+ * CE QUE JE SAIS LIRE. Cette liste part telle quelle dans l'inventaire, et
+ * s'affiche à la personne. L'allonger demande d'écrire l'extracteur qui va
+ * avec — jamais l'inverse.
+ */
+export const SAIT_LIRE = [
+    "tokens au format DTCG (*.tokens.json, tokens.json)",
+    "variables CSS personnalisées (--nom: valeur)",
+    "thème Tailwind (tailwind.config.*)",
+    "composants exportés (*.tsx, *.jsx)",
+    "stories Storybook (*.stories.*)",
+];
+const IGNORE = new Set([
+    "node_modules", ".git", ".next", "dist", "build", "out", "coverage",
+    ".turbo", ".vercel", "vendor", "__snapshots__",
+]);
+/** Plafonds de parcours : un dépôt réel ne se lit pas entièrement à chaud. */
+const MAX_FICHIERS = 4000;
+const MAX_OCTETS = 400_000;
+const pascal = (s) => /^[A-Z][A-Za-z0-9]*$/.test(s);
+/** Les tokens DTCG : un arbre dont les feuilles portent `$value`. */
+function lireDtcg(etat, contenu, fichier) {
+    let arbre;
+    try {
+        arbre = JSON.parse(contenu);
+    }
+    catch {
+        etat.unread.add(`${fichier} — JSON illisible`);
+        return;
+    }
+    const descendre = (noeud, chemin) => {
+        if (!noeud || typeof noeud !== "object")
+            return;
+        const o = noeud;
+        if ("$value" in o) {
+            etat.items.push({
+                kind: "token",
+                name: chemin.join("."),
+                type: typeof o.$type === "string" ? o.$type : undefined,
+                value: typeof o.$value === "string" ? o.$value : JSON.stringify(o.$value),
+                location: fichier,
+            });
+            return;
+        }
+        for (const [cle, valeur] of Object.entries(o)) {
+            if (cle.startsWith("$"))
+                continue;
+            descendre(valeur, [...chemin, cle]);
+        }
+    };
+    descendre(arbre, []);
+}
+/** Les variables CSS personnalisées, quelle que soit leur règle d'accueil. */
+function lireCss(etat, contenu, fichier) {
+    const re = /--([a-zA-Z0-9_-]+)\s*:\s*([^;}]+)[;}]/g;
+    let m;
+    const vus = new Set();
+    while ((m = re.exec(contenu))) {
+        const nom = m[1];
+        if (vus.has(nom))
+            continue;
+        vus.add(nom);
+        etat.items.push({
+            kind: "token",
+            name: nom,
+            type: "css-variable",
+            value: m[2].trim(),
+            location: fichier,
+        });
+    }
+}
+/**
+ * Le thème Tailwind.
+ *
+ * Une config est du JavaScript : l'évaluer exécuterait du code du dépôt
+ * audité, ce qui est hors de question. On lit donc les clés déclarées dans
+ * `theme` / `extend` par lecture de surface — déterministe, et volontairement
+ * limité aux formes simples. Une config qui compose, importe ou calcule ses
+ * valeurs part dans `unread` : dire qu'on n'a pas compris coûte moins cher
+ * qu'un inventaire faux.
+ */
+function lireTailwind(etat, contenu, fichier) {
+    const bloc = contenu.match(/theme\s*:\s*\{([\s\S]*)\}/);
+    if (!bloc) {
+        etat.unread.add(`${fichier} — aucun bloc theme reconnaissable`);
+        return;
+    }
+    const groupes = ["colors", "spacing", "borderRadius", "fontSize", "fontFamily", "boxShadow"];
+    let trouve = 0;
+    for (const groupe of groupes) {
+        const g = bloc[1].match(new RegExp(`${groupe}\\s*:\\s*\\{([^{}]*)\\}`));
+        if (!g)
+            continue;
+        const re = /["']?([a-zA-Z0-9_-]+)["']?\s*:\s*["']([^"']+)["']/g;
+        let m;
+        while ((m = re.exec(g[1]))) {
+            trouve++;
+            etat.items.push({
+                kind: "token",
+                name: `${groupe}.${m[1]}`,
+                type: groupe,
+                value: m[2],
+                location: fichier,
+            });
+        }
+    }
+    if (trouve === 0)
+        etat.unread.add(`${fichier} — thème présent mais aucune valeur littérale lisible`);
+    if (/\.\.\.|require\(|import\s/.test(bloc[1])) {
+        etat.unread.add(`${fichier} — le thème compose ou importe : lecture de surface incomplète`);
+    }
+}
+/** Les composants exportés. Un nom en PascalCase, exporté, fait foi. */
+function lireComposants(etat, contenu, fichier) {
+    const vus = new Set();
+    const motifs = [
+        /export\s+(?:default\s+)?function\s+([A-Za-z0-9_]+)/g,
+        /export\s+const\s+([A-Za-z0-9_]+)\s*[:=]/g,
+    ];
+    for (const re of motifs) {
+        let m;
+        while ((m = re.exec(contenu))) {
+            const nom = m[1];
+            if (!pascal(nom) || vus.has(nom))
+                continue;
+            vus.add(nom);
+            etat.items.push({ kind: "component", name: nom, location: fichier });
+        }
+    }
+}
+/** Les stories : ce qu'elles documentent, par leur titre ou leur nom de fichier. */
+function lireStories(etat, contenu, fichier) {
+    const titre = contenu.match(/title\s*:\s*["'`]([^"'`]+)["'`]/);
+    const nom = titre
+        ? titre[1].split("/").pop().trim()
+        : path.basename(fichier).replace(/\.stories\.[a-z]+$/i, "");
+    etat.items.push({ kind: "story", name: nom, location: fichier });
+}
+function parcourir(etat, racine, dossier) {
+    if (etat.plafond)
+        return;
+    let entrees;
+    try {
+        entrees = readdirSync(dossier);
+    }
+    catch {
+        return;
+    }
+    for (const entree of entrees) {
+        if (etat.plafond)
+            return;
+        if (entree.startsWith(".") && entree !== ".storybook")
+            continue;
+        const complet = path.join(dossier, entree);
+        let s;
+        try {
+            s = statSync(complet);
+        }
+        catch {
+            continue;
+        }
+        if (s.isDirectory()) {
+            if (IGNORE.has(entree))
+                continue;
+            parcourir(etat, racine, complet);
+            continue;
+        }
+        if (++etat.fichiers > MAX_FICHIERS) {
+            etat.plafond = true;
+            etat.unread.add(`parcours arrêté après ${MAX_FICHIERS} fichiers`);
+            return;
+        }
+        const relatif = path.relative(racine, complet);
+        if (s.size > MAX_OCTETS) {
+            etat.unread.add(`${relatif} — fichier trop volumineux pour être lu`);
+            continue;
+        }
+        let contenu;
+        try {
+            contenu = readFileSync(complet, "utf8");
+        }
+        catch {
+            etat.unread.add(`${relatif} — illisible`);
+            continue;
+        }
+        if (/\.stories\.[jt]sx?$/i.test(entree))
+            lireStories(etat, contenu, relatif);
+        else if (/\.tokens\.json$/i.test(entree) || entree === "tokens.json")
+            lireDtcg(etat, contenu, relatif);
+        else if (/^tailwind\.config\.[cm]?[jt]s$/i.test(entree))
+            lireTailwind(etat, contenu, relatif);
+        else if (/\.css$/i.test(entree))
+            lireCss(etat, contenu, relatif);
+        else if (/\.[jt]sx$/i.test(entree))
+            lireComposants(etat, contenu, relatif);
+        else if (/\.(scss|sass|less|styl)$/i.test(entree)) {
+            etat.unread.add(`${relatif} — préprocesseur non lu`);
+        }
+        else if (/\.(vue|svelte)$/i.test(entree)) {
+            etat.unread.add(`${relatif} — composant ${path.extname(entree).slice(1)} non lu`);
+        }
+    }
+}
+/**
+ * Inventorie un dépôt.
+ *
+ * `partial` est vrai dès qu'une seule chose n'a pas été comprise. C'est
+ * volontairement sévère : le comparateur s'en sert pour refuser de conclure à
+ * une absence, et il vaut mieux refuser une conclusion de trop qu'en produire
+ * une fausse.
+ */
+export function inventorierCode(racine) {
+    const etat = { items: [], unread: new Set(), fichiers: 0, plafond: false };
+    parcourir(etat, racine, racine);
+    /* Storybook n'est pas une troisième source : c'est un ATTRIBUT porté par les
+       composants du code. Documenté, ou pas. */
+    const stories = new Set(etat.items.filter((i) => i.kind === "story").map((i) => i.name.toLowerCase()));
+    for (const it of etat.items) {
+        if (it.kind !== "component")
+            continue;
+        it.attrs = { ...(it.attrs ?? {}), documented: stories.has(it.name.toLowerCase()) ? "true" : "false" };
+    }
+    const unread = [...etat.unread];
+    return {
+        source: "code",
+        items: etat.items.filter((i) => i.kind !== "story"),
+        partial: unread.length > 0,
+        covered: [...SAIT_LIRE],
+        unread,
+        at: undefined,
+    };
+}

package/dist/evals.js

@@ -42,8 +42,44 @@ export function getCase(caseId) {
     return null;
 }
 // ─── Scoring ─────────────────────────────────────────────────────────────────
+/**
+ * Les noms de champs, en deux langues — et pourquoi il faut les accepter.
+ *
+ * `issue-schema.md` décrit le schéma en FRANÇAIS : Sévérité, Localisation,
+ * Preuve, Correction. Un juge francophone qui le lit émet donc naturellement
+ * `severite` et `localisation`. Le banc, lui, ne lisait que les noms anglais.
+ *
+ * Ce que ça produisait, mesuré : un juge a rendu trois relais parfaits en
+ * sévérité `note` — et le banc, ne trouvant pas `severity`, les a comptés comme
+ * TROIS FAUX POSITIFS significatifs. La règle « sévérité inconnue = comptée
+ * comme significative » se retournait contre un juge irréprochable, et le
+ * corpus qu'il servait perdait aussi sa détection, faute de pouvoir lire ses
+ * résumés.
+ *
+ * Un instrument qui mesure autre chose que ce qu'il prétend est exactement ce
+ * que ce produit reproche aux autres. On normalise donc à la lecture, sans rien
+ * exiger du juge : les deux langues disent la même chose.
+ */
+const ALIAS = {
+    severite: "severity",
+    gravite: "severity",
+    localisation: "location",
+    categorie: "category",
+    resume: "summary",
+    constat: "summary",
+};
+function normaliser(f) {
+    const brut = f;
+    const out = { ...brut };
+    for (const [fr, en] of Object.entries(ALIAS)) {
+        if (out[en] === undefined && brut[fr] !== undefined)
+            out[en] = brut[fr];
+    }
+    return out;
+}
 function findingText(f) {
-    return [f.location, f.category, f.summary, f.correction].filter(Boolean).join(" ");
+    const n = normaliser(f);
+    return [n.location, n.category, n.summary, n.correction].filter(Boolean).join(" ");
 }
 /**
  * Le matcher n'habite plus ici.
@@ -56,7 +92,38 @@ function findingText(f) {
  * chiffres pour la même réalité.
  */
 function phraseMatched(phrase, findings) {
-    return findings.some((f) => matches(phrase, findingText(f)));
+    return findings.some((f) => !estRelais(f) && matches(phrase, findingText(f)));
+}
+/**
+ * LE RELAIS — ni violation, ni détection.
+ *
+ * Chaque SKILL.md impose une section « À passer à un autre skill : constat
+ * pressenti -> skill concerné, sans le développer ». Un juge qui refuse un
+ * défaut hors de son périmètre et le RELAIE fait exactement ce que son contrat
+ * exige.
+ *
+ * Le banc comptait ce relais comme une violation de périmètre, puisque la
+ * phrase relayée est justement celle que la golden interdit. Autrement dit : il
+ * punissait le bon comportement. Trente cas sur quarante échecs de la première
+ * passe indépendante venaient de là — et le cas le plus net,
+ * `a11y-out-of-scope-hierarchy`, était un juge irréprochable : il a refusé,
+ * relayé, et n'a rien développé.
+ *
+ * La définition reste ÉTROITE, à dessein. Deux conditions cumulatives :
+ *
+ *   1. sévérité `note` — un relais n'est pas une revendication ;
+ *   2. le texte NOMME explicitement un autre skill de la maison.
+ *
+ * Un constat de sévérité majeure ou au-delà sur le domaine d'un autre juge
+ * reste une violation : c'est du vrai débordement, et cette correction ne
+ * l'amnistie pas. `scripts/test-scoring.ts` fige les deux cas.
+ */
+const NOM_DE_SKILL = /\b(better|review|analyze)-[a-z]+(?:-[a-z]+)*\b/;
+export function estRelais(f) {
+    const severite = String(normaliser(f).severity ?? "").toLowerCase().trim();
+    if (severite !== "note")
+        return false;
+    return NOM_DE_SKILL.test(findingText(f));
 }
 /**
  * Un finding inventé ne compte comme FAUX POSITIF que s'il est SIGNIFICATIF :
@@ -66,7 +133,7 @@ function phraseMatched(phrase, findings) {
  * inconnue : traitée comme significative — le doute ne protège pas le skill.
  */
 function isSignificant(f) {
-    const s = f.severity;
+    const s = String(normaliser(f).severity ?? "").toLowerCase().trim();
     return s !== "mineur" && s !== "note";
 }
 export function scoreCase(c, cand, now) {
@@ -82,7 +149,7 @@ export function scoreCase(c, cand, now) {
     // le banc prouve. Aucun verdict attendu → la condition ne s'applique pas.
     const verdict_ok = !g.expected_verdict ? true : cand.verdict === g.expected_verdict;
     const scope_ok = forbidden_hits.length === 0;
-    const extras = cand.findings.filter((f) => !g.expected_findings.some((p) => matches(p, findingText(f))));
+    const extras = cand.findings.filter((f) => !estRelais(f) && !g.expected_findings.some((p) => matches(p, findingText(f))));
     const extra_findings = extras.length;
     const extra_significant = extras.filter(isSignificant).length;
     // Passe si : refus correct, périmètre respecté, verdict conforme quand il est