designwithai-mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,1136 @@
+#!/usr/bin/env node
+/**
+ * Serveur MCP du Handbook Design With AI.
+ *
+ * Expose la source de vérité éditoriale à Claude / un IDE, en RESOURCES (pour
+ * lire) et en TOOLS (pour agir). Principe directeur : les outils imposent la
+ * méthode du Handbook — ils ne distribuent pas des réponses. `review_artifact`
+ * exige une référence d'artefact ; `recommend_workflow` et `build_action_plan`
+ * renvoient des GATES à franchir, pas des solutions clé en main.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { chapterMatchesMode, excerpt, loadHandbook, scoreUnit, tokenize, } from "./handbook.js";
+import { loadSkills } from "./skills.js";
+import { loadProfile, profileSummary, resolveDeliveryMode, saveProfile, } from "./profile.js";
+import { compareReviews, getReview, listReviews, saveReview, updateFindingStatus, } from "./reviews.js";
+import { saveDecision } from "./decisions.js";
+import { clearGate, loadState, reopenGate, saveState } from "./state.js";
+import { readRepoSnapshot } from "./connectors.js";
+import { trySemanticScores } from "./embeddings.js";
+import { getCase, loadCases, saveScore, scoreCase, scorecard, } from "./evals.js";
+const { handbook, origin } = await loadHandbook();
+process.stderr.write(`[designwithai-mcp] ${handbook.units.length} unités chargées depuis ${origin}\n`);
+const { skills, sharedContract, origin: skillsOrigin } = loadSkills();
+process.stderr.write(`[designwithai-mcp] ${skills.length} skills chargés depuis ${skillsOrigin}\n`);
+const skillByName = new Map(skills.map((s) => [s.name, s]));
+let currentProfile = loadProfile().profile;
+process.stderr.write(`[designwithai-mcp] profil : ${currentProfile ? profileSummary(currentProfile) || "(chargé)" : "aucun"}\n`);
+/**
+ * Le mode effectif : l'argument explicite gagne, sinon on retombe sur le mode
+ * déclaré dans le profil. C'est ce qui contextualise les recos sans redemander.
+ */
+function effectiveMode(args) {
+    const explicit = args.delivery_mode ? resolveDeliveryMode(String(args.delivery_mode)) : undefined;
+    return explicit ?? resolveDeliveryMode(currentProfile?.deliveryMode);
+}
+const byUri = new Map(handbook.units.map((u) => [u.uri, u]));
+const orderOf = new Map(handbook.units.map((u, i) => [u.uri, i]));
+const chapterUnits = handbook.units.filter((u) => u.kind === "chapter");
+const chapterById = new Map(chapterUnits.map((u) => [u.id, u]));
+const REQUIRES = handbook.graph?.requires ?? {};
+let currentState = loadState();
+process.stderr.write(`[designwithai-mcp] gates franchis : ${Object.keys(currentState.gates).length}/${chapterUnits.length}\n`);
+/** Résout un chapitre depuis un id (`volume/slug`), un slug, ou des mots-clés. */
+function resolveChapter(query) {
+    const q = query.trim();
+    if (!q)
+        return null;
+    const exact = chapterUnits.find((u) => u.id === q || u.chapter === q || u.uri.endsWith(`/${q}`));
+    if (exact)
+        return exact;
+    const terms = tokenize(q);
+    const ranked = chapterUnits
+        .map((u) => ({ u, s: scoreUnit(u, terms) }))
+        .filter((x) => x.s > 0)
+        .sort((a, b) => b.s - a.s);
+    return ranked[0]?.u ?? null;
+}
+const DELIVERY_MODES = ["ai-builder", "classique", "hybride"];
+const KINDS = [
+    "chapter",
+    "rule",
+    "anti-pattern",
+    "prompt",
+    "checklist",
+    "scorecard",
+];
+function cite(u) {
+    return `${u.source_url} (v${u.version})`;
+}
+function atomsOf(chapterId, kinds) {
+    return handbook.units.filter((u) => u.parent === chapterId && kinds.includes(u.kind));
+}
+/** Chapitres pertinents pour une requête, filtrés par mode, rendus en ordre curriculaire. */
+function rankChapters(query, mode, limit) {
+    const terms = tokenize(query);
+    return handbook.units
+        .filter((u) => u.kind === "chapter" && chapterMatchesMode(u, mode))
+        .map((u) => ({ u, s: scoreUnit(u, terms) }))
+        .filter((x) => x.s > 0)
+        .sort((a, b) => b.s - a.s)
+        .slice(0, limit)
+        .map((x) => x.u)
+        .sort((a, b) => (orderOf.get(a.uri) ?? 0) - (orderOf.get(b.uri) ?? 0));
+}
+function text(s) {
+    return { content: [{ type: "text", text: s }] };
+}
+function refusal(s) {
+    return { content: [{ type: "text", text: s }], isError: true };
+}
+// ─── Définitions des outils ──────────────────────────────────────────────────
+const deliveryModeProp = {
+    type: "string",
+    enum: DELIVERY_MODES,
+    description: "Mode de construction déclaré. Filtre comme le fait le site.",
+};
+const TOOLS = [
+    {
+        name: "search_handbook",
+        description: "Cherche dans le Handbook (chapitres, règles, prompts, checklists, scorecards). " +
+            "Chaque résultat cite sa source et sa version — à réutiliser dans la réponse.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Ce que tu cherches." },
+                kind: { type: "string", enum: KINDS, description: "Restreindre à un type d'unité." },
+                book: { type: "integer", enum: [1, 2], description: "1 = Product Design, 2 = Design System." },
+                delivery_mode: deliveryModeProp,
+                limit: { type: "integer", description: "Nombre de résultats (défaut 8).", default: 8 },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "recommend_workflow",
+        description: "Pour un objectif, renvoie une SÉQUENCE DE GATES à franchir dans l'ordre — pas une " +
+            "solution. Chaque gate exige un artefact réel et un critère de sortie observable.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                objective: { type: "string", description: "Ce que l'utilisateur veut accomplir." },
+                delivery_mode: deliveryModeProp,
+            },
+            required: ["objective"],
+        },
+    },
+    {
+        name: "review_artifact",
+        description: "Renvoie la GRILLE du Handbook (critères de gate, règles) à confronter à un artefact. " +
+            "Exige une référence d'artefact localisable — sans elle, refuse. Ne juge pas à ta place.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_ref: {
+                    type: "string",
+                    description: "Où se trouve l'artefact : lien Figma, chemin de fichier, URL.",
+                },
+                topic: { type: "string", description: "Le sujet à cibler (ex. « design system », « prompt »)." },
+                delivery_mode: deliveryModeProp,
+            },
+            required: ["artifact_ref"],
+        },
+    },
+    {
+        name: "build_action_plan",
+        description: "Pour une situation ou une difficulté, renvoie un plan de GATES priorisés, chacun avec " +
+            "son artefact et son critère observable. Ce qu'il faut PRODUIRE, pas des conseils.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                situation: { type: "string", description: "La situation, le blocage ou la difficulté." },
+                delivery_mode: deliveryModeProp,
+            },
+            required: ["situation"],
+        },
+    },
+    {
+        name: "set_profile",
+        description: "Déclare ou met à jour le profil projet de l'utilisateur pour la session (nom, type, " +
+            "mode de delivery, état du design system, difficulté). Les autres outils s'y adaptent " +
+            "ensuite sans qu'on le redonne. Persisté localement.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                product_type: { type: "string" },
+                audience: { type: "string" },
+                stage: { type: "string" },
+                delivery_mode: { type: "string", description: "ai-builder | classique | hybride (ou un libellé)." },
+                ds_stage: { type: "string" },
+                difficulty: { type: "string" },
+                use_case: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "save_review",
+        description: "Enregistre le résultat d'un skill (issue register) comme ARTEFACT suivi et horodaté, " +
+            "attaché à une référence d'artefact. Permet de re-jouer et de comparer en régression. " +
+            "Exige artifact_ref — sans elle, refuse.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                skill: { type: "string", description: "Le skill qui a produit la review (ex. better-layout)." },
+                artifact_ref: { type: "string", description: "L'artefact audité : lien, chemin, URL." },
+                verdict: { type: "string", enum: ["PASS", "PASS WITH FIXES", "FAIL", "BLOCKED"] },
+                delivery_mode: deliveryModeProp,
+                notes: { type: "string" },
+                findings: {
+                    type: "array",
+                    description: "Les problèmes trouvés, au schéma issue register.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            severity: { type: "string", enum: ["bloquant", "critique", "majeur", "mineur", "note"] },
+                            location: { type: "string" },
+                            category: { type: "string" },
+                            summary: { type: "string" },
+                            evidence: { type: "string" },
+                            impact: { type: "string" },
+                            correction: { type: "string" },
+                            acceptance: { type: "string" },
+                            confidence: { type: "string", enum: ["élevée", "moyenne", "faible"] },
+                        },
+                    },
+                },
+            },
+            required: ["skill", "artifact_ref"],
+        },
+    },
+    {
+        name: "list_reviews",
+        description: "Liste les reviews enregistrées, filtrables par artefact ou par skill.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_ref: { type: "string" },
+                skill: { type: "string" },
+                limit: { type: "integer", default: 20 },
+            },
+        },
+    },
+    {
+        name: "push_audit",
+        description: "Envoie une review déjà enregistrée vers le compte designwithai de l'utilisateur, " +
+            "pour qu'elle apparaisse dans son cockpit sur n'importe quel appareil. " +
+            "Exige DWAI_TOKEN (jeton d'appareil, révocable) et DWAI_INGEST_URL dans l'environnement. " +
+            "Aucun secret fort ne transite : le jeton ne donne accès qu'à l'écriture d'un audit.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                review_id: {
+                    type: "string",
+                    description: "L'id d'une review enregistrée. À défaut, la plus récente est prise.",
+                },
+                scope: {
+                    type: "string",
+                    description: "Ce que l'audit a couvert, en clair (ex. « interface », « sécurité + données »).",
+                },
+            },
+        },
+    },
+    {
+        name: "compare_reviews",
+        description: "Compare deux reviews (régression) : problèmes résolus, nouveaux, persistants. " +
+            "Passe deux ids, ou un artifact_ref pour comparer ses deux dernières passes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                review_base: { type: "string", description: "Id de la review ANCIENNE." },
+                review_head: { type: "string", description: "Id de la review RÉCENTE." },
+                artifact_ref: { type: "string", description: "À défaut d'ids : compare les 2 dernières de cet artefact." },
+            },
+        },
+    },
+    {
+        name: "clear_gate",
+        description: "Ferme un gate en y attachant sa preuve. Comme sur le site : lire ne débloque rien — " +
+            "un gate se ferme sur un artefact localisable. Exige artifact_ref.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chapter: {
+                    type: "string",
+                    description: "Le chapitre du gate : son id (volume/slug), son slug, ou des mots-clés.",
+                },
+                artifact_ref: {
+                    type: "string",
+                    description: "Où est l'artefact produit : lien Figma, chemin de fichier, URL.",
+                },
+            },
+            required: ["chapter", "artifact_ref"],
+        },
+    },
+    {
+        name: "reopen_gate",
+        description: "Rouvre un gate franchi (retire sa preuve).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chapter: { type: "string", description: "Le chapitre du gate à rouvrir." },
+            },
+            required: ["chapter"],
+        },
+    },
+    {
+        name: "gate_status",
+        description: "Où en est l'utilisateur : gates franchis vs total, les derniers franchis (avec preuve), " +
+            "et les prochains suggérés (non franchis).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                objective: { type: "string", description: "Optionnel : biaise les suggestions." },
+                delivery_mode: deliveryModeProp,
+            },
+        },
+    },
+    {
+        name: "audit_project",
+        description: "Flow de bout en bout : audite un VRAI artefact (Figma, dépôt, URL) avec l'orchestrateur, " +
+            "ancré dans le Handbook et le profil, puis trace le résultat (review + gates). Compose " +
+            "l'orchestrateur, le profil et l'état. Exige artifact_ref.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_ref: { type: "string", description: "L'artefact réel : lien Figma, dépôt, URL." },
+                objective: { type: "string", description: "Ce que l'audit doit décider ou améliorer." },
+                scope: { type: "string", description: "Écrans, parcours ou composants à couvrir." },
+                delivery_mode: deliveryModeProp,
+            },
+            required: ["artifact_ref"],
+        },
+    },
+    {
+        name: "list_eval_cases",
+        description: "Liste les cas du banc d'éval d'un skill (id + type). Ne révèle pas la golden review.",
+        inputSchema: {
+            type: "object",
+            properties: { skill: { type: "string" } },
+            required: ["skill"],
+        },
+    },
+    {
+        name: "get_eval_case",
+        description: "Renvoie l'artefact d'un cas d'éval, À L'AVEUGLE (sans la golden). Applique le skill dessus, " +
+            "puis appelle score_review avec tes findings.",
+        inputSchema: {
+            type: "object",
+            properties: { case_id: { type: "string" } },
+            required: ["case_id"],
+        },
+    },
+    {
+        name: "score_review",
+        description: "Score une review candidate contre la golden d'un cas : détection, périmètre, verdict, refus. " +
+            "Enregistre le résultat dans la scorecard du skill.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                case_id: { type: "string" },
+                verdict: { type: "string", enum: ["PASS", "PASS WITH FIXES", "FAIL", "BLOCKED"] },
+                refused: { type: "boolean", description: "true si le skill a refusé (artefact insuffisant)." },
+                findings: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            severity: { type: "string" },
+                            location: { type: "string" },
+                            category: { type: "string" },
+                            summary: { type: "string" },
+                            correction: { type: "string" },
+                        },
+                    },
+                },
+            },
+            required: ["case_id"],
+        },
+    },
+    {
+        name: "skill_scorecard",
+        description: "La scorecard agrégée d'un skill : détection, faux positifs, respect du périmètre, refus.",
+        inputSchema: {
+            type: "object",
+            properties: { skill: { type: "string" } },
+            required: ["skill"],
+        },
+    },
+    {
+        name: "verify_fix",
+        description: "Vérifie qu'une recommandation a RÉELLEMENT été appliquée, critère par critère, sur " +
+            "l'artefact courant. Exige artifact_ref et des critères. Peut mettre à jour le statut " +
+            "d'un finding stocké (open → fixed/partial).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artifact_ref: { type: "string", description: "L'état COURANT vérifié : lien, chemin, URL." },
+                expected_fix: { type: "string", description: "La recommandation censée avoir été appliquée." },
+                results: {
+                    type: "array",
+                    description: "Ton évaluation par critère d'acceptation.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            criterion: { type: "string" },
+                            met: { type: "boolean" },
+                            evidence: { type: "string" },
+                        },
+                        required: ["criterion", "met"],
+                    },
+                },
+                review_id: { type: "string", description: "Optionnel : la review d'origine à mettre à jour." },
+                finding_index: { type: "integer", description: "Optionnel : index du finding (0-based)." },
+            },
+            required: ["artifact_ref", "results"],
+        },
+    },
+    {
+        name: "generate_decision_record",
+        description: "Transforme une analyse en décision traçable (ADR) : contexte, preuves, options, décision, " +
+            "risques acceptés, critères de réévaluation, règles du Handbook utilisées. Persistée.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                title: { type: "string" },
+                context: { type: "string" },
+                decision: { type: "string" },
+                evidence: { type: "array", items: { type: "string" } },
+                options: { type: "array", items: { type: "string" } },
+                accepted_risks: { type: "array", items: { type: "string" } },
+                review_criteria: { type: "array", items: { type: "string" } },
+                sources: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Les unités du Handbook citées (uri, ou titre + version).",
+                },
+                artifact_ref: { type: "string" },
+            },
+            required: ["title", "decision"],
+        },
+    },
+    {
+        name: "next_gate",
+        description: "Le prochain gate à franchir, CONSCIENT DES PRÉRÉQUIS : ne propose que des gates débloqués " +
+            "(leurs prérequis sont franchis) et pas encore faits. Explique pourquoi et l'artefact attendu, " +
+            "et liste les gates bloqués avec ce qui manque.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                objective: { type: "string", description: "Optionnel : biaise vers un objectif." },
+                delivery_mode: deliveryModeProp,
+            },
+        },
+    },
+    {
+        name: "connect_repo",
+        description: "Lit un DÉPÔT LOCAL pour ancrer l'analyse dans le vrai code : stack, composants, tokens, " +
+            "sources présentes/absentes. Les sources distantes (Figma, Supabase live, GitHub) passent " +
+            "par leurs propres serveurs MCP.",
+        inputSchema: {
+            type: "object",
+            properties: { path: { type: "string", description: "Chemin du dépôt local à lire." } },
+            required: ["path"],
+        },
+    },
+];
+// ─── Implémentations ─────────────────────────────────────────────────────────
+function toolSetProfile(args) {
+    const fields = {
+        name: "name",
+        product_type: "productType",
+        audience: "audience",
+        stage: "stage",
+        delivery_mode: "deliveryMode",
+        ds_stage: "dsStage",
+        difficulty: "difficulty",
+        use_case: "useCase",
+    };
+    const merged = { ...(currentProfile ?? {}) };
+    for (const [arg, field] of Object.entries(fields)) {
+        const v = args[arg];
+        if (v != null && String(v).trim())
+            merged[field] = String(v).trim();
+    }
+    currentProfile = merged;
+    let saved = "(non persisté)";
+    try {
+        saved = saveProfile(merged);
+    }
+    catch {
+        /* stockage bloqué : le profil vaut pour la session, sans persistance */
+    }
+    return text(`Profil enregistré : ${profileSummary(merged) || "(vide)"}\n` +
+        `Fichier : ${saved}\n` +
+        `Mode retenu : ${resolveDeliveryMode(merged.deliveryMode) ?? "non déterminé"}. ` +
+        `Les prochaines recos s'y adaptent.`);
+}
+// Poids du sémantique dans le score combiné, et seuil sous lequel une similarité
+// est trop faible pour compter (sinon tout le corpus obtient un petit score).
+const SEM_WEIGHT = 12;
+const SEM_FLOOR = 0.25;
+async function toolSearch(args) {
+    const query = String(args.query ?? "");
+    const kind = args.kind;
+    const book = args.book;
+    const mode = effectiveMode(args);
+    const limit = Math.max(1, Math.min(25, Number(args.limit ?? 8)));
+    const terms = tokenize(query);
+    const rawTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const pool = handbook.units
+        .filter((u) => (kind ? u.kind === kind : true))
+        .filter((u) => (book ? u.book === book : true))
+        .filter((u) => chapterMatchesMode(u, mode));
+    // Sémantique seulement si des embeddings existent — sinon on retombe sur les
+    // mots-clés, à l'identique.
+    const sem = query ? await trySemanticScores(query) : null;
+    const hits = pool
+        .map((u) => {
+        const kw = scoreUnit(u, terms);
+        const cs = sem ? (sem.get(u.uri) ?? 0) : 0;
+        return { u, score: kw + (cs >= SEM_FLOOR ? SEM_WEIGHT * cs : 0) };
+    })
+        .filter((x) => x.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    if (hits.length === 0)
+        return text(`Aucun résultat pour « ${query} ».`);
+    const kindLabel = sem ? "hybride : mots-clés + sémantique" : "mots-clés";
+    const body = hits
+        .map(({ u }, i) => `${i + 1}. [${u.kind}] ${u.title}\n   ${cite(u)}\n   ${excerpt(u.text, rawTerms)}`)
+        .join("\n\n");
+    return text(`${hits.length} résultat(s) pour « ${query} » (${kindLabel}). Cite la source de chacun.\n\n${body}`);
+}
+function toolRecommend(args) {
+    const objective = String(args.objective ?? "");
+    const mode = effectiveMode(args);
+    const cleared = new Set(Object.keys(currentState.gates));
+    const pool = rankChapters(objective, mode, 12);
+    const fresh = pool.filter((u) => !cleared.has(u.id));
+    const chapters = fresh.slice(0, 6);
+    const skipped = pool.length - fresh.length;
+    if (chapters.length === 0) {
+        return text(pool.length === 0
+            ? `Rien de pertinent trouvé pour « ${objective} ».`
+            : `Tout ce qui ressort pour « ${objective} » est déjà franchi (${pool.length} gate(s)). Rien à proposer — c'est bon signe.`);
+    }
+    const steps = chapters
+        .map((u, i) => {
+        const g = u.gate;
+        return (`${i + 1}. ${u.title}\n` +
+            (g ? `   Artefact : ${g.artifact}\n   Réussi quand : ${g.criterion}\n` : "") +
+            `   Source : ${cite(u)}`);
+    })
+        .join("\n\n");
+    return text(`Ces ${chapters.length} étapes sont des GATES à franchir dans l'ordre pour « ${objective} » — ` +
+        `pas une solution clé en main. Chacune exige un artefact réel ; lire ne débloque rien.` +
+        (skipped ? ` (${skipped} déjà franchi(s), écarté(s).)` : "") +
+        `\n\n${steps}\n\nQuand un gate est produit, ferme-le avec clear_gate + son artefact.`);
+}
+function toolReview(args) {
+    const ref = String(args.artifact_ref ?? "").trim();
+    if (!ref) {
+        return refusal("review_artifact exige une référence d'artefact localisable (lien Figma, chemin de " +
+            "fichier, URL). Un review sans artefact qu'on peut ouvrir n'en est pas un — c'est un " +
+            "avis en l'air. Fournis `artifact_ref`.");
+    }
+    const mode = effectiveMode(args);
+    const topic = String(args.topic ?? "") || ref;
+    const chapters = rankChapters(topic, mode, 4);
+    if (chapters.length === 0) {
+        return text(`Artefact : ${ref}\nAucun chapitre ne ressort pour « ${topic} ». Précise le sujet du review.`);
+    }
+    const grid = chapters
+        .map((u) => {
+        const rules = atomsOf(u.id, ["rule", "anti-pattern", "scorecard"]);
+        const rulesText = rules.length
+            ? "\n" + rules.map((r) => `   • [${r.kind}] ${r.title}`).join("\n")
+            : "";
+        return (`## ${u.title}  —  ${cite(u)}\n` +
+            (u.gate ? `Critère de gate : ${u.gate.criterion}` : "") +
+            rulesText);
+    })
+        .join("\n\n");
+    return text(`Review de l'artefact : ${ref}\n\n` +
+        `Confronte-le aux critères du Handbook ci-dessous : réponds oui/non à chacun, en citant la ` +
+        `source. Le MCP donne la grille ; le jugement reste le tien.\n\n${grid}`);
+}
+function toolPlan(args) {
+    const situation = String(args.situation ?? "");
+    const mode = effectiveMode(args);
+    const cleared = new Set(Object.keys(currentState.gates));
+    const pool = rankChapters(situation, mode, 12);
+    const fresh = pool.filter((u) => !cleared.has(u.id));
+    const chapters = fresh.slice(0, 6);
+    const skipped = pool.length - fresh.length;
+    if (chapters.length === 0) {
+        return text(pool.length === 0
+            ? `Rien de pertinent trouvé pour « ${situation} ».`
+            : `Tout ce qui répond à « ${situation} » est déjà franchi (${pool.length} gate(s)).`);
+    }
+    const plan = chapters
+        .map((u, i) => {
+        const g = u.gate;
+        return (`${i + 1}. ${u.title}\n` +
+            (g
+                ? `   À produire : ${g.artifact}\n   Gate franchi quand : ${g.criterion}\n   Budget : ~${g.minutes} min\n`
+                : "") +
+            `   Source : ${cite(u)}`);
+    })
+        .join("\n\n");
+    return text(`Plan d'action pour : « ${situation} ».\n` +
+        `Ce sont des GATES à franchir dans l'ordre — ce qu'il faut PRODUIRE, pas des conseils. ` +
+        `Chaque gate se ferme sur un artefact et un critère observable.` +
+        (skipped ? ` (${skipped} déjà franchi(s), écarté(s).)` : "") +
+        `\n\n${plan}`);
+}
+// ─── Reviews suivies (étape C) ───────────────────────────────────────────────
+function sevCounts(findings) {
+    const order = ["bloquant", "critique", "majeur", "mineur", "note"];
+    const c = {};
+    for (const f of findings) {
+        const s = f.severity ?? "note";
+        c[s] = (c[s] ?? 0) + 1;
+    }
+    const parts = order.filter((s) => c[s]).map((s) => `${c[s]} ${s}`);
+    return parts.length ? parts.join(", ") : "aucun";
+}
+function renderFinding(f) {
+    return `   • [${f.severity ?? "note"}] ${f.location ? `${f.location} — ` : ""}${f.summary ?? f.category ?? ""}`;
+}
+function toolSaveReview(args) {
+    const artifact_ref = String(args.artifact_ref ?? "").trim();
+    if (!artifact_ref) {
+        return refusal("save_review exige une référence d'artefact localisable. Une review sans artefact " +
+            "rattaché n'est pas suivable — c'est un avis en l'air.");
+    }
+    const findings = Array.isArray(args.findings) ? args.findings : [];
+    const r = saveReview({
+        skill: String(args.skill ?? "review"),
+        artifact_ref,
+        delivery_mode: args.delivery_mode ? String(args.delivery_mode) : undefined,
+        verdict: args.verdict ? String(args.verdict) : undefined,
+        notes: args.notes ? String(args.notes) : undefined,
+        findings,
+    }, new Date());
+    return text(`Review enregistrée : ${r.id}\n` +
+        `Artefact : ${artifact_ref}\n` +
+        `Verdict : ${r.verdict ?? "—"} · Problèmes : ${sevCounts(findings)}\n` +
+        `Re-lance le skill plus tard, puis compare_reviews pour mesurer la régression.`);
+}
+function toolListReviews(args) {
+    const rows = listReviews({
+        artifact_ref: args.artifact_ref ? String(args.artifact_ref) : undefined,
+        skill: args.skill ? String(args.skill) : undefined,
+    }).slice(0, Math.max(1, Math.min(100, Number(args.limit ?? 20))));
+    if (rows.length === 0)
+        return text("Aucune review enregistrée.");
+    const body = rows
+        .map((r) => `• ${r.id}  [${r.skill}]  ${r.verdict ?? "—"}  (${sevCounts(r.findings)})\n  ${r.artifact_ref}`)
+        .join("\n");
+    return text(`${rows.length} review(s) :\n${body}`);
+}
+/**
+ * Le pont vers le compte.
+ *
+ * L'audit se produit ici, dans l'éditeur ; il doit réapparaître dans le cockpit
+ * du site. Ce handler ne connaît AUCUN secret fort : il porte un jeton
+ * d'appareil, révocable depuis le compte, et l'échange contre une écriture via
+ * l'Edge Function. Si le jeton fuit, on le révoque — rien d'autre n'est exposé.
+ */
+/**
+ * L'adresse de réception est la même pour tout le monde et ne change jamais :
+ * la demander à chaque utilisateur allongeait la commande de branchement d'une
+ * ligne illisible, pour une valeur qu'aucun d'eux ne choisit. Seul le jeton est
+ * personnel — c'est donc le seul réglage à fournir. La variable reste lisible
+ * pour pointer un environnement de test.
+ */
+const DEFAULT_INGEST_URL = "https://hbugvurcdmimhvvfdlos.supabase.co/functions/v1/ingest-audit";
+async function toolPushAudit(args) {
+    const token = process.env.DWAI_TOKEN?.trim();
+    const url = process.env.DWAI_INGEST_URL?.trim() || DEFAULT_INGEST_URL;
+    if (!token) {
+        return refusal("push_audit a besoin de DWAI_TOKEN dans l'environnement du serveur MCP. " +
+            "Génère un jeton dans ton compte (page Compte → « Connecter mon éditeur »), " +
+            "puis ajoute-le à la config de ton éditeur.");
+    }
+    const review = args.review_id
+        ? getReview(String(args.review_id))
+        : (listReviews()[0] ?? null);
+    if (!review) {
+        return refusal("Aucune review à envoyer. Lance d'abord un skill et enregistre le résultat avec save_review.");
+    }
+    // On n'envoie que le résumé utile au cockpit : ni preuve brute, ni contenu de
+    // fichier. Ce qui part est ce qui s'affiche.
+    const payload = {
+        token,
+        audit: {
+            product_ref: review.artifact_ref,
+            verdict: review.verdict ?? null,
+            scope: args.scope ? String(args.scope) : review.skill,
+            // L'outil source voyage à part du scope : le cockpit s'en sert pour ranger
+            // les constats par axe, sans avoir à interpréter une phrase libre.
+            tool: review.skill,
+            findings: review.findings.map((f) => ({
+                severity: f.severity ?? null,
+                summary: f.summary ?? null,
+                location: f.location ?? null,
+            })),
+        },
+    };
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        const body = (await res.json().catch(() => ({})));
+        if (!res.ok) {
+            return refusal(`L'envoi a été refusé (${res.status} ${String(body.error ?? "")}). ` +
+                (res.status === 401
+                    ? "Le jeton est inconnu ou révoqué : regénères-en un depuis ton compte."
+                    : "Vérifie DWAI_INGEST_URL."));
+        }
+        return text(`Audit envoyé sous ton compte.\n` +
+            `Review : ${review.id} [${review.skill}] ${review.verdict ?? "—"}\n` +
+            `Objet : ${review.artifact_ref}\n` +
+            `Constats : ${review.findings.length}\n` +
+            `Id côté compte : ${String(body.id ?? "—")}\n` +
+            `Il apparaît maintenant dans ton cockpit, sur n'importe quel appareil connecté.`);
+    }
+    catch (e) {
+        return refusal(`Impossible de joindre ${url} : ${e instanceof Error ? e.message : String(e)}. ` +
+            "Réseau filtré ? Essaie depuis un autre réseau.");
+    }
+}
+function toolCompare(args) {
+    let base = null;
+    let head = null;
+    if (args.review_base && args.review_head) {
+        base = getReview(String(args.review_base));
+        head = getReview(String(args.review_head));
+    }
+    else if (args.artifact_ref) {
+        const rows = listReviews({ artifact_ref: String(args.artifact_ref) });
+        if (rows.length >= 2) {
+            head = rows[0];
+            base = rows[1];
+        }
+    }
+    if (!base || !head) {
+        return refusal("Fournis review_base + review_head, ou un artifact_ref ayant au moins deux reviews.");
+    }
+    const d = compareReviews(base, head);
+    const block = (label, arr) => arr.length ? `\n${label} (${arr.length}) :\n${arr.map(renderFinding).join("\n")}` : `\n${label} : aucun`;
+    return text(`Régression — ${base.id} → ${head.id}\nArtefact : ${head.artifact_ref}` +
+        block("✓ Résolus", d.resolved) +
+        block("＋ Nouveaux", d.added) +
+        block("• Persistants", d.persisting));
+}
+// ─── Boucle d'état des gates (étape D, version locale) ───────────────────────
+function toolClearGate(args) {
+    const artifact_ref = String(args.artifact_ref ?? "").trim();
+    if (!artifact_ref) {
+        return refusal("clear_gate exige une référence d'artefact. Un gate qu'on ferme sans rien montrer est " +
+            "un mensonge qu'on se fait à soi-même — donne le lien, le chemin ou l'URL.");
+    }
+    const ch = resolveChapter(String(args.chapter ?? ""));
+    if (!ch)
+        return refusal(`Aucun chapitre trouvé pour « ${String(args.chapter ?? "")} ».`);
+    currentState = clearGate(currentState, ch.id, artifact_ref, new Date());
+    saveState(currentState);
+    const count = Object.keys(currentState.gates).length;
+    return text(`Gate franchi : ${ch.title}\n` +
+        `Critère : ${ch.gate?.criterion ?? "—"}\n` +
+        `Artefact : ${artifact_ref}\n` +
+        `Progression : ${count}/${chapterUnits.length} gate(s).`);
+}
+function toolReopenGate(args) {
+    const ch = resolveChapter(String(args.chapter ?? ""));
+    if (!ch)
+        return refusal(`Aucun chapitre trouvé pour « ${String(args.chapter ?? "")} ».`);
+    if (!currentState.gates[ch.id])
+        return text(`Le gate « ${ch.title} » n'était pas franchi.`);
+    currentState = reopenGate(currentState, ch.id);
+    saveState(currentState);
+    return text(`Gate rouvert : ${ch.title}.`);
+}
+function toolGateStatus(args) {
+    const clearedIds = Object.keys(currentState.gates);
+    const total = chapterUnits.length;
+    const recent = clearedIds
+        .map((id) => ({ id, unit: chapterUnits.find((u) => u.id === id), gate: currentState.gates[id] }))
+        .filter((x) => x.unit)
+        .sort((a, b) => b.gate.clearedAt.localeCompare(a.gate.clearedAt))
+        .slice(0, 5)
+        .map((x) => `   ✓ ${x.unit.title}\n     ${x.gate.artifactRef}`)
+        .join("\n");
+    const clearedSet = new Set(clearedIds);
+    const mode = effectiveMode(args);
+    const objective = String(args.objective ?? "");
+    const pool = objective
+        ? rankChapters(objective, mode, 12)
+        : chapterUnits.filter((u) => chapterMatchesMode(u, mode));
+    const next = pool
+        .filter((u) => !clearedSet.has(u.id))
+        .slice(0, 5)
+        .map((u) => `   ○ ${u.title}${u.gate ? ` — ${u.gate.artifact}` : ""}`)
+        .join("\n");
+    return text(`Gates : ${clearedIds.length}/${total} franchi(s).\n\n` +
+        `Derniers franchis :\n${recent || "   (aucun)"}\n\n` +
+        `Prochains${objective ? ` pour « ${objective} »` : ""} :\n${next || "   (rien à proposer)"}`);
+}
+// ─── Flow « audite mon vrai projet » (étape E) ───────────────────────────────
+function toolAuditProject(args) {
+    const ref = String(args.artifact_ref ?? "").trim();
+    if (!ref) {
+        return refusal("audit_project exige une référence d'artefact réel (lien Figma, dépôt, URL). " +
+            "Sans artefact, il n'y a rien à auditer — c'est le principe.");
+    }
+    const mode = effectiveMode(args);
+    const objective = String(args.objective ?? "");
+    const scope = String(args.scope ?? "");
+    const q = [objective, scope].filter(Boolean).join(" ") || ref;
+    const cleared = new Set(Object.keys(currentState.gates));
+    const pool = rankChapters(q, mode, 8);
+    const fresh = pool.filter((u) => !cleared.has(u.id)).slice(0, 5);
+    const doneNote = pool.length - pool.filter((u) => !cleared.has(u.id)).length;
+    const anchor = fresh.map((u) => `   • ${u.title} — ${u.gate?.criterion ?? "—"}\n     ${cite(u)}`).join("\n") ||
+        "   (précise l'objectif pour ancrer la revue dans le Handbook)";
+    const ctx = currentProfile
+        ? profileSummary(currentProfile) || "(profil chargé)"
+        : "profil non déclaré — set_profile pour contextualiser";
+    const step1 = skillByName.has("better-interface")
+        ? "Applique le skill `better-interface` (prompt /better-interface) sur cet artefact : sélectionne UNIQUEMENT les experts pertinents, agrège leurs diagnostics, arbitre les conflits. N'exécute pas tous les skills par défaut."
+        : "Sélectionne les skills pertinents, agrège leurs diagnostics, arbitre les conflits.";
+    return text(`FLOW « audite mon vrai projet »\n` +
+        `Artefact : ${ref}\n` +
+        `Contexte : ${ctx}\n` +
+        `Mode : ${mode ?? "non déterminé"}\n` +
+        `Périmètre : ${scope || objective || "(à cadrer avant de lancer)"}\n\n` +
+        `1. ORCHESTRE\n${step1}\n\n` +
+        `2. ANCRE DANS LE HANDBOOK\nConfronte chaque finding aux critères ci-dessous, et cite la source :\n${anchor}` +
+        (doneNote ? `\n   (${doneNote} gate(s) déjà franchi(s), écarté(s).)` : "") +
+        `\n\n3. TRACE — rien n'est « fait » tant que ce n'est pas tracé\n` +
+        `- Enregistre le résultat : save_review(skill:"better-interface", artifact_ref:"${ref}", verdict, findings:[…]).\n` +
+        `- Pour chaque gate dont le critère est atteint par l'artefact : clear_gate(chapter, artifact_ref:"${ref}").\n` +
+        `- Plus tard, re-lance puis compare_reviews pour mesurer la régression.`);
+}
+// ─── Banc d'éval des skills (clef de voûte) ──────────────────────────────────
+function toolListEvalCases(args) {
+    const skill = String(args.skill ?? "");
+    const cases = loadCases(skill);
+    if (cases.length === 0)
+        return text(`Aucun cas d'éval pour « ${skill} ».`);
+    const body = cases.map((c) => `• ${c.id}  [${c.kind}]${c.delivery_mode ? `  (${c.delivery_mode})` : ""}`).join("\n");
+    return text(`${cases.length} cas pour ${skill} :\n${body}\n\n` +
+        `get_eval_case <id> pour l'artefact (à l'aveugle), puis score_review.`);
+}
+function toolGetEvalCase(args) {
+    const c = getCase(String(args.case_id ?? ""));
+    if (!c)
+        return refusal(`Cas d'éval introuvable : ${String(args.case_id ?? "")}`);
+    // On ne révèle JAMAIS la golden : le run doit être aveugle.
+    return text(`Cas ${c.id} · skill ${c.skill}${c.delivery_mode ? ` · mode ${c.delivery_mode}` : ""}\n\n` +
+        `ARTEFACT :\n${c.artifact}\n\n` +
+        `Applique le skill ${c.skill} sur cet artefact (reste dans ton périmètre, refuse si l'artefact ` +
+        `est insuffisant), puis appelle score_review(case_id:"${c.id}", findings:[…], verdict, refused).`);
+}
+function toolScoreReview(args) {
+    const c = getCase(String(args.case_id ?? ""));
+    if (!c)
+        return refusal(`Cas d'éval introuvable : ${String(args.case_id ?? "")}`);
+    const cand = {
+        findings: Array.isArray(args.findings) ? args.findings : [],
+        verdict: args.verdict ? String(args.verdict) : undefined,
+        refused: typeof args.refused === "boolean" ? args.refused : undefined,
+    };
+    const s = scoreCase(c, cand, new Date());
+    saveScore(s);
+    const pct = (x) => `${Math.round(x * 100)}%`;
+    return text(`Cas ${s.case_id} [${s.kind}] — ${s.passed ? "PASSÉ ✓" : "ÉCHOUÉ ✗"}\n` +
+        `Détection : ${s.detected}/${s.expected}${s.expected ? ` (${pct(s.detection_rate)})` : " (rien à trouver)"}\n` +
+        (s.missed.length ? `Manqués : ${s.missed.join(" · ")}\n` : "") +
+        `Périmètre : ${s.scope_ok ? "respecté" : `VIOLÉ → ${s.forbidden_hits.join(" · ")}`}\n` +
+        `Refus attendu : ${(c.golden.should_refuse ?? false) ? "oui" : "non"} · obtenu : ${cand.refused ? "oui" : "non"} → ${s.refusal_ok ? "ok" : "KO"}\n` +
+        `Faux positifs (majeur+) : ${s.extra_significant} · notes hors-golden : ${s.extra_findings - s.extra_significant}\n` +
+        (c.golden.expected_verdict
+            ? `Verdict attendu / obtenu : ${c.golden.expected_verdict} / ${cand.verdict ?? "—"} — ${s.verdict_ok ? "✓" : "✗"}\n`
+            : "") +
+        `Résultat enregistré dans la scorecard.`);
+}
+function toolScorecard(args) {
+    const skill = String(args.skill ?? "");
+    const sc = scorecard(skill);
+    const pct = (x) => (x === null ? "—" : `${Math.round(x * 100)}%`);
+    return text(`${skill} — scorecard\n\n` +
+        `Cas testés : ${sc.cases_tested}/${sc.cases_total}\n` +
+        `Passés : ${sc.passed}/${sc.cases_tested}\n` +
+        `Détection critique : ${pct(sc.detection_rate)}\n` +
+        `Faux positifs : ${pct(sc.false_positive_rate)}\n` +
+        `Respect du périmètre : ${pct(sc.scope_adherence)}\n` +
+        `Justesse du refus : ${pct(sc.refusal_accuracy)}\n` +
+        `Dernière validation : ${sc.last_validated ?? "jamais"}`);
+}
+// ─── Vérification & décisions (étapes verify_fix / decision_record) ──────────
+function toolVerifyFix(args) {
+    const ref = String(args.artifact_ref ?? "").trim();
+    if (!ref) {
+        return refusal("verify_fix exige une référence d'artefact courant : sans regarder l'état actuel, on ne " +
+            "vérifie rien — on suppose.");
+    }
+    const results = Array.isArray(args.results)
+        ? args.results
+        : [];
+    if (results.length === 0) {
+        return refusal("verify_fix exige au moins un critère d'acceptation à vérifier.");
+    }
+    const met = results.filter((r) => r.met);
+    const failed = results.filter((r) => !r.met);
+    const metNoEvidence = met.filter((r) => !r.evidence || !String(r.evidence).trim());
+    const verdict = failed.length === 0 ? "corrigé" : met.length === 0 ? "non corrigé" : "partiel";
+    const status = verdict === "corrigé" ? "fixed" : verdict === "partiel" ? "partial" : "open";
+    let updated = "";
+    if (args.review_id != null && args.finding_index != null) {
+        const f = updateFindingStatus(String(args.review_id), Number(args.finding_index), status, ref);
+        updated = f
+            ? `\nStatut du finding mis à jour : ${status}.`
+            : `\n(finding non trouvé pour la mise à jour.)`;
+    }
+    return text(`Vérification — ${verdict.toUpperCase()}\n` +
+        `Artefact courant : ${ref}\n` +
+        (args.expected_fix ? `Correction attendue : ${String(args.expected_fix)}\n` : "") +
+        `Critères remplis : ${met.length}/${results.length}\n` +
+        (failed.length ? `Non remplis :\n${failed.map((r) => `   ✗ ${r.criterion}`).join("\n")}\n` : "") +
+        (metNoEvidence.length
+            ? `\n⚠ Déclarés remplis SANS preuve (à étayer, sinon c'est une supposition) :\n${metNoEvidence
+                .map((r) => `   ? ${r.criterion}`)
+                .join("\n")}\n`
+            : "") +
+        updated);
+}
+function toolGenerateDecision(args) {
+    const title = String(args.title ?? "").trim();
+    const decision = String(args.decision ?? "").trim();
+    if (!title || !decision) {
+        return refusal("generate_decision_record exige au moins un titre et une décision.");
+    }
+    const arr = (k) => Array.isArray(args[k]) ? args[k].map((x) => String(x)) : undefined;
+    const out = saveDecision({
+        title,
+        decision,
+        context: args.context ? String(args.context) : undefined,
+        evidence: arr("evidence"),
+        options: arr("options"),
+        accepted_risks: arr("accepted_risks"),
+        review_criteria: arr("review_criteria"),
+        sources: arr("sources"),
+        artifact_ref: args.artifact_ref ? String(args.artifact_ref) : undefined,
+    }, new Date());
+    return text(`Décision enregistrée : ${out.decision.id}\nFichier : ${out.path}\n\n${out.markdown}`);
+}
+// ─── Prochain gate, conscient du graphe (prérequis) ─────────────────────────
+function toolNextGate(args) {
+    const cleared = new Set(Object.keys(currentState.gates));
+    const mode = effectiveMode(args);
+    const objective = String(args.objective ?? "");
+    const prereqsMet = (id) => (REQUIRES[id] ?? []).every((p) => cleared.has(p));
+    const missing = (id) => (REQUIRES[id] ?? []).filter((p) => !cleared.has(p));
+    const titleOf = (id) => chapterById.get(id)?.title ?? id;
+    const pool = objective
+        ? rankChapters(objective, mode, 20)
+        : chapterUnits
+            .filter((u) => chapterMatchesMode(u, mode))
+            .sort((a, b) => (orderOf.get(a.uri) ?? 0) - (orderOf.get(b.uri) ?? 0));
+    const fresh = pool.filter((u) => !cleared.has(u.id));
+    const ready = fresh.filter((u) => prereqsMet(u.id)).slice(0, 3);
+    const blocked = fresh.filter((u) => !prereqsMet(u.id)).slice(0, 3);
+    if (ready.length === 0 && blocked.length === 0) {
+        return text(objective
+            ? `Rien de pertinent (et pas déjà franchi) pour « ${objective} ».`
+            : "Tous les gates pertinents sont franchis.");
+    }
+    const readyBlock = ready
+        .map((u, i) => {
+        const n = (REQUIRES[u.id] ?? []).length;
+        return (`${i === 0 ? "Prochain gate" : "Puis"} : ${u.title}\n` +
+            `   Pourquoi : ${n ? `prérequis franchis (${n})` : "aucun prérequis"} ; pas encore fait.\n` +
+            (u.gate ? `   Artefact attendu : ${u.gate.artifact}\n   Réussi quand : ${u.gate.criterion}` : ""));
+    })
+        .join("\n\n");
+    const blockedBlock = blocked.length
+        ? `\n\nBloqués (prérequis manquants) :\n` +
+            blocked.map((u) => `   ⊘ ${u.title} — manque : ${missing(u.id).map(titleOf).join(", ")}`).join("\n")
+        : "";
+    return text((ready.length ? readyBlock : "Aucun gate débloqué pour l'instant.") + blockedBlock);
+}
+// ─── Connecteur dépôt local (étape connecteurs) ─────────────────────────────
+function toolConnectRepo(args) {
+    const p = String(args.path ?? "").trim();
+    if (!p)
+        return refusal("connect_repo exige un chemin de dépôt local.");
+    const snap = readRepoSnapshot(p);
+    if ("error" in snap)
+        return refusal(snap.error);
+    const srcLine = Object.entries(snap.sources)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join(" · ");
+    const absent = Object.entries(snap.sources)
+        .filter(([, v]) => v === "absent")
+        .map(([k]) => k);
+    return text(`Dépôt : ${snap.name ?? p}\n` +
+        `Stack : ${snap.framework.join(", ") || "indéterminée"} · ${snap.dependencies} dépendances\n` +
+        `Composants : ${snap.components.count}` +
+        (snap.components.dir ? ` dans ${snap.components.dir}` : "") +
+        (snap.components.sample.length ? ` (${snap.components.sample.join(", ")}…)` : "") +
+        `\nSources : ${srcLine}` +
+        (absent.length ? `\n\nÀ connecter pour un audit complet : ${absent.join(", ")}.` : "") +
+        `\nLes sources « distant » (Figma, production) se lisent via leurs serveurs MCP dédiés, pas ici.`);
+}
+// ─── Serveur ─────────────────────────────────────────────────────────────────
+const server = new Server({ name: "designwithai-handbook", version: "0.1.0" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+// Les arguments communs à tous les prompts-skills : de quoi renseigner l'en-tête
+// d'invocation (« Artefact / Objectif / Source / Contraintes / Mode »).
+const PROMPT_ARGS = [
+    {
+        name: "artifact",
+        description: "L'artefact à auditer : lien, chemin de fichier, capture décrite ou périmètre.",
+        required: false,
+    },
+    { name: "objective", description: "Ce que la revue doit servir.", required: false },
+    {
+        name: "delivery_mode",
+        description: "ai-builder | classique | hybride.",
+        required: false,
+    },
+    {
+        name: "source_of_truth",
+        description: "Figma, code, Storybook, générateur IA, production…",
+        required: false,
+    },
+    {
+        name: "constraints",
+        description: "Contraintes à respecter (conserver X, ne pas modifier Y…).",
+        required: false,
+    },
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const args = (req.params.arguments ?? {});
+    switch (req.params.name) {
+        case "search_handbook":
+            return toolSearch(args);
+        case "recommend_workflow":
+            return toolRecommend(args);
+        case "review_artifact":
+            return toolReview(args);
+        case "build_action_plan":
+            return toolPlan(args);
+        case "set_profile":
+            return toolSetProfile(args);
+        case "save_review":
+            return toolSaveReview(args);
+        case "list_reviews":
+            return toolListReviews(args);
+        case "push_audit":
+            return toolPushAudit(args);
+        case "compare_reviews":
+            return toolCompare(args);
+        case "clear_gate":
+            return toolClearGate(args);
+        case "reopen_gate":
+            return toolReopenGate(args);
+        case "gate_status":
+            return toolGateStatus(args);
+        case "audit_project":
+            return toolAuditProject(args);
+        case "list_eval_cases":
+            return toolListEvalCases(args);
+        case "get_eval_case":
+            return toolGetEvalCase(args);
+        case "score_review":
+            return toolScoreReview(args);
+        case "skill_scorecard":
+            return toolScorecard(args);
+        case "verify_fix":
+            return toolVerifyFix(args);
+        case "generate_decision_record":
+            return toolGenerateDecision(args);
+        case "next_gate":
+            return toolNextGate(args);
+        case "connect_repo":
+            return toolConnectRepo(args);
+        default:
+            return refusal(`Outil inconnu : ${req.params.name}`);
+    }
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: handbook.units.map((u) => ({
+        uri: u.uri,
+        name: `${u.kind} · ${u.title}`,
+        description: u.summary || undefined,
+        mimeType: "text/plain",
+    })),
+}));
+server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+    const u = byUri.get(req.params.uri);
+    if (!u)
+        throw new Error(`Ressource introuvable : ${req.params.uri}`);
+    const header = `# ${u.title}\n${cite(u)}\n` +
+        (u.gate ? `\nGate — artefact : ${u.gate.artifact}\ncritère : ${u.gate.criterion}\n` : "") +
+        (u.delivery_modes?.length ? `Modes spécifiques : ${u.delivery_modes.join(", ")}\n` : "");
+    return {
+        contents: [{ uri: u.uri, mimeType: "text/plain", text: `${header}\n${u.text}` }],
+    };
+});
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: skills.map((s) => ({
+        name: s.name,
+        description: s.description,
+        arguments: PROMPT_ARGS,
+    })),
+}));
+server.setRequestHandler(GetPromptRequestSchema, async (req) => {
+    const skill = skillByName.get(req.params.name);
+    if (!skill)
+        throw new Error(`Prompt inconnu : ${req.params.name}`);
+    const a = (req.params.arguments ?? {});
+    const invocation = [
+        `/${skill.name}`,
+        a.artifact ? `Artefact: ${a.artifact}` : null,
+        a.objective ? `Objectif: ${a.objective}` : null,
+        a.source_of_truth ? `Source de vérité: ${a.source_of_truth}` : null,
+        a.constraints ? `Contraintes: ${a.constraints}` : null,
+        a.delivery_mode ? `Mode de delivery: ${a.delivery_mode}` : null,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    // Le prompt est SELF-CONTAINED : socle commun + corps du skill + invocation.
+    // Claude reçoit tout ce qu'il faut pour appliquer le skill, sans lire de fichier.
+    const text = `Tu incarnes le skill **${skill.name}**${skill.role ? ` (${skill.role})` : ""}. ` +
+        `Applique-le strictement : reste dans ton périmètre, exige des preuves, donne un ` +
+        `critère d'acceptation par recommandation, et ne modifie rien sans demande explicite.\n\n` +
+        `# Socle commun\n\n${sharedContract}\n\n` +
+        `# Skill\n\n${skill.body}\n\n` +
+        `# Invocation\n\n` +
+        (invocation ||
+            "(Aucun argument fourni — demande l'artefact et l'objectif avant d'auditer.)");
+    return {
+        description: skill.description,
+        messages: [{ role: "user", content: { type: "text", text } }],
+    };
+});
+await server.connect(new StdioServerTransport());
+process.stderr.write("[designwithai-mcp] prêt (stdio).\n");