designwithai-mcp 0.4.0 → 0.6.0

package/dist/export-findings.js

@@ -0,0 +1,142 @@
+/**
+ * L'EXPORT DES CONSTATS — vers les outils que l'équipe emploie déjà.
+ *
+ * Trois verbes manquaient au produit : assigner, informer, tracer. Ils
+ * demandaient jusqu'ici trois intégrations, trois jeux de secrets à stocker et
+ * trois API à maintenir — pour un produit dont la promesse est de ne rien
+ * garder de ce qui ne lui appartient pas.
+ *
+ * LA SORTIE PAR LE HAUT : on n'écrit dans aucun outil. On produit un texte
+ * parfaitement formaté, et c'est l'assistant de l'utilisateur — chez lui, avec
+ * SES serveurs déjà branchés — qui le pose dans Jira, Linear ou Slack. Zéro
+ * secret stocké, zéro jeton à révoquer, zéro API à suivre quand elle change.
+ *
+ * DÉTERMINISTE, ET C'EST LA CONDITION. Aucun appel de modèle ici : le même
+ * audit rend exactement le même texte, à la virgule près. Un export qui varie
+ * d'une fois sur l'autre produirait deux tickets pour un seul défaut — et
+ * personne ne saurait lequel fermer.
+ */
+import { severityRank, worstSeverity, deriveVerdict, verdictLisible } from "./severity.js";
+/** Le seuil : ce qui mérite un ticket. Un mineur encombre une file, il ne la sert pas. */
+export const SEUIL_TICKET = 2; // majeur et au-dessus
+/**
+ * Ce qu'on lit en tête d'un constat.
+ *
+ * Les reviews d'avant n'ont pas de titre. Le repli le DIT au lieu d'afficher un
+ * vide — un ticket sans intitulé est un ticket que personne n'ouvre.
+ */
+export function titre(f) {
+    return (f.title || f.summary || "Constat sans intitulé — voir la preuve").trim();
+}
+const ordonner = (findings) => [...findings].sort((a, b) => severityRank(a.severity) - severityRank(b.severity));
+/** Ce qui reste ouvert. Un constat corrigé n'a rien à faire dans une file. */
+const ouverts = (findings) => findings.filter((f) => (f.status ?? "open") === "open");
+/**
+ * Le bloc des limites, en pied de chaque sortie.
+ *
+ * IL NE S'OMET JAMAIS QUAND IL Y A QUELQUE CHOSE À DIRE. Un ticket se lit par
+ * quelqu'un qui n'a pas vu l'analyse : sans le périmètre, il prend un constat
+ * partiel pour un constat complet, et l'absence d'un défaut pour sa correction.
+ */
+function blocLimites(review) {
+    const l = review.limites ?? [];
+    if (l.length === 0)
+        return "";
+    return (`\n\n---\nCe que cette lecture n'a pas couvert :\n` +
+        l.map((x) => `- ${x}`).join("\n") +
+        `\nUn constat absent d'ici ne prouve donc pas qu'il n'existe pas.`);
+}
+/** Le renvoi vers l'analyse. Un ticket sans retour est un ticket orphelin. */
+function retour(review) {
+    return `designwithai · ${review.skill} · ${review.artifact_ref} · analyse ${review.id}`;
+}
+/**
+ * Le format « tickets » — un bloc par constat, prêt à devenir une issue.
+ *
+ * Chaque bloc porte les quatre choses qu'une issue exige et qu'on oublie
+ * toujours : ce qui cloche en langage courant, la preuve qui permet de le
+ * retrouver, la correction proposée, et le critère qui dira que c'est fini.
+ * Sans le dernier, un ticket se ferme sur une impression.
+ */
+export function enTickets(review) {
+    const retenus = ordonner(ouverts(review.findings)).filter((f) => severityRank(f.severity) <= SEUIL_TICKET);
+    if (retenus.length === 0) {
+        return (`Aucun constat de gravité majeure ou plus sur ${review.artifact_ref}.\n\n` +
+            `Rien à mettre en file. Les constats mineurs et les notes restent dans l'analyse — ` +
+            `les sortir ici encombrerait la file de ton équipe sans la servir.` +
+            blocLimites(review));
+    }
+    const blocs = retenus.map((f, i) => {
+        const lignes = [
+            `## ${i + 1}. ${titre(f)}`,
+            "",
+            `**Gravité** : ${f.severity ?? "non précisée"}${f.location ? ` · **Où** : ${f.location}` : ""}`,
+        ];
+        if (f.evidence)
+            lignes.push("", `**Ce qui le prouve**`, f.evidence);
+        if (f.impact)
+            lignes.push("", `**Pourquoi ça compte**`, f.impact);
+        if (f.correction)
+            lignes.push("", `**Correction proposée**`, f.correction);
+        lignes.push("", `**C'est fait quand** : ${f.acceptance ?? "à définir avec l'équipe — l'analyse n'a pas fourni de critère de fin"}`);
+        if (f.confidence && f.confidence !== "élevée") {
+            lignes.push("", `_Confiance ${f.confidence} : à vérifier avant d'engager du travail._`);
+        }
+        lignes.push("", `_${retour(review)}_`);
+        return lignes.join("\n");
+    });
+    const entete = `${retenus.length} ticket${retenus.length > 1 ? "s" : ""} à créer — ${review.artifact_ref}\n` +
+        `Un bloc par constat. Les mineurs et les notes ne sont pas ici : ils encombreraient la file.`;
+    return `${entete}\n\n${blocs.join("\n\n---\n\n")}${blocLimites(review)}`;
+}
+/**
+ * Le format « message » — ce qu'on poste dans un canal, tel quel.
+ *
+ * Il tient en quelques lignes parce qu'un message d'équipe se lit en passant.
+ * Le verdict traduit d'abord — personne ne doit traduire « PASS WITH FIXES » —
+ * puis ce qui a bougé, puis les trois points les plus graves. Pas dix : trois.
+ */
+export function enMessage(review, mouvement) {
+    const ouvertsTries = ordonner(ouverts(review.findings));
+    const lisible = verdictLisible(review.verdict) ?? verdictLisible(deriveVerdict(ouvertsTries)) ?? "Analysé";
+    const lignes = [`**${review.artifact_ref} — ${lisible.toLowerCase()}**`];
+    if (mouvement) {
+        /* Le mouvement se dit en clair, et « rien n'a bougé » est un résultat.
+           Annoncer un progrès qui n'a pas eu lieu est la faute qu'on a mis un
+           chantier entier à retirer du rapport ; elle ne rentrera pas par ici. */
+        const parts = [];
+        if (mouvement.regles > 0)
+            parts.push(`${mouvement.regles} réglé${mouvement.regles > 1 ? "s" : ""}`);
+        if (mouvement.nouveaux > 0)
+            parts.push(`${mouvement.nouveaux} nouveau${mouvement.nouveaux > 1 ? "x" : ""}`);
+        if (mouvement.restants > 0)
+            parts.push(`${mouvement.restants} encore ouvert${mouvement.restants > 1 ? "s" : ""}`);
+        lignes.push(parts.length > 0 ? `Depuis la dernière fois : ${parts.join(" · ")}.` : "Rien n'a bougé depuis la dernière fois.");
+    }
+    if (ouvertsTries.length === 0) {
+        lignes.push("", "Rien d'ouvert à signaler.");
+    }
+    else {
+        lignes.push("", `Les ${Math.min(3, ouvertsTries.length)} plus graves :`);
+        for (const f of ouvertsTries.slice(0, 3)) {
+            lignes.push(`• ${titre(f)}${f.location ? ` — ${f.location}` : ""} _(${f.severity ?? "?"})_`);
+        }
+        if (ouvertsTries.length > 3) {
+            lignes.push(`_et ${ouvertsTries.length - 3} autre${ouvertsTries.length - 3 > 1 ? "s" : ""}, dans l'analyse complète._`);
+        }
+    }
+    lignes.push("", `_${retour(review)}_`);
+    return lignes.join("\n") + blocLimites(review);
+}
+/** Le compte de ce qui partirait, pour le dire avant d'exporter. */
+export function compter(review) {
+    const o = ouverts(review.findings);
+    return {
+        total: review.findings.length,
+        exportables: o.filter((f) => severityRank(f.severity) <= SEUIL_TICKET).length,
+        pire: worstSeverity(o),
+    };
+}
+export function exporter(review, format, mouvement) {
+    return format === "tickets" ? enTickets(review) : enMessage(review, mouvement);
+}

package/dist/server.js

@@ -18,6 +18,8 @@ import { compareReviews, getReview, listReviews, saveReview, updateFindingStatus
 import { saveDecision } from "./decisions.js";
 import { clearGate, loadState, reopenGate, saveState } from "./state.js";
 import { readRepoSnapshot } from "./connectors.js";
+import { SEVERITES } from "./severity.js";
+import { compter, exporter } from "./export-findings.js";
 import { inventorierCode } from "./ds-inventory.js";
 import { buildPayload, rendreEnvoi, rendreInventaire } from "./inventory-tool.js";
 import { trySemanticScores } from "./embeddings.js";
@@ -196,7 +198,7 @@ const TOOLS = [
                     items: {
                         type: "object",
                         properties: {
-                            severity: { type: "string", enum: ["bloquant", "critique", "majeur", "mineur", "note"] },
+                            severity: { type: "string", enum: [...SEVERITES] },
                             location: { type: "string" },
                             category: { type: "string" },
                             summary: { type: "string" },
@@ -443,6 +445,42 @@ const TOOLS = [
             },
         },
     },
+    {
+        name: "export_findings",
+        description: "Transforme les constats d'une review en TICKETS prêts à créer, ou en MESSAGE prêt à " +
+            "poster. Rien n'est envoyé nulle part : tu reçois un texte, et c'est TOI qui le poses " +
+            "dans Jira, Linear, GitHub ou Slack avec les serveurs que l'utilisateur a déjà branchés. " +
+            "Déterministe — le même audit rend le même texte.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                format: {
+                    type: "string",
+                    enum: ["tickets", "message"],
+                    description: "tickets = un bloc par constat majeur ou plus, avec preuve, correction et critère " +
+                        "de fin. message = le verdict, ce qui a bougé, et les trois plus graves.",
+                },
+                review_id: { type: "string", description: "La review à exporter. Par défaut, la dernière." },
+                regles: { type: "number", description: "Constats réglés depuis la fois d'avant, si tu le sais." },
+                nouveaux: { type: "number", description: "Constats apparus depuis." },
+            },
+            required: ["format"],
+        },
+    },
+    {
+        name: "framing_criteria",
+        description: "Charge les CRITÈRES D'ACCEPTATION d'un cadrage écrit avant de construire, pour vérifier " +
+            "la feature contre eux — un par un, avec verify_fix. C'est la seule façon de vérifier " +
+            "contre des critères posés AVANT : reconstruits de mémoire, ils se moulent sur le " +
+            "résultat obtenu.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                product_ref: { type: "string", description: "Le produit, pour ne lister que ses cadrages." },
+                id: { type: "string", description: "Un cadrage précis, si tu le connais déjà." },
+            },
+        },
+    },
     {
         name: "inventory_ds",
         description: "Inventorie le DESIGN SYSTEM d'un dépôt local — valeurs de style, composants, et lesquels " +
@@ -630,7 +668,7 @@ function toolPlan(args) {
 }
 // ─── Reviews suivies (étape C) ───────────────────────────────────────────────
 function sevCounts(findings) {
-    const order = ["bloquant", "critique", "majeur", "mineur", "note"];
+    const order = SEVERITES;
     const c = {};
     for (const f of findings) {
         const s = f.severity ?? "note";
@@ -692,6 +730,8 @@ function toolListReviews(args) {
 const DEFAULT_INGEST_URL = "https://hbugvurcdmimhvvfdlos.supabase.co/functions/v1/ingest-audit";
 /** Même compte, même jeton, autre table : les inventaires ont leur point d'entrée. */
 const DEFAULT_INVENTORY_URL = "https://hbugvurcdmimhvvfdlos.supabase.co/functions/v1/ingest-inventory";
+/** La lecture des cadrages. Le seul point d'entrée en LECTURE de tout le MCP. */
+const DEFAULT_FRAMING_URL = "https://hbugvurcdmimhvvfdlos.supabase.co/functions/v1/read-framing";
 async function toolPushAudit(args) {
     const token = process.env.DWAI_TOKEN?.trim();
     const url = process.env.DWAI_INGEST_URL?.trim() || DEFAULT_INGEST_URL;
@@ -1022,6 +1062,121 @@ function toolNextGate(args) {
  * lecture : la personne a quand même le droit de savoir ce que son dépôt
  * contient, et ce qu'on n'a pas su y lire.
  */
+/**
+ * `framing_criteria` — la boucle se referme ici.
+ *
+ * Les critères ont été écrits AVANT de construire, et c'est toute leur valeur.
+ * Les relire au moment de vérifier, plutôt que de les reformuler de mémoire,
+ * est la différence entre une vérification et une relecture complaisante : des
+ * critères reconstruits après coup se moulent sur le résultat obtenu.
+ *
+ * L'outil ne juge rien. Il rend les critères, dans leur forme structurée, et
+ * dit explicitement quoi en faire — c'est `verify_fix` qui statue, un critère à
+ * la fois, avec sa preuve.
+ */
+/**
+ * `export_findings` — les trois verbes, sans une seule intégration.
+ *
+ * Assigner, informer, tracer manquaient au produit. Les câbler aurait demandé
+ * trois API, trois jeux de secrets et leur maintenance — pour un produit dont
+ * la promesse est de ne rien garder qui ne lui appartienne pas.
+ *
+ * On sort par le haut : le texte est produit ici, parfaitement formaté, et
+ * c'est l'assistant de l'utilisateur qui le pose dans SES outils, avec SES
+ * serveurs déjà branchés. Aucun secret ne transite, aucune API à suivre quand
+ * elle change.
+ */
+function toolExportFindings(args) {
+    const format = String(args.format ?? "");
+    if (format !== "tickets" && format !== "message") {
+        return refusal("export_findings attend un format : « tickets » ou « message ».");
+    }
+    const review = args.review_id ? getReview(String(args.review_id)) : (listReviews()[0] ?? null);
+    if (!review) {
+        return refusal("Aucune review à exporter. Lance d'abord un skill et enregistre le résultat avec save_review.");
+    }
+    const compte = compter(review);
+    /* Le mouvement n'est employé QUE si l'appelant le connaît. On ne le déduit
+       pas d'une comparaison de photos : c'est exactement ce qui avait produit un
+       « ton produit monte » sur un site que personne n'avait touché. */
+    const mouvement = typeof args.regles === "number" || typeof args.nouveaux === "number"
+        ? {
+            regles: Number(args.regles ?? 0),
+            nouveaux: Number(args.nouveaux ?? 0),
+            restants: review.findings.filter((f) => (f.status ?? "open") === "open").length,
+        }
+        : undefined;
+    const corps = exporter(review, format, mouvement);
+    const entete = format === "tickets"
+        ? `${compte.exportables} constat(s) exportable(s) sur ${compte.total} — les mineurs et les notes restent dans l'analyse.\n` +
+            `CE QUE TU EN FAIS : crée une issue par bloc, avec les serveurs que l'utilisateur a déjà branchés ` +
+            `(Jira, Linear, GitHub). Ne réécris pas les titres : ils sont déjà écrits pour être lus par quelqu'un ` +
+            `qui n'a pas vu l'analyse. Si aucun serveur n'est branché, rends-lui le texte tel quel.`
+        : `CE QUE TU EN FAIS : poste ce message tel quel dans le canal qu'il te dira (Slack, Teams). ` +
+            `Ne l'allonge pas : il est court parce qu'un message d'équipe se lit en passant.`;
+    return text(`${entete}\n\n${corps}`);
+}
+async function toolFramingCriteria(args) {
+    const token = process.env.DWAI_TOKEN?.trim();
+    if (!token) {
+        return refusal("framing_criteria a besoin de DWAI_TOKEN dans l'environnement du serveur MCP. " +
+            "Génère un jeton dans ton compte (page Compte → « Connecter mon éditeur »).");
+    }
+    const url = process.env.DWAI_FRAMING_URL?.trim() || DEFAULT_FRAMING_URL;
+    let body;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                token,
+                product_ref: args.product_ref ? String(args.product_ref) : undefined,
+                id: args.id ? String(args.id) : undefined,
+            }),
+        });
+        body = (await res.json().catch(() => ({})));
+        if (!res.ok) {
+            return refusal(res.status === 401
+                ? "Le jeton est inconnu ou révoqué : regénères-en un depuis ton compte."
+                : `La lecture a été refusée (${res.status} ${String(body.error ?? "")}).`);
+        }
+    }
+    catch (e) {
+        return refusal(`Impossible de joindre ${url} : ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const cadrages = (Array.isArray(body.framings) ? body.framings : []);
+    if (cadrages.length === 0) {
+        return text("Aucun cadrage enregistré pour ce produit.\n\n" +
+            "Les critères d'acceptation s'écrivent AVANT de construire, sur le site — sans eux, " +
+            "il n'y a rien contre quoi vérifier, et une vérification faite de mémoire se moule " +
+            "sur ce qu'on a construit.");
+    }
+    const lignes = [];
+    for (const c of cadrages) {
+        const criteres = c.criteria ?? [];
+        lignes.push(`CADRAGE « ${c.feature ?? "sans nom"} » — ${c.id ?? "?"}`);
+        if (c.essai)
+            lignes.push(`  Ce qui a été tenté : ${c.essai}`);
+        if (c.verdict)
+            lignes.push(`  Verdict du cadrage : ${c.verdict}`);
+        if (criteres.length === 0) {
+            lignes.push("  (aucun critère structuré — rien à vérifier contre)");
+        }
+        else {
+            lignes.push(`  Critères d'acceptation (${criteres.length}) :`);
+            for (const k of criteres) {
+                lignes.push(`    - ${k.quoi ?? "?"} : de ${k.de ?? "?"} à ${k.a ?? "?"}, d'ici ${k.avant ?? "?"}` +
+                    (k.mesure ? ` — mesuré par ${k.mesure}` : " — AUCUNE MESURE INDIQUÉE au cadrage"));
+            }
+        }
+        lignes.push("");
+    }
+    lignes.push("CE QUE TU EN FAIS : appelle verify_fix avec ces critères, UN PAR UN, et une preuve " +
+        "par critère prise dans l'état COURANT du produit. Un critère sans mesure indiquée " +
+        "reste vérifiable — mais dis d'où vient ton chiffre, sinon la vérification vaut ce " +
+        "que vaut une impression.");
+    return text(lignes.join("\n"));
+}
 async function toolInventoryDs(args) {
     const racine = String(args.path ?? "").trim();
     const productRef = String(args.product_ref ?? "").trim();
@@ -1166,6 +1321,10 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
             return toolGenerateDecision(args);
         case "next_gate":
             return toolNextGate(args);
+        case "export_findings":
+            return toolExportFindings(args);
+        case "framing_criteria":
+            return toolFramingCriteria(args);
         case "inventory_ds":
             return toolInventoryDs(args);
         case "connect_repo":

package/dist/severity.js

@@ -0,0 +1,71 @@
+/**
+ * LA SÉVÉRITÉ ET LE VERDICT, CÔTÉ MCP.
+ *
+ * La définition de référence vit dans `supabase/functions/_shared/severity.ts` :
+ * c'est elle que le serveur applique et que le site affiche. Ce paquet-ci ne
+ * peut pas l'importer — il est publié seul sur npm, et un import qui remonte
+ * hors de son dossier ne survivrait pas à l'emballage. C'est la même frontière
+ * que celle de l'inventaire Figma, et elle se paie une fois.
+ *
+ * Ce fichier est donc une RÉÉCRITURE, pas une copie de confort. Et
+ * `scripts/test-severite-frontiere.ts` empêche les deux de diverger : il
+ * compare les deux tables terme à terme, depuis le site qui peut lire les deux.
+ *
+ * CE QU'IL REMPLACE. La même échelle était écrite à trois endroits du paquet —
+ * le type dans `reviews.ts`, l'énumération du schéma d'outil, et un tableau
+ * d'ordre au milieu du serveur. Trois copies qui n'avaient aucun moyen de se
+ * contredire bruyamment.
+ */
+/** Du plus grave au moins grave. L'ordre EST la définition. */
+export const SEVERITES = ["bloquant", "critique", "majeur", "mineur", "note"];
+const RANK = Object.fromEntries(SEVERITES.map((s, i) => [s, i]));
+/** Une sévérité inconnue passe en dernier — jamais devant un défaut réel. */
+export function severityRank(s) {
+    return RANK[(s ?? "").toLowerCase().trim()] ?? 9;
+}
+/** La plus grave d'un lot, ou `null` s'il n'y a rien. */
+export function worstSeverity(findings) {
+    let pire = null;
+    for (const f of findings) {
+        const s = (f.severity ?? "").toLowerCase().trim();
+        if (!RANK[s])
+            if (RANK[s] !== 0)
+                continue;
+        if (pire === null || severityRank(s) < severityRank(pire))
+            pire = s;
+    }
+    return pire;
+}
+/**
+ * Le verdict se DÉDUIT des sévérités, il ne se décide pas.
+ *
+ * Un bloquant, ou deux critiques, et c'est un échec. Un critique isolé ou un
+ * majeur laissent passer avec des corrections. La règle est celle du serveur,
+ * terme à terme.
+ */
+export function deriveVerdict(findings) {
+    const compte = (s) => findings.filter((f) => (f.severity ?? "").toLowerCase().trim() === s).length;
+    if (compte("bloquant") > 0)
+        return "FAIL";
+    if (compte("critique") >= 2)
+        return "FAIL";
+    if (compte("critique") === 1 || compte("majeur") > 0)
+        return "PASS WITH FIXES";
+    return "PASS";
+}
+/**
+ * LES VERDICTS, DITS EN FRANÇAIS.
+ *
+ * `PASS`, `FAIL`, `BLOCKED` sont du vocabulaire de fabrication. Ils n'ont rien à
+ * faire dans un ticket que lira quelqu'un qui n'a jamais ouvert ce produit.
+ */
+export const VERDICT_LISIBLE = {
+    PASS: "Ça tient",
+    "PASS WITH FIXES": "Presque prêt — des choses à corriger",
+    FAIL: "À corriger avant d'ouvrir",
+    BLOCKED: "Pas assez d'infos pour juger",
+};
+export function verdictLisible(v) {
+    const cle = String(v ?? "").trim().toUpperCase();
+    return VERDICT_LISIBLE[cle] ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "designwithai-mcp",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "license": "UNLICENSED",
   "description": "Le serveur designwithai pour ton éditeur : audite ton produit — interface, navigation, performance, sécurité des données, hygiène Figma — trace les corrections, et fait remonter les résultats dans ton tableau de bord.",
@@ -26,7 +26,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "tsx scripts/test-finding-identity.ts && tsx scripts/test-scoring.ts && tsx scripts/test-ds-diff.ts && tsx scripts/test-ds-match.ts && tsx scripts/test-ds-corpus.ts && tsx scripts/test-ds-inventory.ts && tsx scripts/test-inventory-tool.ts && tsx scripts/check-goldens.ts",
+    "test": "tsx scripts/test-finding-identity.ts && tsx scripts/test-scoring.ts && tsx scripts/test-ds-diff.ts && tsx scripts/test-ds-match.ts && tsx scripts/test-ds-corpus.ts && tsx scripts/test-export-findings.ts && tsx scripts/test-ds-inventory.ts && tsx scripts/test-inventory-tool.ts && tsx scripts/check-goldens.ts",
     "start": "node dist/server.js",
     "dev": "tsx src/server.ts",
     "embed": "node scripts/embed.mjs",

package/skills/better-consistency/SKILL.md

@@ -39,6 +39,17 @@ Produit construit rapidement, plusieurs contributeurs, routes hétérogènes, mi
 | **Données** | Formats de date, nombre, devise, unités, labels et ordre de colonnes. |
 | **Accessibilité** | Focus, labels, noms accessibles et clavier variables selon les implémentations. |
 
+## La frontière avec `better-writing`
+
+Les deux juges regardent des mots, et la confusion serait facile.
+
+- **Ici, les TERMES et les COMPOSANTS** : le même objet nommé « projet » ici et « espace » là, deux boutons pour la même action, deux formats de date. Une question d'identité — deux choses désignées de deux façons.
+- **Là-bas, le TON et la VOIX** : comment le produit s'adresse aux gens, sur quel registre, avec quelle chaleur dans l'échec. Une question de manière — la même chose dite de deux façons.
+
+Un même écran peut relever des deux, et ce n'est pas un chevauchement. Le test qui tranche : qu'est-ce qui changerait en corrigeant ? Un mot remplacé partout, c'est ici. Une phrase réécrite, c'est là-bas.
+
+**Ce qui n'est PAS de ce skill** : le tutoiement qui devient vouvoiement, un message d'erreur qui culpabilise, un registre qui glisse d'un écran à l'autre. Ces constats appartiennent à `better-writing`, qui les juge contre la charte de voix déclarée par le produit — une charte que ce skill-ci n'a pas à lire.
+
 ## Séquence d'analyse obligatoire
 
 1. **Définir l'échantillon.** Routes, écrans, composants, périodes et plateformes comparés.

package/skills/better-interface/SKILL.md

@@ -133,6 +133,9 @@ Lot 4 - Polish et prévention
 - Axes non vérifiés, nommés
 ```
 
+
+Ces constats s'exportent en tickets ou en message d'équipe — `export_findings`. Rien n'est envoyé nulle part : l'outil rend un texte, et c'est l'assistant de la personne qui le pose dans SES outils, avec SES accès.
+
 ## Critères de qualité du skill
 
 - Les skills activés sont justifiés par le contenu de l'artefact.

package/skills/better-writing/SKILL.md

@@ -60,6 +60,66 @@ Labels, CTA, onboarding, empty states, erreurs, notifications, formulaires ou te
 - **Utiliser le même terme pour la même chose.** Créer un mini-glossaire lorsque plusieurs écrans divergent.
 - **Ne pas cacher les conséquences.** Les actions irréversibles, paiements, permissions et publications doivent être explicites.
 
+## La voix du produit — la dimension qui ne s'active pas toute seule
+
+Cette grille juge la copie contre des règles générales : clarté, erreurs utiles, terminologie. Elle gagne ici une seconde dimension, qui juge la copie contre **la voix propre du produit** — et celle-ci ne s'exprime qu'à une condition, non négociable.
+
+> **Pas de charte confirmée, pas de jugement de voix.**
+
+La charte vit sur la fiche du produit. Elle porte six choses : le tutoiement ou le vouvoiement, le registre, les mots maison, les mots bannis, la façon de dire les erreurs, et les emojis.
+
+**Quand elle est absente**, la grille générique s'applique seule et le rapport le dit, une fois, sans insister : *« Déclare ta voix sur ta fiche, et je vérifierai que tes écrans la tiennent. »* Aucun constat de voix, aucune insinuation. Une voix qu'on n'a pas déclarée n'est pas une voix qu'on tient mal.
+
+**Quand elle est seulement PROPOSÉE** — déduite d'un échantillon d'écrans, pas encore confirmée — elle ne juge rien non plus. Une proposition se montre, elle ne s'applique pas.
+
+### LE GARDE-FOU, et c'est celui qui compte le plus ici
+
+> **La charte est celle de l'utilisateur, jamais la tienne.**
+
+Un produit qui choisit le vouvoiement, un registre corporate et des emojis partout **a le droit**. Tu vérifies la TENUE, pas le goût. Un constat qui reprocherait le vouvoiement à un produit dont la charte dit « vous » n'est pas un constat sévère : c'est un contresens, et c'est la faute la plus grave possible sur cette dimension.
+
+Corollaire : tu ne proposes jamais de changer la charte. Si elle te paraît étrange, elle appartient quand même à quelqu'un qui l'a écrite.
+
+### Ce qu'un constat de voix doit porter
+
+Deux choses ensemble, sans quoi il ne s'écrit pas : **la règle de la charte violée**, et **la phrase exacte** qui la viole, avec sa localisation.
+
+| Règle violée | Constat |
+|---|---|
+| Adresse | « Ta charte tutoie ; cet écran vouvoie — *"Veuillez réessayer"*, écran de connexion. » |
+| Mots bannis | « *"Utilisateur"* est dans tes mots bannis ; il apparaît 3 fois — page Compte, page Équipe, message d'erreur du formulaire. » |
+| Mots maison | « Tu appelles ça un *dossier* ; cet écran dit *"projet"* — tableau de bord, en-tête. » |
+| Ton des erreurs | « Ta charte dit rassurer ; ce message culpabilise — *"Vous avez fait une erreur"*, formulaire d'inscription. » |
+| Emojis | « Ta charte les exclut ; il y en a deux — bandeau de bienvenue. » |
+
+Une occurrence sans localisation n'est pas citable, donc pas un constat. Un compte sans les endroits qui le produisent non plus.
+
+### La cohérence de voix, même sans règle violée
+
+Deux registres qui coexistent dans un même produit sont un constat **même si la charte n'interdit ni l'un ni l'autre**. Un accueil chaleureux et des messages d'erreur techniques ne se contredisent pas ligne à ligne : ils se contredisent d'un écran à l'autre, et c'est ce que personne ne voit en relisant un écran à la fois.
+
+Ce constat cite au moins **deux endroits**, un de chaque registre. Sans les deux, il n'y a rien à comparer.
+
+### LA FRONTIÈRE AVEC `better-consistency`, à ne pas franchir
+
+Les deux juges regardent des mots, et c'est là que la confusion serait facile.
+
+- **`better-consistency` juge les TERMES et les COMPOSANTS** : le même objet nommé « projet » ici et « espace » là, deux boutons pour la même action, deux formats de date. C'est une question d'identité — deux choses désignées de deux façons.
+- **`better-writing` juge le TON et la VOIX** : comment on s'adresse, sur quel registre, avec quelle chaleur dans l'échec. C'est une question de manière — la même chose dite de deux façons.
+
+Un même écran peut relever des deux, et ce n'est pas un chevauchement : « projet » vs « espace » est un problème de terme ; « Veuillez patienter » vs « Une seconde ! » est un problème de ton. Si tu hésites, demande-toi ce qui changerait en corrigeant : un mot remplacé partout, ou une phrase réécrite.
+
+### Sévérité sur cette dimension
+
+| Sévérité | Sur la voix |
+|---|---|
+| **Critique** | La voix se contredit sur le parcours principal — accueil et paiement ne parlent pas au même public. Un mot banni apparaît dans un message que tout le monde voit. |
+| **Majeur** | L'adresse change d'un écran à l'autre. Le ton des erreurs contredit la charte là où l'échec est fréquent. Un mot maison remplacé par un synonyme dans un écran central. |
+| **Mineur** | Une violation isolée sur un écran secondaire — mentions légales, page d'aide rarement ouverte. |
+| **Note** | Une formulation qui tient la charte mais s'en éloigne, sans que rien ne soit faux. |
+
+La règle de la dernière hésitation s'applique : entre deux niveaux, prends le plus bas et écris l'hésitation dans la confiance.
+
 ## Patrons de microcopy
 
 | Situation | Structure recommandée | À éviter |

package/skills/better-writing/evals/cases.json

@@ -87,5 +87,120 @@
       "should_refuse": true,
       "note": "Sans emplacement ni action attendue, réécrire est deviner. Le skill doit demander le contexte d'affichage."
     }
+  },
+  {
+    "id": "writing-conformant-voix-corporate-tenue",
+    "skill": "better-writing",
+    "kind": "conformant",
+    "delivery_mode": "classique",
+    "artifact": "CHARTE DE VOIX DÉCLARÉE PAR LE PRODUIT (confirmée sur la fiche)\n- Adresse : le produit dit « vous ». Toute phrase qui emploie l'autre forme est une violation.\n- Registre : technique — on nomme les choses précisément. Un écran qui bascule dans un autre registre est une violation, même si la phrase est bonne.\n- Messages d'erreur : on dit ce qui s'est passé, puis la suite, sans détour. Un message qui culpabilise est une violation dans les deux cas.\n- Emojis : autorisés.\n- Mots maison — c'est ainsi que CE produit nomme ses objets : dossier, collaborateur, mandat. Employer un synonyme à la place est une violation.\n- Mots bannis, jamais à l'écran : utilisateur, plateforme. Chaque occurrence est une violation, avec sa localisation.\n\nÉCRANS RELEVÉS (lecture complète du HTML servi, 6 pages)\n\n/connexion\n  Titre : « Accès à votre espace de travail »\n  Champ : « Adresse e-mail professionnelle »\n  Bouton : « Se connecter »\n  Erreur : « Ce mot de passe ne correspond pas à cette adresse. Réinitialisez-le ou contactez votre administrateur. »\n\n/dossiers\n  Titre : « Vos dossiers »\n  Vide : « Aucun dossier pour le moment. Créez-en un pour commencer à travailler. »\n  Bouton : « Nouveau dossier »\n\n/dossiers/equipe\n  Titre : « Collaborateurs du dossier »\n  Sous-titre : « Les personnes autorisées à consulter et modifier ce dossier. »\n  Bouton : « Inviter un collaborateur »\n\n/mandats\n  Titre : « Mandats en cours »\n  Colonne : « Échéance » · « Responsable » · « Statut »\n  Vide : « Aucun mandat actif. Les mandats clôturés restent consultables dans les archives. »\n\n/facturation\n  Titre : « Facturation du dossier »\n  Erreur : « Le paiement a été refusé par votre banque. Vérifiez les informations de votre carte, puis réessayez. »\n\n/aide\n  Titre : « Centre d'aide »\n  Texte : « Consultez la documentation ou écrivez à notre équipe support. » 📄",
+    "golden": {
+      "expected_findings": [],
+      "forbidden_findings": [
+        "le vouvoiement met de la distance avec la personne qui lit",
+        "conseiller de tutoyer pour un ton plus proche et plus moderne",
+        "le registre technique rend les écrans froids et peu accueillants",
+        "un emoji dans le centre d'aide détonne avec le reste du produit",
+        "les messages d'erreur manquent de chaleur et de réassurance"
+      ],
+      "expected_verdict": "PASS",
+      "should_refuse": false,
+      "note": "LE PIÈGE DU GOÛT, et c'est le cas le plus important de cette extension. Le produit a déclaré une voix corporate — vouvoiement, registre technique, erreurs directes, emojis autorisés — et il la tient partout : six écrans, aucune adresse qui glisse, aucun mot banni, les trois mots maison employés exactement là où ils doivent l'être. L'emoji du centre d'aide est AUTORISÉ par la charte. Un juge qui préférerait le tutoiement et le ferait savoir commettrait un contresens, pas une sévérité : il remplacerait le projet de quelqu'un par le sien. Les cinq interdits sont exactement les cinq façons de céder à ce réflexe. La bonne réponse est PASS et le silence."
+    }
+  },
+  {
+    "id": "writing-obvious-voix-adresse-qui-glisse",
+    "skill": "better-writing",
+    "kind": "obvious-defect",
+    "delivery_mode": "ai-builder",
+    "artifact": "CHARTE DE VOIX DÉCLARÉE PAR LE PRODUIT (confirmée sur la fiche)\n- Adresse : le produit dit « tu ». Toute phrase qui emploie l'autre forme est une violation.\n- Registre : chaleureux — on est à côté de la personne. Un écran qui bascule dans un autre registre est une violation, même si la phrase est bonne.\n- Messages d'erreur : on rassure avant de dire quoi faire. Un message qui culpabilise est une violation dans les deux cas.\n- Emojis : jamais.\n- Mots maison : carnet, note.\n- Mots bannis, jamais à l'écran : utilisateur, contenu.\n\nÉCRANS RELEVÉS (lecture complète du HTML servi, 5 pages)\n\n/accueil\n  Titre : « Bienvenue dans ton carnet »\n  Texte : « Retrouve ici toutes tes notes, où que tu sois. »\n  Bouton : « Ouvrir mon carnet »\n\n/notes/nouvelle\n  Titre : « Veuillez saisir le titre de votre note »\n  Champ : « Titre »\n  Aide : « Vous pourrez le modifier ultérieurement. »\n  Bouton : « Enregistrer »\n\n/parametres\n  Titre : « Vos préférences »\n  Texte : « Veuillez sélectionner la langue d'affichage de votre interface. »\n  Bouton : « Valider »\n\n/partage\n  Titre : « Partager ta note »\n  Texte : « Choisis avec qui tu partages ce contenu. »\n  Bouton : « Créer le lien »\n\n/erreur-500\n  Titre : « Une erreur est survenue »\n  Texte : « Vous avez effectué une action non autorisée. Veuillez réessayer plus tard. »",
+    "golden": {
+      "expected_findings": [
+        "la charte tutoie mais trois écrans vouvoient",
+        "l'écran de nouvelle note dit vous alors que l'accueil dit tu",
+        "les préférences vouvoient d'un bout à l'autre",
+        "le message d'erreur vouvoie et rejette la faute sur la personne",
+        "le mot contenu est banni par la charte et apparaît sur l'écran de partage"
+      ],
+      "forbidden_findings": [
+        "conseiller de choisir le vouvoiement pour l'ensemble du produit",
+        "le tutoiement n'est pas adapté à un produit professionnel",
+        "les titres des écrans ne suivent pas la même hiérarchie visuelle",
+        "revoir la mise en page des écrans de paramètres",
+        "le terme note est employé de deux façons différentes"
+      ],
+      "expected_verdict": "FAIL",
+      "should_refuse": false,
+      "note": "La violation la plus visible, et la plus fréquente en pratique : un produit généré où la moitié des écrans a gardé le vouvoiement par défaut. Trois écrans sur cinq, dont un message d'erreur qui cumule deux violations — le vouvoiement ET la culpabilisation, que la charte refuse dans les deux tons. « contenu » est dans les mots bannis. Les interdits couvrent le contresens du goût (conseiller l'inverse de la charte), l'avis sur le choix lui-même, et deux dérives hors axe — la mise en page, et un constat de TERME qui appartient à better-consistency."
+    }
+  },
+  {
+    "id": "writing-subtle-voix-qui-lache-sous-stress",
+    "skill": "better-writing",
+    "kind": "subtle-defect",
+    "delivery_mode": "hybride",
+    "artifact": "CHARTE DE VOIX DÉCLARÉE PAR LE PRODUIT (confirmée sur la fiche)\n- Adresse : le produit dit « tu ». Toute phrase qui emploie l'autre forme est une violation.\n- Registre : chaleureux — on est à côté de la personne. Un écran qui bascule dans un autre registre est une violation, même si la phrase est bonne.\n- Messages d'erreur : on rassure avant de dire quoi faire. Un message qui culpabilise est une violation dans les deux cas.\n- Emojis : jamais.\n- Mots maison : carnet, note.\n- Mots bannis, jamais à l'écran : utilisateur, contenu.\n\nÉCRANS RELEVÉS (lecture complète du HTML servi, 7 pages)\n\n/accueil\n  Titre : « Ton carnet t'attend »\n  Texte : « Reprends là où tu t'es arrêté. »\n\n/notes\n  Titre : « Tes notes »\n  Vide : « Rien ici pour l'instant. Crée ta première note, ça prend dix secondes. »\n\n/notes/nouvelle\n  Titre : « Nouvelle note »\n  Aide : « Donne-lui un titre, tu pourras le changer après. »\n\n/partage\n  Titre : « Partage ta note »\n  Texte : « Choisis qui peut la lire. Tu peux retirer l'accès quand tu veux. »\n\n/parametres\n  Titre : « Tes préférences »\n  Texte : « Choisis ta langue et le thème qui te va. »\n\nMESSAGES D'ERREUR (relevés dans le même HTML)\n  Formulaire de note : « Échec de la validation du formulaire : le champ titre est requis. »\n  Import : « Erreur 422 — le fichier fourni ne satisfait pas au format attendu. »\n  Partage : « Opération impossible : quota de liens de partage atteint pour la période courante. »\n  Connexion : « Authentification échouée. »",
+    "golden": {
+      "expected_findings": [
+        "la voix tient partout sauf dans les messages d'erreur",
+        "les messages d'échec basculent dans un registre technique que la charte n'emploie nulle part ailleurs",
+        "aucun message d'erreur ne rassure ni ne dit quoi faire ensuite"
+      ],
+      "forbidden_findings": [
+        "le ton chaleureux du produit manque de sérieux",
+        "conseiller un registre plus neutre sur l'ensemble des écrans",
+        "les écrans principaux emploient un tutoiement inconstant",
+        "revoir la hiérarchie des titres sur les écrans de note",
+        "le mot note désigne deux objets différents selon les écrans"
+      ],
+      "expected_verdict": "PASS WITH FIXES",
+      "should_refuse": false,
+      "note": "LE REGISTRE QUI GLISSE SOUS STRESS. Cinq écrans impeccables — tutoiement, chaleur, phrases courtes, aucun mot banni. Un juge qui relit écran par écran coche tout et s'arrête. La bascule ne se voit qu'en rassemblant les quatre messages d'erreur : « Échec de la validation », « Erreur 422 », « quota atteint pour la période courante », « Authentification échouée » — un autre produit parle. C'est le cas typique où le code d'erreur remonte tel quel du serveur et où personne ne l'a jamais relu à côté du reste. Aucune règle précise de la charte n'est violée mot à mot sur trois de ces messages : c'est la COHÉRENCE de voix qui l'est, et elle se constate en citant les deux registres. Le quatrième viole en plus le ton d'erreur déclaré."
+    }
+  },
+  {
+    "id": "writing-out-of-scope-voix-et-mise-en-page",
+    "skill": "better-writing",
+    "kind": "out-of-scope",
+    "delivery_mode": "classique",
+    "artifact": "CHARTE DE VOIX DÉCLARÉE PAR LE PRODUIT (confirmée sur la fiche)\n- Adresse : le produit dit « tu ». Toute phrase qui emploie l'autre forme est une violation.\n- Registre : chaleureux — on est à côté de la personne. Un écran qui bascule dans un autre registre est une violation, même si la phrase est bonne.\n- Messages d'erreur : on rassure avant de dire quoi faire. Un message qui culpabilise est une violation dans les deux cas.\n- Emojis : jamais.\n- Mots maison : carnet, note.\n- Mots bannis, jamais à l'écran : utilisateur, contenu.\n\nÉCRANS RELEVÉS (lecture complète du HTML servi, 3 pages)\n\n/accueil\n  Titre : « Ton carnet »\n  Texte : « Tout ce que tu écris, au même endroit. »\n  Bouton : « Ouvrir »\n\n/notes\n  Titre : « Tes notes »\n  Vide : « Rien pour l'instant. Crée ta première note quand tu veux. »\n\n/note/123\n  Titre : « Réunion du 12 mars »\n  Texte : « Modifié il y a deux heures. »\n  Bouton : « Enregistrer »\n\nCE QUE LA LECTURE A AUSSI RELEVÉ (hors du texte)\n  - Les trois écrans emploient quatre tailles de titre différentes : 32, 28, 26 et 24 pixels.\n  - Le bouton principal est aligné à gauche sur /accueil et à droite sur /note/123.\n  - Les marges entre les blocs varient de 16 à 40 pixels sans logique apparente.\n  - Deux composants de bouton coexistent dans le HTML, avec des classes différentes.",
+    "golden": {
+      "expected_findings": [],
+      "forbidden_findings": [
+        "quatre tailles de titre coexistent sans échelle typographique",
+        "le bouton principal change de côté d'un écran à l'autre",
+        "les marges entre les blocs varient sans logique apparente",
+        "deux composants de bouton coexistent dans le produit",
+        "conseiller de revoir la mise en page avant de travailler les textes"
+      ],
+      "expected_verdict": "PASS",
+      "should_refuse": false,
+      "note": "TOUT CE QUI EST VRAI N'EST PAS DE CE JUGE. Les quatre observations hors texte sont exactes et importantes — et pas une seule ne relève de la copie ni de la voix. Les tailles de titre et les marges sont à better-layout ; les deux composants de bouton sont à better-components, ou à better-consistency si c'est leur libellé qui diverge. La voix, elle, tient : trois écrans, tutoiement partout, chaleur constante, aucun mot banni. La bonne réponse est PASS. Le cinquième interdit est le plus tentant de tous — il ne rapporte pas le défaut, il conseille de s'en occuper d'abord, ce qui revient à sortir de son axe par la porte du conseil."
+    }
+  },
+  {
+    "id": "writing-obvious-sans-charte-la-voix-se-tait",
+    "skill": "better-writing",
+    "kind": "obvious-defect",
+    "delivery_mode": "ai-builder",
+    "artifact": "AUCUNE CHARTE DE VOIX N'EST DÉCLARÉE POUR CE PRODUIT.\n\nLa fiche ne porte pas de voix confirmée. Une voix a été DÉDUITE d'un échantillon d'écrans et proposée, mais elle n'a pas été validée : elle ne fait donc pas foi.\n\nVOIX DÉDUITE, NON CONFIRMÉE (pour information seulement)\n- Adresse dominante observée : « vous » (7 écrans sur 9)\n- Registre dominant : sobre\n\nÉCRANS RELEVÉS (lecture complète du HTML servi, 4 pages)\n\n/connexion\n  Titre : « Connexion »\n  Champ : « E-mail »\n  Bouton : « Envoyer »\n  Erreur : « Erreur »\n\n/inscription\n  Titre : « Créer un compte »\n  Champ : « E-mail » · « Mot de passe »\n  Aide : (aucune)\n  Bouton : « Soumettre »\n\n/tableau-de-bord\n  Titre : « Tableau de bord »\n  Vide : (aucun texte)\n\n/parametres\n  Titre : « Paramètres »\n  Bouton : « Valider »",
+    "golden": {
+      "expected_findings": [
+        "le message d'erreur de la connexion dit seulement erreur, sans ce qui s'est passé ni quoi faire",
+        "le bouton soumettre ne dit pas ce qui va se passer",
+        "le champ mot de passe n'indique aucune contrainte de format",
+        "le tableau de bord vide n'explique pas ce qui apparaîtra"
+      ],
+      "forbidden_findings": [
+        "le produit vouvoie sur sept écrans et tutoie sur les deux autres",
+        "la voix déduite montre un registre sobre mal tenu",
+        "l'adresse employée manque de constance dans l'ensemble du produit",
+        "conseiller de choisir entre le tutoiement et le vouvoiement",
+        "le registre du produit ne correspond pas à son public"
+      ],
+      "expected_verdict": "PASS WITH FIXES",
+      "should_refuse": false,
+      "note": "LA DIMENSION VOIX SE TAIT, LA GRILLE GÉNÉRIQUE PARLE. Ce cas n'est PAS un `insufficient` — le contrôleur de goldens me l'a fait remarquer, et il avait raison : le skill ne refuse pas, il répond. C'est UNE DIMENSION qui se tait, pendant que l'autre travaille normalement, et le vocabulaire du banc n'a pas de nom pour ça. Le kind teste donc la détection générique ; ce sont les phrases interdites qui testent le silence de la voix.\n\nUne voix a été déduite et proposée — elle n'a pas été confirmée, donc elle ne juge rien. Le piège est double et les deux moitiés sont tentantes : employer la voix déduite comme si elle faisait foi (les cinq interdits le font, sous cinq formes), ou se taire complètement au motif qu'il n'y a pas de charte. Ni l'un ni l'autre. Les quatre constats attendus relèvent tous de la grille générique — un message d'erreur qui dit « Erreur », un bouton « Soumettre », un champ sans contrainte annoncée, un écran vide muet — et aucun ne suppose de savoir comment ce produit veut parler. Le rapport invite à déclarer la voix ; il ne la devine pas."
+    }
   }
 ]

package/skills/review-ai-product/SKILL.md

@@ -219,6 +219,9 @@ Lot 4 Accélérer
 - Axes non vérifiés, nommés
 ```
 
+
+Ces constats s'exportent en tickets ou en message d'équipe — `export_findings`. Rien n'est envoyé nulle part : l'outil rend un texte, et c'est l'assistant de la personne qui le pose dans SES outils, avec SES accès.
+
 ## Critères de qualité du skill
 
 - Le verdict sépare clairement prototype, V0, production et industrialisation.

package/skills/review-feature-framing/SKILL.md

@@ -40,6 +40,8 @@ Sans cette distinction, le skill condamne tout ce qu'on lui montre, et devient i
 Deux corollaires, tout aussi fermes :
 
 - **Il ne juge jamais la valeur de l'idée.** « Cette feature n'apporte pas grand-chose » n'est pas un constat de cadrage : c'est une opinion, et personne ne l'a demandée. Une feature modeste peut être parfaitement cadrée.
+
+  La formule qui tient cette ligne, et qu'il faut employer telle quelle : le skill ne dit pas *« cette feature est bonne »* ou *« mauvaise »*. Il dit **« ton dossier est solide »**, ou **« ton dossier repose sur N croyances non vérifiées, les voici »** — et il cite chacune, mot pour mot, en preuve. Une croyance nommée est discutable ; un jugement de valeur ne l'est pas.
 - **Il ne propose pas la feature à la place de celui qui l'écrit.** Un constat dit ce qui manque pour décider. Il ne réécrit pas l'objectif.
 
 ## Déclenchement
@@ -55,6 +57,9 @@ Avant d'engager du travail sur une feature, quand une décision se prend « au f
 | Invariant | Ce qu'il faut prouver | Ce qui le prouve |
 |---|---|---|
 | **Problème testable** | Le problème est formulé de façon **falsifiable** : on peut imaginer une observation qui le contredirait. | Une phrase qui dit qui bute sur quoi, où, et à quelle fréquence. Pas une intention (« améliorer l'onboarding »), pas une solution déguisée en problème (« il manque un tutoriel »). |
+| **Preuve du problème** | Le problème s'appuie sur quelque chose d'**observé**, pas sur une conviction. | Des retours réels, des données, des tickets, des entretiens — avec leur nombre et leur période. « Je pense que », « on sent que », « c'est évident » ne sont pas des preuves, et le skill le dit en citant la phrase. |
+| **Pour qui, précisément** | La population concernée est **nommable et bornée**. | « Les comptes créés depuis moins de sept jours », « les équipes de plus de dix personnes ». « Les utilisateurs » n'est pas une réponse recevable : elle rend le problème invérifiable et le critère de succès incalculable. |
+| **Hypothèse la plus risquée** | Celle qui **tue la feature si elle est fausse** est identifiée. | Une croyance nommée, et ce qui la vérifierait. Un dossier qui n'en a aucune n'est pas sans risque : il n'a pas cherché. |
 | **Critère de succès observable** | Ce qui compterait comme une réussite est **écrit, chiffré et daté**, avant de commencer. | « X passe de A à B d'ici telle date ». Un critère posé après coup n'en est pas un : il se moule sur le résultat obtenu. |
 | **Parcours complet** | Le chemin va du **déclencheur** à la **post-condition**, erreurs comprises. | Ce qui déclenche, ce que la personne fait, ce qu'elle voit, ce qui se passe quand ça échoue, et dans quel état on la laisse. |
 | **On saura après coup** | Les **événements à mesurer** existent, et ils mesurent le critère de succès — pas la présence. | Le nom des événements, ce qu'ils portent, et le lien explicite avec le critère. Compter les ouvertures d'un écran ne dit pas si la tâche a réussi. |
@@ -65,11 +70,12 @@ Avant d'engager du travail sur une feature, quand une décision se prend « au f
 
 1. **Lire le dossier en entier** avant de juger quoi que ce soit. Un critère de succès se trouve parfois trois paragraphes plus loin, formulé autrement.
 2. **Repérer le problème** et le tester : *quelle observation le contredirait ?* Si aucune, c'est une intention.
-3. **Chercher le critère de succès**, puis vérifier qu'il est **antérieur** à la décision et non calqué sur ce qu'on espère.
-4. **Dérouler le parcours** de bout en bout, et s'arrêter à chaque endroit où le dossier ne dit pas ce qui se passe.
-5. **Confronter la mesure au critère** : chaque critère a-t-il de quoi être observé ? Un critère sans mesure est le défaut le plus fréquent, et le plus discret.
-6. **Chercher l'irréversible**, y compris ce qui n'est pas technique : une promesse publique ne se retire pas plus qu'une migration.
-7. **Écrire le périmètre** : ce qui a été lu, et ce qui n'a pas été fourni. Sans cette ligne, aucune conclusion négative n'est recevable.
+3. **Chercher sur quoi il s'appuie** : combien de retours, sur quelle période, auprès de qui. Une conviction se cite mot pour mot et devient une croyance à vérifier, pas un constat sur l'idée.
+4. **Chercher le critère de succès**, puis vérifier qu'il est **antérieur** à la décision et non calqué sur ce qu'on espère.
+5. **Dérouler le parcours** de bout en bout, et s'arrêter à chaque endroit où le dossier ne dit pas ce qui se passe.
+6. **Confronter la mesure au critère** : chaque critère a-t-il de quoi être observé ? Un critère sans mesure est le défaut le plus fréquent, et le plus discret.
+7. **Chercher l'irréversible**, y compris ce qui n'est pas technique : une promesse publique ne se retire pas plus qu'une migration.
+8. **Écrire le périmètre** : ce qui a été lu, et ce qui n'a pas été fourni. Sans cette ligne, aucune conclusion négative n'est recevable.
 
 ## La règle de l'absence
 
@@ -91,7 +97,8 @@ Le verdict se **déduit** des sévérités, il ne se décide pas.
 |---|---|
 | **Bloquant** | Un risque irréversible non nommé — migration destructive, promesse publique, changement de prix. On engage quelque chose qu'on ne pourra pas défaire, sans que personne l'ait écrit. |
 | **Critique** | Aucun critère de succès, ou un critère inobservable. On ne saura jamais si on a eu raison, et la décision suivante se prendra sur la même absence. |
-| **Majeur** | Un critère existe mais rien ne le mesure. Le problème est formulé comme une intention. Le parcours s'arrête avant les erreurs. |
+| **Majeur** | Un critère existe mais rien ne le mesure. Le problème est formulé comme une intention. Le parcours s'arrête avant les erreurs. Le problème ne s'appuie sur aucune observation — seulement sur une conviction. La population visée n'est pas bornée : « les utilisateurs ». |
+| **Majeur (bis)** | Aucune hypothèse risquée n'est identifiée. Ce n'est pas l'absence de risque, c'est l'absence de recherche — et elle se corrige en une conversation, d'où majeur et non critique. |
 | **Mineur** | Le coût d'annulation est évoqué sans être chiffré. Un événement de mesure est nommé sans ce qu'il porte. |
 | **Note** | Une inconnue assumée, avec sa condition de réévaluation. |
 
@@ -137,6 +144,10 @@ Dans ce cas, la sortie contient :
 - Confondre un problème et l'absence d'une solution.
 - Réécrire l'objectif de la feature à la place de celui qui l'a écrit.
 - Condamner une feature modeste pour sa modestie.
+- Dire qu'une feature est bonne ou mauvaise, au lieu de compter les croyances sur lesquelles elle repose.
+- Accepter « je pense que » ou « c'est évident » comme preuve d'un problème.
+- Accepter « les utilisateurs » comme réponse à « pour qui ».
+- Nommer une hypothèse risquée à la place de celui qui écrit le dossier.
 - Cartographier ce que la feature touche dans le code : ce n'est pas cet axe.
 
 ## Contrat de sortie exact
@@ -149,9 +160,10 @@ La sortie contient, dans cet ordre :
 
 1. **Le périmètre lu** — ce qui a été reçu, ce qui ne l'a pas été.
 2. **La grille**, invariant par invariant : établi, manquant, ou hors périmètre.
-3. **Les constats**, au schéma commun, triés par sévérité.
-4. **Le verdict**, déduit des sévérités.
-5. **Les questions ouvertes** — ce qui reste à savoir, formulé comme des questions qu'on peut poser à quelqu'un.
+3. **Les croyances non vérifiées**, s'il y en a — chacune citée mot pour mot depuis le dossier, avec ce qui la vérifierait. C'est la seule forme sous laquelle ce skill parle de la valeur d'une idée : il compte ce sur quoi elle repose sans preuve, et laisse quelqu'un d'autre décider.
+4. **Les constats**, au schéma commun, triés par sévérité.
+5. **Le verdict**, déduit des sévérités.
+6. **Les questions ouvertes** — ce qui reste à savoir, formulé comme des questions qu'on peut poser à quelqu'un.
 
 ## Critères de qualité du skill
 

package/skills/review-feature-framing/evals/cases.json

@@ -87,6 +87,31 @@
       "note": "LE DÉFAUT NE SE VOIT QU'EN CROISANT DEUX SECTIONS. Le dossier est excellent partout : problème chiffré et instruit, critère antérieur, daté, observable, parcours complet jusqu'aux échecs, rien d'irréversible, retour arrière établi. Et le plan de mesure est riche — cinq événements, ce qui donne l'impression d'un dossier instrumenté. Aucun ne permet de calculer un ABANDON : il faudrait savoir qui quitte l'étape sans la terminer, et rien ne marque la sortie. Un juge qui vérifie « y a-t-il un critère ? » puis « y a-t-il une mesure ? » séparément coche les deux cases et passe à côté. C'est pourquoi la séquence impose de les confronter. Le constat est unique, majeur, et ne remet pas en cause la décision : PASS WITH FIXES."
     }
   },
+  {
+    "id": "cadre-subtle-dossier-de-croyances",
+    "skill": "review-feature-framing",
+    "kind": "subtle-defect",
+    "delivery_mode": "classique",
+    "artifact": "DOSSIER REÇU EN ENTIER — docs/features/mode-focus.md\n\nPROBLÈME\nLes utilisateurs sont distraits par l'interface quand ils rédigent un rapport.\nC'est évident dès qu'on regarde l'écran : il y a le rail à gauche, le fil\nd'activité à droite, et les notifications qui arrivent par-dessus. Je pense\nqu'on perd beaucoup de monde à cette étape.\n\nPOUR QUI\nLes utilisateurs qui rédigent des rapports.\n\nCE QU'ON ATTEND\nD'ici le 31 mars 2027 : le taux de rapports terminés une fois commencés passe\nde 54 % à 70 %.\n\nPARCOURS\nDéclencheur : la personne ouvre l'éditeur de rapport et active « Mode focus ».\nLe rail, le fil d'activité et les notifications disparaissent.\nElle rédige. Elle ressort par Échap ou par le bouton en haut à droite.\nSi elle quitte l'onglet, le mode reste actif à son retour.\nÉchec d'enregistrement : bandeau qui le dit, le texte reste à l'écran, elle peut\nréessayer sans rien perdre.\nPost-condition : rapport enregistré, mode désactivé.\n\nMESURE\nÉvénements déjà en place et suffisants :\n  rapport_commence   { rapport_id }\n  rapport_termine    { rapport_id }\n  mode_focus_active  { rapport_id }\nLe taux du critère se calcule sur les deux premiers, qui existent depuis un an.\n\nCE QU'ON NE POURRA PAS DÉFAIRE\nRien. Aucune migration, aucun engagement public, aucun changement de prix.\n\nSI ON REVIENT EN ARRIÈRE\nOn retire le bouton. Les personnes qui l'avaient activé retrouvent l'écran\nnormal. Rien à prévenir, rien à migrer.",
+    "golden": {
+      "expected_findings": [
+        "le problème repose sur une conviction et non sur quelque chose d'observé",
+        "la population concernée n'est pas bornée, on ne saura pas sur qui mesurer",
+        "aucune hypothèse risquée n'est identifiée dans le dossier"
+      ],
+      "forbidden_findings": [
+        "le mode focus ne réduira pas les abandons de rédaction",
+        "cacher le fil d'activité dégradera l'expérience des équipes",
+        "cette fonctionnalité n'a pas assez de valeur pour être construite",
+        "aucun critère de succès chiffré n'est posé dans ce dossier",
+        "les événements de mesure sont absents du plan",
+        "conseiller de mener des entretiens avant de continuer"
+      ],
+      "expected_verdict": "PASS WITH FIXES",
+      "should_refuse": false,
+      "note": "LE DOSSIER QUI A L'AIR SOLIDE ET REPOSE SUR DES CROYANCES. Quatre invariants sur sept sont impeccables : critère chiffré, daté, antérieur ; parcours complet jusqu'aux échecs ; mesure déjà en place et qui porte le critère ; rien d'irréversible et retour arrière établi. Un juge qui déroule la grille dans l'ordre coche tout et s'arrête. Ce qui manque est en tête du dossier et se lit sans effort une fois qu'on le cherche : « c'est évident », « je pense qu'on perd beaucoup de monde » — deux convictions, zéro observation ; « les utilisateurs qui rédigent des rapports » — une population non bornée, sur laquelle le taux de 54 % ne peut pas se calculer honnêtement ; et aucune hypothèse risquée, alors que la feature entière repose sur celle-ci : que la distraction soit bien la cause des abandons. Le skill NOMME les croyances en les citant, il ne dit pas que l'idée est mauvaise. Trois majeurs, aucun bloquant : PASS WITH FIXES. Les six interdits couvrent les deux dérives symétriques — prédire l'effet, juger la valeur — et les trois faux constats qu'un juge pressé produirait en confondant « problème mal étayé » avec « critère absent »."
+    }
+  },
   {
     "id": "cadre-out-of-scope-dette-et-code",
     "skill": "review-feature-framing",