@hegemonart/get-design-done 1.59.5 → 1.59.7

package/docs/i18n/README.fr.md

@@ -4,9 +4,11 @@
 
 [English](../../README.md) · [简体中文](README.zh-CN.md) · [日本語](README.ja.md) · [한국어](README.ko.md) · **Français** · [Italiano](README.it.md) · [Deutsch](README.de.md)
 
-**Un pipeline de qualité design pour agents de code IA : brief → exploration → plan → implémentation → vérification.**
+> Remarque : cette traduction peut être en retard sur la version anglaise. La version de référence est [README.md](../../README.md) (translation may lag behind English; see README.md for the canonical version).
 
-**Get Design Done garde l'UI générée par IA liée à votre brief, votre design system, vos références et vos quality gates. Fonctionne avec Claude Code, OpenCode, Gemini CLI, Kilo, Codex, Copilot, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy et Cline.**
+**Un pipeline de qualité design pour agents de code IA : brief -> exploration -> plan -> design -> vérification.**
+
+**Get Design Done garde l'UI générée par IA liée à votre brief, votre design system, votre connaissance design locale et vos quality gates. Conçu pour Claude Code, et s'installe sur Codex, Cursor, Gemini, OpenCode, Copilot, Windsurf, et plus encore.**
 
 [![npm version](https://img.shields.io/npm/v/@hegemonart/get-design-done?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/@hegemonart/get-design-done)
 [![npm downloads](https://img.shields.io/npm/dm/@hegemonart/get-design-done?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/@hegemonart/get-design-done)
@@ -15,610 +17,313 @@
 [![Node](https://img.shields.io/badge/node-22%20%7C%2024-339933?style=for-the-badge&logo=node.js&logoColor=white)](https://nodejs.org/)
 [![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)](LICENSE)
 
-<br>
-
 ```bash
 npx @hegemonart/get-design-done@latest
 ```
 
 **Fonctionne sur macOS, Linux et Windows.**
 
-<br>
-
-*« Les agents de code IA livrent l'UI vite. Get Design Done s'assure qu'ils livrent du design. »*
-
-<br>
-
-[Pourquoi je l'ai construit](#pourquoi-je-lai-construit) · [Comment ça marche](#comment-ça-marche) · [Commandes](#commandes) · [Connexions](#connexions) · [Pourquoi ça marche](#pourquoi-ça-marche)
+[Installation](#installation) · [Démarrage rapide](#démarrage-rapide) · [Cas d'usage](#cas-dusage) · [Comment ça marche](#comment-ça-marche) · [Commandes](#commandes) · [Connexions](#connexions) · [Sécurité](#sécurité-et-confidentialité)
 
 </div>
 
 ---
 
-> [!IMPORTANT]
-> ### Vous avez déjà un bundle Claude Design ?
->
-> Si vous avez exporté un design depuis [claude.ai/design](https://claude.ai/design), vous pouvez sauter entièrement les étapes 1 à 3 :
->
-> ```
-> /gdd:handoff ./my-design.html
-> ```
->
-> Parse les propriétés CSS personnalisées du bundle en décisions de design D-XX, exécute la passe de vérification avec scoring Handoff Faithfulness et écrit éventuellement le statut d'implémentation dans Figma.
-
----
-
-## Pourquoi je l'ai construit
-
-Je suis un designer qui livre avec des agents de code IA. Le workflow côté code est mature : specs, tâches, tests, commits, boucles de review. Le workflow côté design ne l'était pas.
-
-Ce que j'ai rencontré sans cesse : l'agent pouvait générer un écran qui semblait bon isolément, mais le travail restait *déconnecté*. Les tokens ne correspondaient pas au système existant. Les ratios de contraste glissaient sous WCAG. La hiérarchie était réinventée par écran. Les vieux anti-patterns entraient dans de nouveaux composants. Et comme rien ne vérifiait la sortie par rapport au brief original, les problèmes apparaissaient tard, en PR review ou après le handoff.
-
-Alors j'ai construit Get Design Done : un pipeline de design qui donne aux agents de code IA la même structure que les développeurs attendent déjà des workflows d'ingénierie. Il capture le brief, cartographie le design system existant, ancre les décisions dans des références, décompose le travail en tâches atomiques, exécute ces tâches et vérifie le résultat avant l'expédition.
-
-En coulisses : 37 agents spécialisés, un intel store interrogeable, du routage de modèle par tier, 12 connexions d'outils optionnelles, des commits atomiques et une couche adaptative no-regret qui apprend des résultats solidify-with-rollback. Au quotidien, vous utilisez quelques commandes `/gdd:*` qui gardent le travail design cohérent.
-
-— **Hegemon**
-
----
-
-Le design généré par IA a le même mode d'échec que le code généré par IA : vous décrivez ce que vous voulez, obtenez quelque chose de plausible, puis le tout s'effondre à l'échelle parce qu'aucun système ne reliait la sortie au brief.
+## Ce que c'est
 
-Get Design Done est la couche d'ingénierie de contexte pour le travail de design. Il transforme « améliore cette UI » en cycle traçable : brief → inventaire → références → plan → implémentation → vérification.
+Get Design Done aide les agents de code IA à livrer une UI qui a sa place dans votre produit.
 
----
+Il transforme des demandes vagues comme « améliore cet écran » en un workflow design traçable : brief, exploration, plan, design, vérification.
 
-## Ce que vous obtenez
+Au lieu de demander à un agent d'improviser sur le seul bon goût, GDD lui donne un processus structuré, une connaissance design locale, une mémoire spécifique au projet, des connexions optionnelles aux outils de design, et une vérification avant que le travail ne soit livré.
 
-- **Travail design ancré dans le brief** — chaque cycle commence par le problème, l'audience, les contraintes, les critères de réussite et les must-haves.
-- **Extraction du design system** — GDD inventorie tokens, typographie, espacements, composants, motion, accessibilité, dark mode et dette design avant de planifier les changements.
-- **Décisions appuyées par des références** — les agents utilisent des références design intégrées ainsi que les connexions optionnelles Figma, Refero, Pinterest, Storybook, Chromatic, Preview, Claude Design, paper.design, pencil.dev, Graphify, 21st.dev Magic et Magic Patterns.
-- **Exécution atomique** — les tâches design sont décomposées par dépendance, exécutées en vagues sûres et commitées indépendamment.
-- **Vérification avant livraison** — les audits vérifient l'adéquation au brief, l'intégration des tokens, le contraste WCAG, la conformité des composants, la cohérence de la motion, l'architecture dark-mode et les anti-patterns design.
-- **Rollback en cas d'échec de validation** — solidify-with-rollback valide chaque tâche avant de la conserver ; le travail en échec est automatiquement revert.
+## Pourquoi ça existe
 
----
-
-## Pour qui est-ce
-
-GDD est fait pour les ingénieurs, designers, design engineers, fondateurs et builders produit qui livrent de l'UI avec des agents de code IA et veulent un résultat qui tienne au-delà de la première capture d'écran.
+Les agents IA sont rapides pour produire de l'UI. Le difficile, c'est de rendre cette UI cohérente.
 
-Utilisez-le si vous voulez que les tokens correspondent, que le contraste passe WCAG, que la motion reste cohérente, que les composants suivent votre système et que l'implémentation finale corresponde encore à votre demande.
+Sans workflow design, les interfaces générées dérivent :
 
-Vous n'avez pas besoin d'être designer. Le pipeline apporte la discipline design au workflow agentique : il extrait le contexte, ne pose que les questions manquantes, ancre le travail dans des références et attrape les problèmes que l'on découvre généralement trop tard.
+- les couleurs et les espacements cessent de correspondre au système
+- les composants sont réinventés
+- le contraste et l'accessibilité régressent
+- la hiérarchie change d'un écran à l'autre
+- l'implémentation ne correspond plus au brief initial
 
-### Points forts v1.24.0 — Installeur multi-runtime
+GDD ajoute la discipline design manquante autour des workflows de code IA. Il capture le problème, cartographie le design system actuel, planifie des changements cadrés, les exécute par étapes atomiques, et vérifie le résultat par rapport au brief, aux tokens, à l'accessibilité et aux rubriques de qualité design.
 
-- **Multi-sélection interactive `@clack/prompts`** — `npx @hegemonart/get-design-done` sans flag ouvre maintenant une UI de cases à cocher soignée pour les 14 runtimes supportés (Claude Code, OpenCode, Gemini CLI, Kilo, Codex, Copilot, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline) plus une radio Global / Local.
-- **Idempotent + sûr pour AGENTS.md externes** — relancer l'installeur ne duplique jamais d'entrées et n'écrase jamais les instructions spécifiques au runtime que vous avez ajoutées. Étape de confirmation avant toute écriture de fichier.
-- **Surface CI scriptée préservée** — chaque flag existant (`--claude`, `--cursor`, `--all`, `--global`, `--local`, `--uninstall`, `--config-dir`) continue de fonctionner sans changement. Le mode interactif s'active uniquement si aucun flag de runtime n'est passé.
-- **Désinstallation multi-sélection** — `--uninstall` sans flag de runtime entre aussi en multi-sélection interactive pour choisir de quels runtimes désinstaller.
+En coulisses : 64 agents spécialisés, un intel store interrogeable, du routage de modèle par tier, et 39 connexions d'outils optionnelles. Au quotidien, vous utilisez une poignée de commandes `/gdd:*`.
 
-### Versions précédentes
+## Installation
 
-- **v1.23.5** — Couche adaptative No-Regret (bandit Thompson sampling + ensemble AdaNormalHedge + reranking MMR ; viable en mono-utilisateur via bootstrap par a priori informé, sans télémétrie partagée opt-in).
-- **v1.23.0** — Primitives de domaine SDK (porte solidify-with-rollback, contrats de sortie JSON, auto-cristallisation des motifs `Touches:`).
-- **v1.22.0** — Observabilité SDK (~24 types d'événements typés, trajectoire par tool-call, chaîne d'événements append-only, scrubber de secrets).
-- **v1.21.0** — SDK headless (CLI `gdd-sdk` exécute le pipeline complet sans Claude Code, researchers parallèles, MCP cross-harness).
-- **v1.20.0** — Fondation SDK (primitives de résilience, `STATE.md` sécurisé par lockfile, serveur MCP `gdd-state` avec 11 outils typés, fondation TypeScript).
-
-Notes de version complètes dans [CHANGELOG.md](CHANGELOG.md).
-
----
-
-<p align="center">
-  <strong>Supported by</strong>
-</p>
-
-<div align="center">
-  <a href="https://www.humbleteam.com/" aria-label="Humbleteam">
-    <img src="docs/assets/sponsors/humbleteam.svg" alt="Humbleteam logo" width="180">
-  </a>
-  <br>
-  <sub>Product design partner for ambitious startups and AI products.</sub>
-</div>
-
----
-
-## Démarrage
+### npm
 
 ```bash
 npx @hegemonart/get-design-done@latest
 ```
 
-L'installeur vous invite à choisir :
-1. **Runtime** — Claude Code, OpenCode, Gemini, Kilo, Codex, Copilot, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline ou tous (multi-sélection interactive)
-2. **Emplacement** — Global (tous les projets) ou Local (projet actuel uniquement)
-
-Vérifier avec :
+### Claude Code
 
+```bash
+/plugin marketplace add hegemonart/get-design-done
+/plugin install get-design-done@get-design-done
+/reload-plugins
 ```
-/gdd:help
-```
-
-> [!TIP]
-> Lancez Claude Code avec `--dangerously-skip-permissions` pour une expérience automatisée sans friction. GDD est conçu pour une exécution multi-étapes autonome.
-
-### Rester à jour
 
-GDD livre souvent. Mettez à jour en relançant l'installeur (idempotent) :
+### Codex
 
 ```bash
-npx @hegemonart/get-design-done@latest
+codex plugin marketplace add hegemonart/get-design-done
 ```
 
-Ou depuis Claude Code :
-
-```
-/gdd:update
-```
+### agentskills.io
 
-`/gdd:update` prévisualise le changelog avant d'appliquer. Les modifications locales sous `reference/` sont préservées — si une mise à jour structurelle nécessite un re-stitching, exécutez `/gdd:reapply-patches`.
+Parcourez et installez Get Design Done depuis le registre de skills [agentskills.io](https://agentskills.io).
 
-<details>
-<summary><strong>Installation non-interactive (Docker, CI, scripts)</strong></summary>
+### Installeur de runtime direct
 
 ```bash
+# Claude Code
 npx @hegemonart/get-design-done --claude --global
 npx @hegemonart/get-design-done --claude --local
-npx @hegemonart/get-design-done --opencode --global
-npx @hegemonart/get-design-done --gemini --global
-npx @hegemonart/get-design-done --kilo --global
+
+# Autres runtimes
 npx @hegemonart/get-design-done --codex --global
-npx @hegemonart/get-design-done --copilot --global
 npx @hegemonart/get-design-done --cursor --global
-npx @hegemonart/get-design-done --windsurf --global
-npx @hegemonart/get-design-done --antigravity --global
-npx @hegemonart/get-design-done --augment --global
-npx @hegemonart/get-design-done --trae --global
-npx @hegemonart/get-design-done --qwen --global
-npx @hegemonart/get-design-done --codebuddy --global
-npx @hegemonart/get-design-done --cline --global
-
-# Tous les runtimes
+npx @hegemonart/get-design-done --gemini --global
+
+# Installation multi-runtime
 npx @hegemonart/get-design-done --all --global
 
-# Dry run
+# Aperçu sans écriture
 npx @hegemonart/get-design-done --dry-run
-
-# Répertoire de config personnalisé
-CLAUDE_CONFIG_DIR=/workspace/.claude npx @hegemonart/get-design-done
 ```
 
-</details>
+## Démarrage rapide
 
-<details>
-<summary><strong>Alternative : Claude Code CLI</strong></summary>
+Lancez une première passe légère :
 
 ```bash
-claude plugin marketplace add hegemonart/get-design-done
-claude plugin install get-design-done@get-design-done
+/gdd:start
 ```
 
-</details>
-
-### Tier-2 Distribution Channels (v1.28.8+)
-
-En complément des chemins d'installation par dépôt de fichiers de la Phase 28.7 ci-dessus (par défaut, toujours fonctionnels), la v1.28.8 ajoute trois nouveaux canaux de distribution Tier-2 :
-
-- **Portabilité multi-runtime via agentskills.io.** Nos `skills/` sont conformes à la spécification [agentskills.io](https://agentskills.io). Les runtimes revendiquant la compatibilité agentskills.io (Codex, Kilo, Augment, Hermes, Qwen) peuvent consommer nos skills directement.
-- **Cursor Marketplace.** Installation via l'interface marketplace de Cursor ; publication en attente de la revue de l'équipe Cursor — voir `docs/cursor-marketplace-field-test.md`.
-- **Codex Plugin.** Installation via l'ajout de plugin par URL GitHub de Codex :
-
-  ```bash
-  codex plugin marketplace add hegemonart/get-design-done
-  ```
-
-Pour les détails complets, voir [README.md](README.md) (anglais, autoritatif).
-
-### Télémétrie Capability-Gap + Auto-Authoring (v1.29.0+)
-
-La boucle réflectrice suit désormais les signaux "lookup de capacité échoué" comme télémétrie de première classe et — une fois que suffisamment de lacunes récurrentes émergent — peut esquisser de nouveaux agents ou skills comme propositions à votre review.
+Ou exécutez le cycle de design complet :
 
-**Phase 0 — télémétrie (livrée immédiatement).** Trois points de lookup-fail émettent désormais des événements typés `capability_gap` : chemins `skills/fast` sans match, chemins `gdd-router` à intent non-matché, et le pattern-detection pass du reflector. Affichage via `gdd-events --type capability_gap`.
-
-**Phase 1 — auto-authoring (opt-in une fois les données franchissant le seuil).** Lorsque K=3 clusters stables émergent sur M=10 cycles de réflexion, `/gdd:apply-reflections` vous propose une seule fois d'activer la Phase 1. Le reflector esquisse alors des artefacts incubateur sous `.design/reflections/incubator/<slug>/` avec frontmatter conforme Phase 28.5. Quatre actions : `accept` / `reject` / `defer` / `edit`. Strictement proposition-only — `/gdd:apply-reflections` reste l'unique gate humain (Phase 11 SC-8).
-
-Scope-guard : l'authoring est limité à `agents/` et `skills/` — jamais runtimes / transports / hooks. Pour les détails complets, voir [README.md](README.md) (anglais, autoritatif).
-
-
-## Comment ça marche
-
-> **Vous démarrez sur un codebase existant ?** Exécutez `/gdd:map` d'abord. Il dispatche 5 mappers spécialistes en parallèle (tokens, components, visual hierarchy, a11y, motion) et écrit du JSON structuré dans `.design/map/`.
-
-### 1. Brief
-
-```
+```bash
 /gdd:brief
-```
-
-Capture le problème de design avant tout scan ou exploration. Le skill interview via `AskUserQuestion`, une question à la fois — uniquement pour les sections sans réponse : problème, audience, contraintes, métriques de succès, scope.
-
-**Crée :** `.design/BRIEF.md`
-
----
-
-### 2. Explore
-
-```
 /gdd:explore
-```
-
-Inventorie le design system du codebase actuel — couleurs, typographie, espacement, composants, motion, a11y, dark-mode. Cinq mappers parallèles + un entretien `design-discussant` produisent trois artefacts. Les sondes de connexion détectent la disponibilité de 12 outils externes.
-
-**Crée :** `.design/DESIGN.md`, `.design/DESIGN-DEBT.md`, `.design/DESIGN-CONTEXT.md`, `.design/map/{tokens,components,a11y,motion,visual-hierarchy}.{md,json}`
-
----
-
-### 3. Plan
-
-```
 /gdd:plan
+/gdd:design
+/gdd:verify
 ```
 
-Décompose la sortie d'Explore en tâches de design atomiques, coordonnées par vagues, avec analyse des dépendances. Chaque tâche porte des chemins `Touches:` explicites, des tags de sécurité parallèle et des critères d'acceptation. `design-planner` (opus) rédige ; `design-plan-checker` (haiku) vérifie avant exécution.
-
-**Crée :** `.design/DESIGN-PLAN.md`
-
----
-
-### 4. Design
+Pour un routage en langage naturel :
 
-```
-/gdd:design
+```bash
+/gdd:do improve the checkout page hierarchy, spacing, and empty states
 ```
 
-Exécute les tâches dans l'ordre des vagues. Chaque tâche obtient un agent `design-executor` dédié avec un nouveau contexte de 200k, un commit git atomique et une gestion automatique des déviations selon les règles de contexte. Les tâches sûres en parallèle s'exécutent dans des worktrees.
+## Cas d'usage
 
-**Solidify-with-rollback** (v1.23.0) — chaque tâche valide (typecheck + build + test ciblé) avant de verrouiller. Échec de validation → revert via `git stash`.
+### Améliorer un écran existant
 
-**Crée :** un `.design/tasks/task-NN.md` par tâche, un commit git atomique par tâche
+Utilisez GDD quand un écran fonctionne techniquement mais semble visuellement incohérent, peu clair ou sous-conçu.
 
-```
-┌────────────────────────────────────────────────────────────────────┐
-│  EXÉCUTION PAR VAGUES                                              │
-├────────────────────────────────────────────────────────────────────┤
-│                                                                    │
-│  WAVE 1 (parallèle)         WAVE 2 (parallèle)        WAVE 3       │
-│  ┌─────────┐ ┌─────────┐    ┌─────────┐ ┌─────────┐    ┌─────────┐ │
-│  │ Task 01 │ │ Task 02 │ →  │ Task 03 │ │ Task 04 │ →  │ Task 05 │ │
-│  └─────────┘ └─────────┘    └─────────┘ └─────────┘    └─────────┘ │
-│       │           │              ↑           ↑              ↑      │
-│       └───────────┴──────────────┴───────────┴──────────────┘      │
-│              Touches: chemins pilotent l'analyse de dépendances    │
-│                                                                    │
-└────────────────────────────────────────────────────────────────────┘
+```bash
+/gdd:do improve the settings page layout and component hierarchy
 ```
 
----
+### Ramener la sortie IA vers le design system
 
-### 5. Verify
+Utilisez-le quand un agent a généré une UI qui paraît plausible mais ne correspond pas à vos tokens, espacements, états ou composants.
 
-```
+```bash
 /gdd:verify
 ```
 
-Vérifie par rapport au brief — must-haves, heuristiques NN/g, rubrique d'audit, intégration de tokens. Trois agents s'exécutent séquentiellement : `design-auditor` (score 6 piliers 1–4), `design-verifier` (rétro-objectif), `design-integration-checker` (greppe les décisions D-XX dans le code). Aux échecs, produit une liste de gaps structurée et entre dans une boucle verify→fix via `design-fixer`.
+### Auditer avant l'expédition
 
-**Crée :** `.design/DESIGN-VERIFICATION.md`, commits de fix si problèmes trouvés
+Lancez la vérification avant une PR, une release ou un handoff design.
 
----
+```bash
+/gdd:audit
+```
 
-### 6. Ship → Reflect → Cycle suivant
+### Corriger le dark mode
 
-```
-/gdd:ship                    # Génère une PR branche propre (filtre les commits .design/)
-/gdd:reflect                 # design-reflector lit télémétrie + apprentissages
-/gdd:apply-reflections       # Examiner et appliquer sélectivement les propositions
-/gdd:complete-cycle          # Archive les artefacts du cycle + écrit EXPERIENCE.md
-/gdd:new-cycle               # Ouvre un nouveau cycle de design
+```bash
+/gdd:darkmode
 ```
 
-Ou routage automatique :
+### Importer un handoff design
 
+```bash
+/gdd:handoff ./my-design.html
 ```
-/gdd:next                    # Auto-détecte l'état et exécute la prochaine étape
-```
-
-Chaque cycle obtient un brief, un scan, un plan, une exécution, une vérification et un `EXPERIENCE.md` par cycle (~100–200 lignes : Objectif / Décisions prises / Apprentissages gradués / Ce qui est mort / Passation au cycle suivant) qui devient la source la plus prioritaire pour le hook decision-injector.
 
----
+Ceci parse un bundle Claude Design, extrait les propriétés CSS personnalisées en décisions de design, et exécute les vérifications de fidélité du handoff.
 
-### Mode Fast
+### Faire une petite correction ciblée
 
-```
-/gdd:fast "<task>"
+```bash
+/gdd:fast "fix contrast in pricing cards"
 ```
 
-Pour les corrections triviales d'un seul fichier qui n'ont pas besoin du pipeline complet. Saute le routeur, le cache-manager et la télémétrie. Mêmes garanties de commit atomique.
+## Ce qui le rend différent
 
-```
-/gdd:quick
-```
+### Connaissance design locale
 
-Pour les tâches ad-hoc qui nécessitent les garanties GDD mais sautent les portes optionnelles (pas de phase-researcher, pas d'analyste d'hypothèses, pas d'integration-checker). Plus rapide que le pipeline complet ; plus sûr que `/gdd:fast`.
+GDD est livré avec une bibliothèque de référence locale étendue pour le travail de design. Les agents peuvent l'utiliser sans dépendre d'une recherche web en direct pour le jugement design de base.
 
----
+Elle couvre l'accessibilité, WCAG, la typographie, les espacements, les grilles, la couleur, le contraste, les surfaces, la motion, l'UX writing, les formulaires, les états vides, la hiérarchie visuelle, le dark mode, le comportement responsive, l'i18n, les méthodes de recherche, le scoring d'audit et les anti-patterns design.
 
-## Pourquoi ça marche
+L'agent ne part pas d'un prompt vierge. Il dispose d'un vocabulaire design partagé et de standards concrets qu'il peut appliquer pendant le planning, l'implémentation et la vérification.
 
-### Ingénierie de contexte
+Carte complète : [docs/KNOWLEDGE-BASE.md](docs/KNOWLEDGE-BASE.md)
 
-Les CLI de codage IA sont puissants **si** vous leur donnez du contexte. La plupart des gens ne le font pas.
+### Mémoire spécifique au projet
 
-GDD le gère pour vous :
+GDD crée un espace de travail `.design/` qui ancre chaque cycle :
 
-| Fichier | Rôle |
-|---------|------|
-| `.design/BRIEF.md` | Le problème, l'audience, les métriques de succès du cycle |
-| `.design/DESIGN.md` | Snapshot du design system actuel (tokens, composants, hiérarchie) |
-| `.design/DESIGN-CONTEXT.md` | Décisions D-XX, réponses d'entretien, contraintes amont/aval |
-| `.design/DESIGN-PLAN.md` | Tâches atomiques, chorégraphie de vagues, dépendances |
-| `.design/DESIGN-VERIFICATION.md` | Résultat de vérification, liste de gaps, score Handoff Faithfulness |
-| `.design/intel/` | Couche de connaissances interrogeable |
-| `.design/archive/cycle-N/EXPERIENCE.md` | Rétrospective par cycle, mémoire inter-cycles |
-| `.design/telemetry/events.jsonl` | Flux d'événements typés à travers les étapes |
-| `.design/telemetry/posterior.json` | Postérieur du bandit (quand `adaptive_mode != static`) |
-
-Limites de taille là où la qualité de Claude se dégrade. Restez dessous, obtenez de la cohérence.
+| Artefact | Rôle |
+| --- | --- |
+| `.design/BRIEF.md` | Problème, audience, scope, métriques de succès |
+| `.design/DESIGN.md` | Snapshot du design system actuel |
+| `.design/DESIGN-CONTEXT.md` | Décisions, contraintes, références |
+| `.design/DESIGN-PLAN.md` | Plan d'implémentation atomique |
+| `.design/DESIGN-VERIFICATION.md` | Audit final et rapport de gaps |
+| `.design/intel/` | Connaissance projet interrogeable : tokens, composants, relations, décisions |
+| `.design/archive/` | Historique des cycles terminés et apprentissages |
 
-### 37 agents spécialisés
+Plus vous l'utilisez longtemps, moins l'agent a à redécouvrir.
 
-Chaque étape est un orchestrateur léger qui spawn des agents spécialisés.
+### Vérification avant l'expédition
 
-| Étape | Orchestrateur | Agents |
-|-------|---------------|--------|
-| Brief | entretien une question | (pas de sous-agents) |
-| Explore | spawn 5 mappers + discussant | 5 mappers parallèles, design-discussant, research-synthesizer |
-| Plan | spawn researcher + planner + checker | design-phase-researcher (optionnel), design-planner (opus), design-plan-checker (haiku) |
-| Design | coordination de vagues + isolation worktree | design-executor par tâche, design-fixer en cas d'échec solidify |
-| Verify | spawn auditor + verifier + checker | design-auditor, design-verifier, design-integration-checker |
-| Reflect | lit télémétrie + apprentissages | design-reflector (opus), design-authority-watcher, design-update-checker |
+GDD ne s'arrête pas quand l'UI « a l'air finie ».
 
-### 12 connexions d'outils
+L'étape de vérification contrôle si le résultat correspond toujours :
 
-Toutes optionnelles — le pipeline dégrade gracieusement quand une connexion est indisponible :
+- au brief initial
+- aux tokens du design system
+- aux seuils d'accessibilité
+- aux conventions de composants
+- à la hiérarchie visuelle
+- aux règles de motion et d'interaction
+- aux décisions de design enregistrées
 
-- **Figma** (lecture + écriture + Code Connect)
-- **Refero** — recherche de références de design
-- **Pinterest** — ancrage de références visuelles
-- **Claude Design** — import de bundle de handoff
-- **Storybook** — recherche de spécifications de composants
-- **Chromatic** — diff de baseline de régression visuelle
-- **Preview** — captures d'écran runtime Playwright + Claude Preview MCP
-- **paper.design** — lecture/écriture canvas MCP
-- **pencil.dev** — fichiers de spécification `.pen` suivis par git
-- **Graphify** — export de graphe de connaissances
-- **21st.dev Magic** — recherche de précédents avant builds greenfield
-- **Magic Patterns** — génération de composants DS-aware
+Quand des gaps apparaissent, GDD produit une liste de corrections structurée au lieu de laisser la review au feeling.
 
-### Références de design intégrées
+### Tests de comportement des skills
 
-Le plugin livre **18+ fichiers de référence** — NN/g 10, design émotionnel de Don Norman, 10 principes de Dieter Rams, 12 principes de Disney (motion), lentille d'authoring de composants Sonner / Emil Kowalski, Peak-End, Loss Aversion, Cognitive Load, Aesthetic-Usability, Doherty, Flow, 35 spécifications de composants, gestalt, hiérarchie visuelle, brand voice, 161 palettes par industrie, 67 esthétiques d'UI, 12 easings de motion, 8 familles de transition, WCAG 2.1 AA, plateformes (iOS/Android/web/visionOS/watchOS), RTL/CJK, patterns de formulaire, catalogue d'anti-patterns.
+Les propres skills de GDD sont éprouvés sous des scénarios de pression adverse (pression temporelle, coût irrécupérable, autorité, minimisation du scope) pour confirmer qu'ils tiennent leur discipline plutôt que de céder. Voir [CONTRIBUTING.md](CONTRIBUTING.md) pour savoir comment ajouter un scénario de pression.
 
-### Commits git atomiques
+## Comment ça marche
 
+```text
+Brief -> Explore -> Plan -> Design -> Verify -> Ship
 ```
-abc123f docs(08-02): complete user-card token plan
-def456g feat(08-02): unify card surface tokens with --color-bg-elevated
-hij789k feat(08-02): replace inline padding with --space-* scale
-lmn012o test(08-02): assert card.spec passes WCAG contrast 4.5:1
-```
-
-Git bisect trouve la tâche défaillante exacte. Chaque tâche est revertable indépendamment. Solidify-with-rollback ajoute une porte de validation au niveau de la tâche, donc une tâche 3 cassée ne corrompt jamais les tâches 4–10 avant que verify ne s'exécute.
-
-### Boucle d'auto-amélioration
 
-Après chaque cycle, `design-reflector` (opus) lit `events.jsonl`, `agent-metrics.json`, `learnings/`, puis propose des diffs — surcharges de niveau, règles de parallélisation, ajouts de références, mises à jour de frontmatter. `/gdd:apply-reflections` montre le diff et demande avant d'appliquer.
+| Étape | Commande | Sortie |
+| --- | --- | --- |
+| Brief | `/gdd:brief` | Capture le problème de design |
+| Explore | `/gdd:explore` | Cartographie le système UI, la dette, les tokens, les composants |
+| Plan | `/gdd:plan` | Crée des tâches design atomiques |
+| Design | `/gdd:design` | Exécute les tâches avec validation |
+| Verify | `/gdd:verify` | Audite le résultat final |
 
-La **couche adaptative No-Regret** (v1.23.5) ajoute par-dessus un bandit Thompson sampling + ensemble AdaNormalHedge + reranking MMR, viable en mono-utilisateur via bootstrap par a priori informé.
+### Sorties principales
 
-### Gouvernance des coûts
-
-- **Skill `gdd-router`** — routage déterministe intent → fast / quick / full, sans appel de modèle.
-- **`gdd-cache-manager`** — cache explicite Layer-B, hash d'entrée SHA-256, conscience TTL 5 min.
-- **Hook PreToolUse `budget-enforcer`** — applique surcharges de niveau, plafonds durs, portes de spawn paresseuses depuis `.design/budget.json`.
-- **Télémétrie de coût par spawn** — les lignes `.design/telemetry/costs.jsonl` alimentent les recommandations basées sur règles de `/gdd:optimize`.
-
-Vise une réduction de coût de 50–70% par tâche sans régression de qualité.
-
----
+| Fichier | Ce qu'il fait |
+| --- | --- |
+| `.design/BRIEF.md` | Le problème, l'audience, les métriques de succès du cycle |
+| `.design/DESIGN.md` | Snapshot du design system actuel |
+| `.design/DESIGN-CONTEXT.md` | Décisions et contraintes de design |
+| `.design/DESIGN-PLAN.md` | Tâches atomiques, vagues, dépendances |
+| `.design/DESIGN-VERIFICATION.md` | Résultat de vérification et liste de gaps |
+| `.design/intel/` | Couche de connaissances interrogeable pour ce projet |
 
 ## Commandes
 
-### Pipeline principal
-
-| Commande | Rôle |
-|----------|------|
-| `/gdd:brief` | Étape 1 — capturer le brief de design |
-| `/gdd:explore` | Étape 2 — inventaire codebase + entretien |
-| `/gdd:plan` | Étape 3 — produire DESIGN-PLAN.md |
-| `/gdd:design` | Étape 4 — exécuter par vagues |
-| `/gdd:verify` | Étape 5 — vérifier par rapport au brief |
-| `/gdd:ship` | Générer une PR branche propre |
-| `/gdd:next` | Routage auto vers la prochaine étape selon STATE.md |
-| `/gdd:do <text>` | Routeur en langage naturel |
-| `/gdd:fast <text>` | Correction triviale one-shot, sans pipeline |
-| `/gdd:quick` | Tâche ad-hoc avec garanties GDD mais portes optionnelles sautées |
-
-### Premier lancement + onboarding
-
-| Commande | Rôle |
-|----------|------|
-| `/gdd:start` | Parcours de preuve premier-lancement — top 3 problèmes de design |
-| `/gdd:new-project` | Initialiser un projet GDD |
-| `/gdd:connections` | Assistant d'onboarding pour les 12 intégrations externes |
+GDD livre 96 skills. Voici ceux dont la plupart des utilisateurs ont besoin au quotidien. Pour la référence complète, voir [SKILL.md](SKILL.md).
 
-### Cycle de vie
+### Pipeline principal
 
 | Commande | Rôle |
-|----------|------|
-| `/gdd:new-cycle` | Nouveau cycle de design |
-| `/gdd:complete-cycle` | Archiver les artefacts du cycle + EXPERIENCE.md |
-| `/gdd:pause` / `/gdd:resume` | Checkpoints numérotés |
-| `/gdd:continue` | Alias pour `/gdd:resume` |
-| `/gdd:timeline` | Rétrospective narrative à travers cycles + git log |
-
-### Itération + décisions
+| --- | --- |
+| `/gdd:brief` | Capturer le brief de design |
+| `/gdd:explore` | Inventorier le système UI actuel |
+| `/gdd:plan` | Produire le plan de design |
+| `/gdd:design` | Exécuter le plan |
+| `/gdd:verify` | Vérifier le résultat |
+| `/gdd:ship` | Préparer une branche PR propre |
+| `/gdd:next` | Router automatiquement vers l'étape suivante |
 
-| Commande | Rôle |
-|----------|------|
-| `/gdd:discuss [topic]` | Entretien de design adaptatif |
-| `/gdd:list-assumptions` | Faire émerger les hypothèses cachées avant le plan |
-| `/gdd:sketch [idea]` | Maquettes HTML multi-variantes |
-| `/gdd:spike [idea]` | Expérience de faisabilité timeboxée |
-| `/gdd:sketch-wrap-up` / `/gdd:spike-wrap-up` | Empaqueter les findings en skill local |
-| `/gdd:audit` | Wrapper verify + audit + reflector |
-| `/gdd:reflect` | Lancer le reflector à la demande |
-| `/gdd:apply-reflections` | Examiner et appliquer sélectivement les propositions |
-
-### Mémoire + couche de connaissances
+### Usage quotidien
 
 | Commande | Rôle |
-|----------|------|
-| `/gdd:recall <query>` | Recherche FTS5 |
-| `/gdd:extract-learnings` | Extraire patterns/décisions/leçons |
-| `/gdd:note <text>` | Capture d'idée sans friction |
-| `/gdd:plant-seed <idea>` | Idée prospective avec condition de déclenchement |
-| `/gdd:analyze-dependencies` | Token fan-out, call-graphs, traçabilité de décisions |
-| `/gdd:skill-manifest` | Lister tous les skills et agents GDD |
-| `/gdd:graphify` | Construire/interroger/diff le graphe de connaissances |
-| `/gdd:watch-authorities` | Diff du whitelist de feeds d'autorité |
-
-### Connexions
+| --- | --- |
+| `/gdd:do <task>` | Routeur en langage naturel |
+| `/gdd:fast <task>` | Correction ciblée légère |
+| `/gdd:quick` | Flux de tâche léger |
+| `/gdd:audit` | Audit de qualité design |
+| `/gdd:darkmode` | Audit du dark mode |
+| `/gdd:style <component>` | Handoff de style de composant |
+| `/gdd:health` | Diagnostiquer l'état du pipeline |
+| `/gdd:progress` | Afficher la progression du cycle actuel |
+| `/gdd:resume` | Reprendre depuis un checkpoint |
+
+### Outils de design et handoff
 
 | Commande | Rôle |
-|----------|------|
-| `/gdd:figma-write` | Écrire les décisions de design dans Figma |
+| --- | --- |
+| `/gdd:connections` | Configurer les intégrations optionnelles |
+| `/gdd:figma-extract` | Extraire le contexte design system de Figma |
+| `/gdd:figma-write` | Réécrire les décisions et le statut dans Figma |
 | `/gdd:handoff <bundle>` | Importer un bundle Claude Design |
-| `/gdd:darkmode` | Auditer l'implémentation dark-mode |
-| `/gdd:compare` | Calculer le delta DESIGN.md vs DESIGN-VERIFICATION.md |
-| `/gdd:style <Component>` | Générer un doc de handoff de composant |
+| `/gdd:sketch <idea>` | Générer des maquettes HTML multi-variantes |
+| `/gdd:spike <idea>` | Passe de faisabilité timeboxée |
 
-### Diagnostic + forensique
-
-| Commande | Rôle |
-|----------|------|
-| `/gdd:scan` | Inventaire design system codebase |
-| `/gdd:map` | 5 mappers codebase parallèles |
-| `/gdd:debug [desc]` | Investigation design pilotée par symptômes |
-| `/gdd:health` | Rapport de santé des artefacts `.design/` |
-| `/gdd:progress` | Position dans le pipeline |
-| `/gdd:stats` | Statistiques de cycle |
-| `/gdd:optimize` | Analyse de coût basée sur règles |
-| `/gdd:warm-cache` | Préchauffer le cache Anthropic |
-
-### Distribution + mise à jour
-
-| Commande | Rôle |
-|----------|------|
-| `/gdd:update` | Mettre à jour GDD avec preview du changelog |
-| `/gdd:reapply-patches` | Re-stitcher les modifs locales `reference/` |
-| `/gdd:check-update` | Vérification manuelle de mise à jour |
-| `/gdd:settings` | Configurer `.design/config.json` |
-| `/gdd:set-profile <profile>` | Basculer le profil de modèle |
-| `/gdd:undo` | Revert sécurisé de changement de design |
-| `/gdd:pr-branch` | PR branche propre |
-
-### Backlog + notes
-
-| Commande | Rôle |
-|----------|------|
-| `/gdd:todo` | Ajouter / lister / choisir des tâches de design |
-| `/gdd:add-backlog <idea>` | Garer une idée pour un cycle futur |
-| `/gdd:review-backlog` | Examiner les éléments garés |
-
-### Aide
-
-| Commande | Rôle |
-|----------|------|
-| `/gdd:help` | Liste complète des commandes et usage |
-| `/gdd:bandit-reset` | Réinitialiser le postérieur de la couche adaptative à la sortie d'un nouveau modèle Anthropic |
-
----
+Référence complète des commandes : [SKILL.md](SKILL.md)
 
 ## Connexions
 
-GDD livre 12 connexions d'outils. Toutes optionnelles. Configurer avec `/gdd:connections`.
-
-| Connexion | Objectif | Sonde |
-|-----------|----------|-------|
-| **Figma** | Lire tokens, composants, screenshots ; écrire annotations, Code Connect, statut d'implémentation | `mcp__figma__get_metadata` + `use_figma` |
-| **Refero** | Recherche de références de design | `mcp__refero__search` |
-| **Pinterest** | Référence visuelle pour brand voice + style | OAuth + MCP |
-| **Claude Design** | Import de bundle de handoff | URL ou fichier local |
-| **Storybook** | Recherche de spécifications composant au port 6006 | Sonde HTTP |
-| **Chromatic** | Diff de baseline de régression visuelle | Clé API |
-| **Preview** | Screenshots runtime Playwright + Claude Preview MCP | `mcp__Claude_Preview__preview_*` |
-| **paper.design** | Lecture/écriture canvas MCP | `mcp__paper__use_paper` |
-| **pencil.dev** | Spécifications `.pen` suivies par git | Fichiers `.pen` dans le repo |
-| **Graphify** | Export de graphe de connaissances | `mcp__graphify__*` |
-| **21st.dev Magic** | Recherche de précédents avant greenfield | `mcp__magic__search` |
-| **Magic Patterns** | Génération de composants DS-aware | `mcp__magic-patterns__generate` |
-
-Détails complets dans [`connections/connections.md`](connections/connections.md).
+GDD fonctionne sans outils externes, mais peut se connecter à 39 intégrations optionnelles. Toutes sont optionnelles ; le pipeline dégrade gracieusement vers des fallbacks quand une connexion est indisponible.
 
----
+La couche de connexion couvre ces catégories :
 
-## Configuration
+- **Surfaces de design** - Figma (lecture + écriture + Code Connect), paper.design, pencil.dev, Penpot, Framer, Webflow, Plasmic
+- **Référence et recherche** - Refero, Pinterest, Lazyweb, Mobbin, handoff Claude Design
+- **Génération de composants** - 21st.dev Magic, Magic Patterns, v0.dev, Builder.io
+- **Spécification de composants et QA visuelle** - Storybook, Chromatic, Preview (Playwright + Claude Preview MCP)
+- **Graphe de connaissances** - Graphify
+- **Sortie native et non-web** - Xcode Simulator, Android Emulator, Litmus / Email-on-Acid, moteur de rendu print
+- **Vérification de motion** - Lottie, Rive
+- **Surfaces d'équipe** - Slack, Discord, Linear, Jira, Notion, PR GitHub
 
-GDD stocke les paramètres projet dans `.design/config.json`. Configurer pendant `/gdd:new-project` ou mettre à jour avec `/gdd:settings`.
+Configurez les intégrations avec :
 
-### Profils de modèle
-
-| Profil | Planning | Exécution | Vérification |
-|--------|----------|-----------|--------------|
-| `quality` | Opus | Opus | Sonnet |
-| `balanced` (par défaut) | Opus | Sonnet | Sonnet |
-| `budget` | Sonnet | Sonnet | Haiku |
-| `inherit` | Inherit | Inherit | Inherit |
-
-```
-/gdd:set-profile budget
+```bash
+/gdd:connections
 ```
 
-### Mode adaptatif
-
-Échelle `.design/budget.json#adaptive_mode` (v1.23.5) :
+Pour la liste complète des connexions avec leurs motifs de sonde, voir [connections/connections.md](connections/connections.md).
 
-| Mode | Rôle |
-|------|------|
-| `static` (par défaut) | Comportement Phase 10.1 |
-| `hedge` | Ensemble AdaNormalHedge + reranking MMR engagés. Introduction la plus sûre. |
-| `full` | Routeur bandit + Hedge + MMR tous actifs |
+## Prérequis
 
-### Parallélisme
+- Node.js 22 ou 24
+- Git
+- Un runtime de code IA supporté
 
-| Paramètre | Défaut | Contrôle |
-|-----------|--------|----------|
-| `parallelism.enabled` | `true` | Exécuter les tâches indépendantes en worktrees |
-| `parallelism.min_estimated_savings_seconds` | `30` | Sauter la parallélisation sous ce seuil |
-| `parallelism.max_concurrent_workers` | `4` | Plafond dur sur les workers simultanés |
+## Support multi-runtime
 
-### Portes de qualité
+GDD s'installe sur 14 runtimes de code IA : Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Kilo, Copilot, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy et Cline. Les mêmes skills et agents sources sont compilés vers la disposition native de chaque runtime (`skills/`, `command/`, `agents/`, ou `.clinerules`) par des convertisseurs propres à chaque runtime, de sorte que le pipeline vous suit d'un éditeur à l'autre.
 
-| Paramètre | Défaut | Contrôle |
-|-----------|--------|----------|
-| `solidify.rollback_mode` | `"stash"` | `stash` / `hard` / `none` |
-| `solidify.commands` | autodetect | Surcharger commandes typecheck / build / test |
-| `verify.iterations_max` | `3` | Plafond de la boucle verify→fix |
-| `connection.figma_writeback` | `proposal` | `proposal` / `auto` |
+Claude Code est le produit phare. L'expérience complète s'y déroule de bout en bout : chaque agent, les hooks de défense en profondeur et les connexions adossées à MCP. Sur les autres runtimes, vous obtenez les mêmes skills et agents dans leur forme native, les connexions adossées à MCP s'activent sur les hôtes compatibles MCP, et la couche de hooks est spécifique à Claude Code.
 
----
-
-## Sécurité
-
-### Durcissement intégré
+## Sécurité et confidentialité
 
-GDD livre une défense en profondeur depuis la Phase 14.5 :
+GDD est local-first par défaut. Il écrit les artefacts du projet sous `.design/`, n'utilise les intégrations optionnelles que lorsqu'elles sont configurées, et garde le signalement de problèmes soumis au consentement.
 
-- **`hooks/gdd-bash-guard.js`** — PreToolUse:Bash bloque ~50 motifs dangereux après normalisation Unicode NFKC + ANSI.
-- **`hooks/gdd-protected-paths.js`** — PreToolUse:Edit/Write/Bash applique la liste glob `protected_paths`.
-- **`hooks/gdd-read-injection-scanner.ts`** — scanne le contenu Read entrant pour Unicode invisible, commentaires HTML, motifs d'exfiltration de secrets.
-- **`scripts/lib/blast-radius.cjs`** — préflight de `design-executor` refuse les tâches au-dessus de `max_files_per_task: 10` / `max_lines_per_task: 400`.
-- **`hooks/gdd-mcp-circuit-breaker.js`** — coupe les boucles de timeout consécutifs sur `use_figma` / `use_paper` / `use_pencil`.
-
-### Protéger les fichiers sensibles
+Le plugin inclut des hooks de défense en profondeur pour les chemins protégés, le blocage de commandes dangereuses, le scan d'injection, le circuit breaking MCP et l'application des budgets. GDD expose également 13 outils MCP en lecture seule pour une introspection sûre du projet.
 
 Ajoutez les chemins sensibles à la deny list de votre runtime :
 
@@ -629,7 +334,6 @@ Ajoutez les chemins sensibles à la deny list de votre runtime :
       "Read(.env)",
       "Read(.env.*)",
       "Read(**/secrets/*)",
-      "Read(**/*credential*)",
       "Read(**/*.pem)",
       "Read(**/*.key)"
     ]
@@ -637,77 +341,58 @@ Ajoutez les chemins sensibles à la deny list de votre runtime :
 }
 ```
 
-> [!IMPORTANT]
-> Comme GDD génère des fichiers markdown qui deviennent des prompts système LLM, tout texte contrôlé par l'utilisateur qui s'écoule dans les artefacts `.design/` est un vecteur potentiel d'injection de prompt indirecte. Le scanner d'injection attrape de tels vecteurs à plusieurs couches — mais la défense en profondeur reste la meilleure pratique.
-
----
-
-## Dépannage
+À lire : [SECURITY.md](SECURITY.md) · [PRIVACY.md](PRIVACY.md)
 
-**Commandes introuvables après installation ?**
-- Redémarrez votre runtime
-- Vérifiez `~/.claude/skills/get-design-done/` (global) ou `./.claude/skills/get-design-done/` (local)
-- Lancez `/gdd:help` pour confirmer l'enregistrement
+## Mise à jour
 
-**Pipeline bloqué en milieu d'étape ?**
-- `/gdd:resume` — restaurer depuis le dernier checkpoint numéroté
-- `/gdd:health` — diagnostiquer les problèmes d'artefacts `.design/`
-- `/gdd:progress --forensic` — audit d'intégrité 6 vérifications
-
-**Dépassement de coût ?**
-- `/gdd:optimize` — recommandations basées sur règles
-- `/gdd:set-profile budget` — basculer en niveau budget
-- Définissez `adaptive_mode: "full"` dans `.design/budget.json` — le bandit apprendra
-
-**Mise à jour vers la dernière version ?**
 ```bash
 npx @hegemonart/get-design-done@latest
 ```
 
-**Docker / conteneurs ?**
+Ou depuis Claude Code :
 
 ```bash
-CLAUDE_CONFIG_DIR=/workspace/.claude npx @hegemonart/get-design-done
+/gdd:update
 ```
 
-### Désinstallation
+Pour l'historique complet des releases, voir [CHANGELOG.md](CHANGELOG.md).
 
-```bash
-# Désinstallation globale (par runtime)
-npx @hegemonart/get-design-done --claude --global --uninstall
-npx @hegemonart/get-design-done --opencode --global --uninstall
-# ... même pattern --<runtime> --global --uninstall pour les 14 runtimes
+## Dépannage
 
-# Désinstallation interactive multi-sélection (sans flag de runtime)
-npx @hegemonart/get-design-done --uninstall
+### Les commandes n'apparaissent pas
 
-# Désinstallation locale
-npx @hegemonart/get-design-done --claude --local --uninstall
-# ... avec flag --local
-```
+Redémarrez votre runtime et lancez :
 
-Supprime toutes les commandes, agents, hooks et paramètres GDD tout en préservant vos autres configurations.
+```bash
+/gdd:help
+```
 
----
+### Le pipeline est bloqué
 
-## Canal de retour (v1.30.0+)
+```bash
+/gdd:health
+/gdd:resume
+```
 
-GDD inclut désormais un rapporteur de problèmes GitHub avec consentement explicite via la commande slash `/gdd:report-issue`.
+### Le coût est trop élevé
 
-- **Ce qu'il fait.** Vous guide pour signaler un bug ou une lacune fonctionnelle, avec aperçu de la charge utile avant soumission. Local-first, basé sur le consentement, pas de mode automatique.
-- **Pseudonymisation, PAS d'anonymisation.** Les identifiants directs (nom d'utilisateur, nom d'hôte, chemins absolus, identité Git, valeurs des variables d'environnement, e-mails, adresses IP) sont remplacés par des pseudonymes stables — mais la corrélation interne est préservée pour que les mainteneurs puissent déboguer. Les canaux latéraux (style d'écriture, motifs de code, empreintes de dépôt) peuvent encore ré-identifier. Vous voyez la charge utile complète avant l'envoi et donnez votre consentement par problème.
-- **Interrupteur d'arrêt.** Définissez `GDD_DISABLE_ISSUE_REPORTER=1` (env) ou ajoutez `{ "issue_reporter": false }` à `.design/config.json` pour arrêter la soumission avant tout appel réseau.
-- **Repli si `gh` absent.** Si la CLI GitHub n'est pas installée, la charge utile est écrite sur disque dans `.design/issue-drafts/` et l'URL du modèle d'issue est copiée dans le presse-papiers.
+```bash
+/gdd:optimize
+```
 
-Voir [`README.md`](README.md) en anglais pour les détails complets, [`reference/pseudonymization-rules.md`](reference/pseudonymization-rules.md) pour le catalogue de règles (R1..R8) et [`reference/known-failure-modes.md`](reference/known-failure-modes.md) pour les modes d'échec connus.
+## Contribuer
 
-**Mise à jour v1.30.5** — le catalogue compte maintenant 22 entrées (10 dans v1.30.0) et un nouveau matcher flou déterministe (`scripts/lib/failure-mode-matcher.cjs`) renvoie des candidats top-N avec score de confiance. Le réflecteur + authority-watcher peuvent proposer de nouvelles entrées via `/gdd:apply-reflections` (6e classe de proposition) — strictement propositionnel, chaque entrée passe par la revue utilisateur.
+```bash
+npm install
+npm test
+npm run typecheck
+```
 
----
+À lire : [CONTRIBUTING.md](CONTRIBUTING.md)
 
 ## Licence
 
-Licence MIT. Voir [LICENSE](LICENSE) pour les détails.
+Licence MIT. Voir [LICENSE](LICENSE) pour les détails. Les attributions tierces sont listées dans [NOTICE](NOTICE).
 
 ---