Merge 2e930e67f9 into 072d0a7458

Co-authored-by: Brian <bmadcode@gmail.com>

README_KR.md

@@ -0,0 +1,113 @@
+![BMad Method](banner-bmad-method.png)
+
+[![Version](https://img.shields.io/npm/v/bmad-method?color=blue&label=version)](https://www.npmjs.com/package/bmad-method)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)](https://nodejs.org)
+[![Python Version](https://img.shields.io/badge/python-%3E%3D3.10-blue?logo=python&logoColor=white)](https://www.python.org)
+[![uv](https://img.shields.io/badge/uv-package%20manager-blueviolet?logo=uv)](https://docs.astral.sh/uv/)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white)](https://discord.gg/gk8jAdXWmj)
+
+[English](README.md) | [简体中文](README_CN.md) | [Tiếng Việt](README_VN.md) | 한국어
+
+**Build More Architect Dreams** - BMad Method 모듈 생태계를 위한 AI 기반 애자일 개발 모듈입니다. 버그 수정부터 엔터프라이즈 시스템까지, 프로젝트 규모와 도메인에 맞춰 계획 깊이를 조절하는 포괄적인 프레임워크입니다.
+
+**100% 무료 오픈 소스입니다.** 유료 장벽도, 잠긴 콘텐츠도, 폐쇄형 Discord도 없습니다. 우리는 닫힌 커뮤니티나 강좌 비용을 낼 수 있는 사람만이 아니라 모두가 더 나은 도구를 쓸 수 있어야 한다고 믿습니다.
+
+## 왜 BMad Method인가요?
+
+전통적인 AI 도구는 사용자를 대신해 생각하고 평균적인 결과를 내는 데 그치는 경우가 많습니다. BMad의 전문 에이전트와 안내형 워크플로는 AI와 함께 더 나은 사고를 끌어내도록 돕는 전문가 협업자처럼 작동합니다.
+
+- **AI 안내 도움말** - 언제든 `bmad-help` 스킬을 호출해 다음 단계 안내를 받습니다
+- **규모와 도메인에 적응** - 프로젝트 복잡도에 맞춰 계획 깊이를 자동으로 조절합니다
+- **구조화된 워크플로** - 분석, 계획, 아키텍처, 구현 전반에 애자일 모범 사례를 적용합니다
+- **전문 에이전트** - PM, 아키텍트, 개발자, UX 등 12개 이상의 역할별 전문가를 제공합니다
+- **파티 모드** - 여러 에이전트 페르소나를 한 세션에 불러와 함께 협업하고 토론합니다
+- **전체 수명주기 지원** - 브레인스토밍부터 배포까지 함께합니다
+
+[**docs.bmad-method.org**에서 더 알아보기](https://docs.bmad-method.org/ko-kr/)
+
+## BMad의 다음 단계
+
+**V6가 출시됐고, 이제 시작입니다!** BMad Method는 크로스 플랫폼 에이전트 팀과 서브 에이전트 통합, 스킬 아키텍처, BMad 빌더 v1, 개발 루프 자동화 등 여러 개선과 함께 빠르게 진화하고 있습니다.
+
+**[전체 로드맵 보기](https://docs.bmad-method.org/ko-kr/roadmap/)**
+
+## 빠른 시작
+
+**필수 조건**: [Node.js](https://nodejs.org) v20+ · [Python](https://www.python.org) 3.10+ · [uv](https://docs.astral.sh/uv/)
+
+```bash
+npx bmad-method install
+```
+
+> 최신 사전 릴리스 빌드를 사용하려면 `npx bmad-method@next install`을 실행하세요. 기본 설치보다 변경이 더 잦을 수 있습니다.
+
+설치 프로그램의 안내를 따른 다음, Claude Code나 Cursor 같은 AI IDE를 프로젝트 폴더에서 엽니다.
+
+**비대화형 설치**(CI/CD용):
+
+```bash
+npx bmad-method install --directory /path/to/project --modules bmm --tools claude-code --yes
+```
+
+모듈 설정 옵션은 `--set <module>.<key>=<value>`로 재정의할 수 있습니다. 여러 번 사용할 수 있습니다. 로컬에서 알려진 공식 키를 보려면 `--list-options [module]`을 실행하세요.
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm --tools claude-code \
+  --set bmm.project_knowledge=research \
+  --set bmm.user_skill_level=expert
+```
+
+[전체 설치 옵션 보기](https://docs.bmad-method.org/ko-kr/how-to/non-interactive-installation/)
+
+> **무엇을 해야 할지 모르겠나요?** `bmad-help`에게 물어보세요. 다음에 해야 할 일과 선택 사항을 정확히 알려줍니다. `bmad-help 아키텍처를 막 끝냈는데 다음에 무엇을 해야 하나요?`처럼 질문할 수도 있습니다.
+
+## 모듈
+
+BMad Method는 전문 도메인을 위한 공식 모듈로 확장됩니다. 설치 중에 선택하거나 나중에 추가할 수 있습니다.
+
+| 모듈                                                                                                            | 목적                                      |
+| ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
+| **[BMad Method(BMM)](https://github.com/bmad-code-org/BMAD-METHOD)**                                             | 34개 이상의 워크플로를 제공하는 핵심 프레임워크 |
+| **[BMad 빌더(BMB)](https://github.com/bmad-code-org/bmad-builder)**                                             | 커스텀 BMad 에이전트와 워크플로 생성         |
+| **[테스트 설계자(TEA)](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)**             | 위험 기반 테스트 전략과 자동화              |
+| **[게임 개발 스튜디오(BMGD)](https://github.com/bmad-code-org/bmad-module-game-dev-studio)**                    | Unity, Unreal, Godot 워크플로                |
+| **[창의적 지능 제품군(CIS)](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)**         | 혁신, 브레인스토밍, 디자인 사고             |
+
+## 문서
+
+[BMad Method 문서 사이트](https://docs.bmad-method.org/ko-kr/) - 튜토리얼, 가이드, 개념 설명, 참조 문서
+
+**빠른 링크:**
+
+- [시작하기 튜토리얼](https://docs.bmad-method.org/ko-kr/tutorials/getting-started/)
+- [이전 버전에서 업그레이드](https://docs.bmad-method.org/ko-kr/how-to/upgrade-to-v6/)
+- [테스트 설계자 문서](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+
+## 커뮤니티
+
+- [Discord](https://discord.gg/gk8jAdXWmj) - 도움을 받고, 아이디어를 나누고, 협업하세요
+- [YouTube](https://youtube.com/@BMadCode) - 튜토리얼, 마스터 클래스 등
+- [X / Twitter](https://x.com/BMadCode)
+- [웹사이트](https://bmadcode.com)
+- [GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues) - 버그 제보와 기능 요청
+- [토론](https://github.com/bmad-code-org/BMAD-METHOD/discussions) - 커뮤니티 대화
+
+## BMad 후원
+
+BMad는 모두에게 무료이며 앞으로도 그럴 것입니다. 이 저장소에 스타를 눌러 주거나, [커피 한 잔 후원](https://buymeacoffee.com/bmad)을 보내거나, 기업 후원은 <contact@bmadcode.com>으로 문의해 주세요.
+
+## 기여
+
+기여를 환영합니다! 자세한 지침은 [CONTRIBUTING.md](CONTRIBUTING.md)를 확인하세요.
+
+## 라이선스
+
+MIT 라이선스입니다. 자세한 내용은 [LICENSE](LICENSE)를 확인하세요.
+
+**BMad**와 **BMAD-METHOD**는 BMad Code, LLC의 상표입니다. 자세한 내용은 [TRADEMARK.md](TRADEMARK.md)를 확인하세요.
+
+[![Contributors](https://contrib.rocks/image?repo=bmad-code-org/BMAD-METHOD)](https://github.com/bmad-code-org/BMAD-METHOD/graphs/contributors)
+
+기여자 정보는 [CONTRIBUTORS.md](CONTRIBUTORS.md)를 확인하세요.

docs/fr/404.md

@@ -3,6 +3,6 @@ title: Page introuvable
 template: splash
 ---
 
-La page que vous recherchez n'existe pas ou a été déplacée.
+La page que vous recherchez n’existe pas ou a été déplacée.
 
-[Retour à l'accueil](/fr/index.md)
+[Retour à l’accueil](/fr/index.md)

docs/fr/_STYLE_GUIDE.md

@@ -7,17 +7,17 @@ Ce projet suit le [Guide de style de documentation pour développeurs Google](ht
 
 ## Règles spécifiques au projet
 
-| Règle                                   | Spécification                                          |
-| --------------------------------------- | ------------------------------------------------------ |
-| Pas de règles horizontales (`---`)      | Perturbe le flux de lecture des fragments              |
-| Pas de titres `####`                    | Utiliser du texte en gras ou des admonitions           |
-| Pas de sections « Related » ou « Next: »    | La barre latérale gère la navigation                   |
-| Pas de listes profondément imbriquées   | Diviser en sections à la place                         |
-| Pas de blocs de code pour non-code      | Utiliser des admonitions pour les exemples de dialogue |
-| Pas de paragraphes en gras pour les appels | Utiliser des admonitions à la place                 |
-| 1-2 admonitions max par section         | Les tutoriels permettent 3-4 par section majeure       |
-| Cellules de tableau / éléments de liste | 1-2 phrases maximum                                    |
-| Budget de titres                        | 8-12 `##` par doc ; 2-3 `###` par section              |
+| Règle                                      | Spécification                                          |
+|--------------------------------------------|--------------------------------------------------------|
+| Pas de règles horizontales (`---`)         | Perturbe le flux de lecture des fragments              |
+| Pas de titres `####`                       | Utiliser du texte en gras ou des admonitions           |
+| Pas de sections « Related » ou « Next »    | La barre latérale gère la navigation                   |
+| Pas de listes profondément imbriquées      | Diviser en sections à la place                         |
+| Pas de blocs de code pour non-code         | Utiliser des admonitions pour les exemples de dialogue |
+| Pas de paragraphes en gras pour les appels | Utiliser des admonitions à la place                    |
+| 1-2 admonitions max par section            | Les tutoriels permettent 3-4 par section majeure       |
+| Cellules de tableau / éléments de liste    | 1-2 phrases maximum                                    |
+| Budget de titres                           | 8-12 `##` par doc ; 2-3 `###` par section              |
 
 ## Admonitions (Syntaxe Starlight)
 
@@ -41,36 +41,36 @@ Avertissements critiques uniquement — perte de données, problèmes de sécuri
 
 ### Utilisations standards
 
-| Admonition                 | Usage                                    |
-| -------------------------- | ---------------------------------------- |
-| `:::note[Pré-requis]`   | Dépendances avant de commencer           |
-| `:::tip[Chemin rapide]`       | Résumé TL;DR en haut du document         |
-| `:::caution[Important]`    | Mises en garde critiques                 |
-| `:::note[Exemple]`         | Exemples de commandes/réponses           |
+| Admonition              | Usage                            |
+|-------------------------|----------------------------------|
+| `:::note[Pré-requis]`   | Dépendances avant de commencer   |
+| `:::tip[Chemin rapide]` | Résumé TL;DR en haut du document |
+| `:::caution[Important]` | Mises en garde critiques         |
+| `:::note[Exemple]`      | Exemples de commandes/réponses   |
 
 ## Formats de tableau standards
 
-**Phases :**
+**Phases :**
 
 ```md
-| Phase | Nom        | Ce qui se passe                                     |
-| ----- | ---------- | --------------------------------------------------- |
-| 1     | Analyse    | Brainstorm, recherche *(optionnel)*                 |
-| 2     | Planification | Exigences — PRD ou spécification technique *(requis)*          |
+| Phase | Nom           | Ce qui se passe                                       |
+|-------|---------------|-------------------------------------------------------|
+| 1     | Analyse       | Brainstorm, recherche *(optionnel)*                   |
+| 2     | Planification | Exigences — PRD ou spécification technique *(requis)* |
 ```
 
-**Skills :**
+**Skills :**
 
 ```md
-| Skill               | Agent   | Objectif                                        |
-| ------------------- | ------- | ----------------------------------------------- |
-| `bmad-brainstorming` | Analyste | Brainstorming pour un nouveau projet                    |
-| `bmad-create-prd`    | PM      | Créer un document d'exigences produit           |
+| Skill                | Agent    | Objectif                              |
+|----------------------|----------|---------------------------------------|
+| `bmad-brainstorming` | Analyste | Brainstorming pour un nouveau projet  |
+| `bmad-prd`           | PM       | Créer un document d'exigences produit |
 ```
 
 ## Blocs de structure de dossiers
 
-À afficher dans les sections "Ce que vous avez accompli" :
+À afficher dans les sections « Ce que vous avez accompli » :
 
 ````md
 ```
@@ -78,9 +78,9 @@ votre-projet/
 ├── _bmad/                                   # Configuration BMad
 ├── _bmad-output/
 │   ├── planning-artifacts/
-│   │   └── PRD.md                           # Votre document d'exigences
+│   │   └── PRD.md                           # Votre document d’exigences
 │   ├── implementation-artifacts/
-│   └── project-context.md                   # Règles d'implémentation (optionnel)
+│   └── project-context.md                   # Règles d’implémentation (optionnel)
 └── ...
 ```
 ````
@@ -107,21 +107,21 @@ votre-projet/
 
 ### Liste de vérification des tutoriels
 
-- [ ] L'accroche décrit le résultat en 1-2 phrases
-- [ ] Section "Ce que vous allez apprendre" présente
+- [ ] L’accroche décrit le résultat en 1-2 phrases
+- [ ] Section « Ce que vous allez apprendre » présente
 - [ ] Prérequis dans une admonition
 - [ ] Admonition TL;DR de chemin rapide en haut
 - [ ] Tableaux pour phases, skills, agents
-- [ ] Section "Ce que vous avez accompli" présente
+- [ ] Section « Ce que vous avez accompli » présente
 - [ ] Tableau de référence rapide présent
 - [ ] Section questions courantes présente
-- [ ] Section obtenir de l'aide présente
+- [ ] Section obtenir de l’aide présente
 - [ ] Admonition points clés à retenir à la fin
 
 ## Structure des guides pratiques (How-To)
 
 ```text
-1. Titre + Accroche (une phrase : « Utilisez le workflow `X` pour... »)
+1. Titre + Accroche (une phrase : « Utilisez le workflow `X` pour... »)
 2. Quand utiliser ce guide (liste à puces de scénarios)
 3. Quand éviter ce guide (optionnel)
 4. Prérequis (admonition note)
@@ -134,23 +134,23 @@ votre-projet/
 
 ### Liste de vérification des guides pratiques
 
-- [ ] L'accroche commence par « Utilisez le workflow `X` pour... »
-- [ ] "Quand utiliser ce guide" contient 3-5 points
+- [ ] L’accroche commence par « Utilisez le workflow `X` pour... »
+- [ ] « Quand utiliser ce guide » contient 3-5 points
 - [ ] Prérequis listés
-- [ ] Les étapes sont des sous-sections `###` numérotées avec des verbes d'action
-- [ ] "Ce que vous obtenez" décrit les artefacts produits
+- [ ] Les étapes sont des sous-sections `###` numérotées avec des verbes d’action
+- [ ] « Ce que vous obtenez » décrit les artefacts produits
 
 ## Structure des explications
 
 ### Types
 
-| Type                    | Exemple                              |
-| ----------------------- | ------------------------------------ |
-| **Index/Page d'accueil** | `core-concepts/index.md`            |
-| **Concept**             | `what-are-agents.md`                 |
-| **Fonctionnalité**      | `quick-dev.md`                       |
-| **Philosophie**         | `why-solutioning-matters.md`         |
-| **FAQ**                 | `established-projects-faq.md`        |
+| Type                     | Exemple                       |
+|--------------------------|-------------------------------|
+| **Index/Page d’accueil** | `core-concepts/index.md`      |
+| **Concept**              | `what-are-agents.md`          |
+| **Fonctionnalité**       | `quick-dev.md`                |
+| **Philosophie**          | `why-solutioning-matters.md`  |
+| **FAQ**                  | `established-projects-faq.md` |
 
 ### Modèle général
 
@@ -164,7 +164,7 @@ votre-projet/
 7. Prochaines étapes (optionnel)
 ```
 
-### Pages d'index/d'accueil
+### Pages d’index/d’accueil
 
 ```text
 1. Titre + Accroche (une phrase)
@@ -209,7 +209,7 @@ votre-projet/
 
 ### Liste de vérification des explications
 
-- [ ] L'accroche énonce ce que le document explique
+- [ ] L’accroche énonce ce que le document explique
 - [ ] Contenu dans des sections `##` parcourables
 - [ ] Tableaux comparatifs pour 3+ options
 - [ ] Les diagrammes ont des étiquettes claires
@@ -220,16 +220,16 @@ votre-projet/
 
 ### Types
 
-| Type                    | Exemple               |
-| ----------------------- | --------------------- |
-| **Index/Page d'accueil** | `workflows/index.md` |
-| **Catalogue**           | `agents/index.md`     |
-| **Approfondissement**   | `document-project.md` |
-| **Configuration**       | `core-tasks.md`       |
-| **Glossaire**           | `glossary/index.md`   |
-| **Complet**             | `bmgd-workflows.md`   |
+| Type                     | Exemple               |
+|--------------------------|-----------------------|
+| **Index/Page d’accueil** | `workflows/index.md`  |
+| **Catalogue**            | `agents/index.md`     |
+| **Approfondissement**    | `document-project.md` |
+| **Configuration**        | `core-tasks.md`       |
+| **Glossaire**            | `glossary/index.md`   |
+| **Complet**              | `bmgd-workflows.md`   |
 
-### Pages d'index de référence
+### Pages d’index de référence
 
 ```text
 1. Titre + Accroche (une phrase)
@@ -243,11 +243,11 @@ votre-projet/
 1. Titre + Accroche
 2. Éléments (## pour chaque élément)
    - Brève description (une phrase)
-   - **Skills :** ou **Infos clés :** sous forme de liste simple
+   - **Skills :** ou **Infos clés :** sous forme de liste simple
 3. Universel/Partagé (## section) (optionnel)
 ```
 
-### Référence d'approfondissement d'élément
+### Référence d’approfondissement d’élément
 
 ```text
 1. Titre + Accroche (objectif en une phrase)
@@ -286,16 +286,16 @@ votre-projet/
 
 ### Liste de vérification des références
 
-- [ ] L'accroche énonce ce que le document référence
+- [ ] L’accroche énonce ce que le document référence
 - [ ] La structure correspond au type de référence
 - [ ] Les éléments utilisent une structure cohérente
 - [ ] Tableaux pour les données structurées/comparatives
-- [ ] Liens vers les documents d'explication pour la profondeur conceptuelle
+- [ ] Liens vers les documents d’explication pour la profondeur conceptuelle
 - [ ] 1-2 admonitions max
 
 ## Structure du glossaire
 
-Starlight génère la navigation "Sur cette page" à droite à partir des titres :
+Starlight génère la navigation « Sur cette page » à droite à partir des titres :
 
 - Catégories en tant que titres `##` — apparaissent dans la navigation à droite
 - Termes dans des tableaux — lignes compactes, pas de titres individuels
@@ -303,22 +303,23 @@ Starlight génère la navigation "Sur cette page" à droite à partir des titres
 
 ### Format de tableau
 
+
 ```md
 ## Nom de catégorie
 
-| Terme        | Définition                                                                                    |
-| ------------ | --------------------------------------------------------------------------------------------- |
-| **Agent**    | Personnalité IA spécialisée avec une expertise spécifique qui guide les utilisateurs dans les workflows. |
+| Terme        | Définition                                                                                                 |
+|--------------|------------------------------------------------------------------------------------------------------------|
+| **Agent**    | Personnalité IA spécialisée avec une expertise spécifique qui guide les utilisateurs dans les workflows.   |
 | **Workflow** | Processus guidé en plusieurs étapes qui orchestre les activités des agents IA pour produire des livrables. |
 ```
 
 ### Règles de définition
 
-| À faire                           | À ne pas faire                                |
-| --------------------------------- | --------------------------------------------- |
-| Commencer par ce que c'est ou ce que cela fait | Commencer par « C'est... » ou « Un [terme] est... » |
-| Se limiter à 1-2 phrases          | Écrire des explications de plusieurs paragraphes |
-| Mettre le nom du terme en gras dans la cellule | Utiliser du texte simple pour les termes      |
+| À faire                                        | À ne pas faire                                      |
+|------------------------------------------------|-----------------------------------------------------|
+| Commencer par ce que c’est ou ce que cela fait | Commencer par « C’est... » ou « Un [terme] est... » |
+| Se limiter à 1-2 phrases                       | Écrire des explications de plusieurs paragraphes    |
+| Mettre le nom du terme en gras dans la cellule | Utiliser du texte simple pour les termes            |
 
 ### Marqueurs de contexte
 
@@ -337,7 +338,7 @@ Ajouter un contexte en italique au début de la définition pour les termes à p
 - [ ] Définitions de 1-2 phrases
 - [ ] Marqueurs de contexte en italique
 - [ ] Noms des termes en gras dans les cellules
-- [ ] Pas de définitions « Un [terme] est... »
+- [ ] Pas de définitions « Un [terme] est... »
 
 ## Sections FAQ
 

docs/fr/explanation/advanced-elicitation.md

@@ -2,25 +2,25 @@
 title: "Élicitation Avancée"
 description: Pousser le LLM à repenser son travail en utilisant des méthodes de raisonnement structurées
 sidebar:
-  order: 3
+  order: 4
 ---
 
-Faites repenser au LLM ce qu'il vient de générer. Vous choisissez une méthode de raisonnement, il l'applique à sa propre sortie, et vous décidez de conserver ou non les améliorations.
+Faites repenser au LLM ce qu’il vient de générer. Vous choisissez une méthode de raisonnement, il l’applique à sa propre sortie, et vous décidez de conserver ou non les améliorations.
 
-## Qu'est-ce que l’Élicitation Avancée ?
+## Qu’est-ce que l’Élicitation Avancée ?
 
-Un second passage structuré. Au lieu de demander à l'IA de "réessayer" ou de "faire mieux", vous sélectionnez une méthode de raisonnement spécifique et l'IA réexamine sa propre sortie à travers ce prisme.
+Un second passage structuré. Au lieu de demander à l’IA de « réessayer » ou de « faire mieux », vous sélectionnez une méthode de raisonnement spécifique et l’IA réexamine sa propre sortie à travers ce prisme.
 
-La différence est importante. Les demandes vagues produisent des révisions vagues. Une méthode nommée impose un angle d'attaque particulier, mettant en lumière des perspectives qu'un simple réajustement générique aurait manquées.
+La différence est importante. Les demandes vagues produisent des révisions vagues. Une méthode nommée impose un angle d’attaque particulier, mettant en lumière des perspectives qu’un simple réajustement générique aurait manquées.
 
-## Quand l'utiliser
+## Quand l’utiliser
 
-- Après qu'un workflow a généré du contenu et vous souhaitez des alternatives
-- Lorsque la sortie semble correcte mais que vous soupçonnez qu'il y a davantage de profondeur
+- Après qu’un workflow a généré du contenu et vous souhaitez des alternatives
+- Lorsque la sortie semble correcte mais que vous soupçonnez qu’il y a davantage de profondeur
 - Pour tester les hypothèses ou trouver des faiblesses
 - Pour du contenu à enjeux élevés où la réflexion approfondie aide
 
-Les workflows offrent l'élicitation aux points de décision - après que le LLM ait généré quelque chose, on vous demandera si vous souhaitez l'exécuter.
+Les workflows offrent l’élicitation aux points de décision - après que le LLM ait généré quelque chose, on vous demandera si vous souhaitez l’exécuter.
 
 ## Comment ça fonctionne
 
@@ -35,15 +35,15 @@ Des dizaines de méthodes de raisonnement sont disponibles. Quelques exemples :
 
 - **Analyse Pré-mortem** - Suppose que le projet a déjà échoué, revient en arrière pour trouver pourquoi
 - **Pensée de Premier Principe** - Élimine les hypothèses, reconstruit à partir de la vérité de terrain
-- **Inversion** - Demande comment garantir l'échec, puis les évite
+- **Inversion** - Demande comment garantir l’échec, puis les évite
 - **Équipe Rouge vs Équipe Bleue** - Attaque votre propre travail, puis le défend
-- **Questionnement Socratique** - Conteste chaque affirmation avec "pourquoi ?" et "comment le savez-vous ?"
+- **Questionnement Socratique** - Conteste chaque affirmation avec « pourquoi ? » et « comment le savez-vous ? »
 - **Suppression des Contraintes** - Abandonne toutes les contraintes, voit ce qui change, les réajoute sélectivement
 - **Cartographie des Parties Prenantes** - Réévalue depuis la perspective de chaque partie prenante
-- **Raisonnement Analogique** - Trouve des parallèles dans d'autres domaines et applique leurs leçons
+- **Raisonnement Analogique** - Trouve des parallèles dans d’autres domaines et applique leurs leçons
 
-Et bien d'autres. L'IA choisit les options les plus pertinentes pour votre contenu - vous choisissez lesquelles exécuter.
+Et bien d’autres. L’IA choisit les options les plus pertinentes pour votre contenu - vous choisissez lesquelles exécuter.
 
 :::tip[Commencez Ici]
-L'Analyse Pré-mortem est un bon premier choix pour toute spécification ou tout plan. Elle trouve systématiquement des lacunes qu'une révision standard manque.
+L’Analyse Pré-mortem est un bon premier choix pour toute spécification ou tout plan. Elle trouve systématiquement des lacunes qu’une révision standard manque.
 :::

docs/fr/explanation/adversarial-review.md

@@ -1,58 +1,58 @@
 ---
 title: "Revue Contradictoire"
-description: Technique de raisonnement forcée qui empêche les revues paresseuses du style "ça à l'air bon"
+description: Technique de raisonnement forcée qui empêche les revues paresseuses du style « ça à l’air bon »
 sidebar:
-  order: 8
+  order: 9
 ---
 
 Forcez une analyse plus approfondie en exigeant que des problèmes soient trouvés.
 
-## Qu'est-ce que la Revue Contradictoire ?
+## Qu’est-ce que la Revue Contradictoire ?
 
-Une technique de revue où le réviseur *doit* trouver des problèmes. Pas de "ça a l'air bon" autorisé. Le réviseur adopte une posture cynique - suppose que des problèmes existent et les trouve.
+Une technique de revue où le réviseur *doit* trouver des problèmes. Pas de « ça a l’air bon » autorisé. Le réviseur adopte une posture cynique - suppose que des problèmes existent et les trouve.
 
-Il ne s'agit pas d'être négatif. Il s'agit de forcer une analyse authentique au lieu d'un coup d'œil superficiel qui valide automatiquement ce qui a été soumis.
+Il ne s’agit pas d’être négatif. Il s’agit de forcer une analyse authentique au lieu d’un coup d’œil superficiel qui valide automatiquement ce qui a été soumis.
 
-**La règle fondamentale :** Il doit trouver des problèmes. Zéro constatation déclenche un arrêt - réanalyse ou explique pourquoi.
+**La règle fondamentale :** Il doit trouver des problèmes. Zéro constatation déclenche un arrêt - réanalyse ou explique pourquoi.
 
 ## Pourquoi Cela Fonctionne
 
-Les revues normales souffrent du biais de confirmation[^1]. Il parcourt le travail rapidement, rien ne lui saute aux yeux, il l'approuve. L'obligation de "trouver des problèmes" brise ce schéma :
+Les revues normales souffrent du biais de confirmation[^1]. Il parcourt le travail rapidement, rien ne lui saute aux yeux, il l’approuve. L’obligation de « trouver des problèmes » brise ce schéma :
 
-- **Force la rigueur** - Impossible d'approuver tant qu’il n'a pas examiné suffisamment en profondeur pour trouver des problèmes
-- **Détecte les oublis** - "Qu'est-ce qui manque ici ?" devient une question naturelle
+- **Force la rigueur** - Impossible d’approuver tant qu’il n’a pas examiné suffisamment en profondeur pour trouver des problèmes
+- **Détecte les oublis** - « Qu’est-ce qui manque ici ? » devient une question naturelle
 - **Améliore la qualité du signal** - Les constatations sont spécifiques et actionnables, pas des préoccupations vagues
-- **Asymétrie d'information**[^2] - Effectue les revues avec un contexte frais (sans accès au raisonnement original) pour évaluer l'artefact, pas l'intention
+- **Asymétrie d’information**[^2] - Effectue les revues avec un contexte frais (sans accès au raisonnement original) pour évaluer l’artefact, pas l’intention
 
 ## Où Elle Est Utilisée
 
-La revue contradictoire apparaît dans tous les workflows BMad - revue de code, vérifications de préparation à l'implémentation, validation de spécifications, et d'autres. Parfois c'est une étape obligatoire, parfois optionnelle (comme l'élicitation avancée ou le mode party). Le pattern s'adapte à n'importe quel artefact nécessitant un examen.
+La revue contradictoire apparaît dans tous les workflows BMad - revue de code, vérifications de préparation à l’implémentation, validation de spécifications, et d’autres. Parfois c’est une étape obligatoire, parfois optionnelle (comme l’élicitation avancée ou le mode party). Le pattern s’adapte à n’importe quel artefact nécessitant un examen.
 
 ## Filtrage Humain Requis
 
-Parce que l'IA est *instruite* de trouver des problèmes, elle trouvera des problèmes - même lorsqu'ils n'existent pas. Attendez-vous à des faux positifs : des détails présentés comme des problèmes, des malentendus sur l'intention, ou des préoccupations purement hallucinées[^3].
+Parce que l’IA est *instruite* de trouver des problèmes, elle trouvera des problèmes - même lorsqu’ils n’existent pas. Attendez-vous à des faux positifs : des détails présentés comme des problèmes, des malentendus sur l’intention, ou des préoccupations purement hallucinées[^3].
 
-**C'est vous qui décidez ce qui est réel.** Examinez chaque constatation, ignorez le bruit, corrigez ce qui compte.
+**C’est vous qui décidez ce qui est réel.** Examinez chaque constatation, ignorez le bruit, corrigez ce qui compte.
 
 ## Exemple
 
 Au lieu de :
 
-> "L'implémentation de l'authentification semble raisonnable. Approuvé."
+> « L’implémentation de l’authentification semble raisonnable. Approuvé. »
 
 Une revue contradictoire produit :
 
 > 1. **ÉLEVÉ** - `login.ts:47` - Pas de limitation de débit sur les tentatives échouées
 > 2. **ÉLEVÉ** - Jeton de session stocké dans localStorage (vulnérable au XSS)
 > 3. **MOYEN** - La validation du mot de passe se fait côté client uniquement
-> 4. **MOYEN** - Pas de journalisation d'audit pour les tentatives de connexion échouées
+> 4. **MOYEN** - Pas de journalisation d’audit pour les tentatives de connexion échouées
 > 5. **FAIBLE** - Le nombre magique `3600` devrait être `SESSION_TIMEOUT_SECONDS`
 
 La première revue pourrait manquer une vulnérabilité de sécurité. La seconde en a attrapé quatre.
 
 ## Itération et Rendements Décroissants
 
-Après avoir traité les constatations, envisagez de relancer la revue. Une deuxième passe détecte généralement plus de problèmes. Une troisième n'est pas toujours inutile non plus. Mais chaque passe prend du temps, et vous finissez par atteindre des rendements décroissants[^4] - juste des détails et des faux problèmes.
+Après avoir traité les constatations, envisagez de relancer la revue. Une deuxième passe détecte généralement plus de problèmes. Une troisième n’est pas toujours inutile non plus. Mais chaque passe prend du temps, et vous finissez par atteindre des rendements décroissants[^4] - juste des détails et des faux problèmes.
 
 :::tip[Meilleures Revues]
 Supposez que des problèmes existent. Cherchez ce qui manque, pas seulement ce qui ne va pas.
@@ -61,6 +61,6 @@ Supposez que des problèmes existent. Cherchez ce qui manque, pas seulement ce q
 ## Glossaire
 
 [^1]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui confirment nos croyances préexistantes, tout en ignorant ou minimisant celles qui les contredisent.
-[^2]: **Asymétrie d'information** : situation où une partie dispose de plus ou de meilleures informations qu'une autre, conduisant potentiellement à des décisions ou jugements biaisés.
-[^3]: **Hallucination (IA)** : phénomène où un modèle d'IA génère des informations plausibles mais factuellement incorrectes ou inventées, présentées avec confiance comme si elles étaient vraies.
-[^4]: **Rendements décroissants** : principe selon lequel l'augmentation continue d'un investissement (temps, effort, ressources) finit par produire des bénéfices de plus en plus faibles proportionnellement.
+[^2]: **Asymétrie d’information** : situation où une partie dispose de plus ou de meilleures informations qu’une autre, conduisant potentiellement à des décisions ou jugements biaisés.
+[^3]: **Hallucination (IA)** : phénomène où un modèle d’IA génère des informations plausibles mais factuellement incorrectes ou inventées, présentées avec confiance comme si elles étaient vraies.
+[^4]: **Rendements décroissants** : principe selon lequel l’augmentation continue d’un investissement (temps, effort, ressources) finit par produire des bénéfices de plus en plus faibles proportionnellement.

docs/fr/explanation/analysis-phase.md

@@ -1,74 +1,74 @@
 ---
-title: "Phase d'analyse : de l'Idée aux Fondations"
+title: "Phase d’analyse : de l’Idée aux Fondations"
 description: Ce que sont le brainstorming, la recherche, les product briefs et les PRFAQs — et quand les utiliser
 sidebar:
-  order: 1
+  order: 2
 ---
 
-La phase d'Analyse (Phase 1) vous aide à penser clairement à votre produit avant de vous engager à le construire. Chaque outil de cette phase est optionnel, mais sauter l'analyse entièrement signifie que votre PRD sera construit sur des suppositions plutôt que sur des connaissances approfondies.
+La phase d’Analyse (Phase 1) vous aide à penser clairement à votre produit avant de vous engager à le construire. Chaque outil de cette phase est optionnel, mais sauter l’analyse entièrement signifie que votre PRD sera construit sur des suppositions plutôt que sur des connaissances approfondies.
 
-## Pourquoi Analyser avant de Planifier ?
+## Pourquoi Analyser avant de Planifier ?
 
-Un PRD répond à la question « que devons-nous construire et pourquoi ? » Si vous l'alimentez avec une réflexion vague, vous obtiendrez un PRD vague — et chaque document en aval héritera de cette imprécision. Une architecture bâtie sur un PRD faible prend de mauvaises décisions techniques. Les stories dérivées d'une architecture faible manquent de edge cases. Le coût s'accumule.
+Un PRD répond à la question « que devons-nous construire et pourquoi ? » Si vous l’alimentez avec une réflexion vague, vous obtiendrez un PRD vague — et chaque document en aval héritera de cette imprécision. Une architecture bâtie sur un PRD faible prend de mauvaises décisions techniques. Les stories dérivées d’une architecture faible manquent de edge cases. Le coût s’accumule.
 
-Les outils d'analyse existent pour rendre votre PRD précis. Ils attaquent le problème sous différents angles — exploration créative, réalité du marché, clarté client, faisabilité — pour qu'au moment de vous asseoir avec l'agent PM, vous sachiez ce que vous construisez et pour qui.
+Les outils d’analyse existent pour rendre votre PRD précis. Ils attaquent le problème sous différents angles — exploration créative, réalité du marché, clarté client, faisabilité — pour qu’au moment de vous asseoir avec l’agent PM, vous sachiez ce que vous construisez et pour qui.
 
 ## Les Outils
 
 ### Brainstorming
 
-**Quoi.** Une session créative facilitée utilisant des techniques d'idéation éprouvées. L'IA agit comme coach, extrayant vos idées à travers des exercices structurés — pas en les générant pour vous.
+**Quoi.** Une session créative facilitée utilisant des techniques d’idéation éprouvées. L’IA agit comme coach, extrayant vos idées à travers des exercices structurés — pas en les générant pour vous.
 
-**Pourquoi.** Les idées brutes ont besoin d'espace pour se développer avant d'être verrouillées dans des exigences. Le brainstorming crée cet espace. Il est particulièrement précieux quand vous avez un espace-problème mais pas de solution claire, ou quand vous voulez explorer plusieurs pistes avant de vous engager.
+**Pourquoi.** Les idées brutes ont besoin d’espace pour se développer avant d’être verrouillées dans des exigences. Le brainstorming crée cet espace. Il est particulièrement précieux quand vous avez un espace-problème mais pas de solution claire, ou quand vous voulez explorer plusieurs pistes avant de vous engager.
 
-**Quand.** Vous avez une vague idée de ce que vous voulez construire mais n'avez pas encore cristallisé le concept. Ou vous avez un concept mais voulez l'éprouver face à des alternatives.
+**Quand.** Vous avez une vague idée de ce que vous voulez construire mais n’avez pas encore cristallisé le concept. Ou vous avez un concept mais voulez l’éprouver face à des alternatives.
 
 Voir [Brainstorming](./brainstorming.md) pour un aperçu plus approfondi du fonctionnement des sessions.
 
 ### Recherche (Marché, Domaine, Technique)
 
-**Quoi.** Trois workflows de recherche ciblés qui investiguent différentes dimensions de votre idée. La recherche marché examine les concurrents, les tendances et le sentiment utilisateur. La recherche domaine construit l'expertise métier et la terminologie. La recherche technique évalue la faisabilité, les options d'architecture et les approches d'implémentation.
+**Quoi.** Trois workflows de recherche ciblés qui investiguent différentes dimensions de votre idée. La recherche marché examine les concurrents, les tendances et le sentiment utilisateur. La recherche domaine construit l’expertise métier et la terminologie. La recherche technique évalue la faisabilité, les options d’architecture et les approches d’implémentation.
 
-**Pourquoi.** Construire sur des suppositions est le moyen le plus rapide de construire quelque chose dont personne n'a besoin. La recherche ancre votre concept dans la réalité — quels concurrents existent déjà, avec quoi les utilisateurs luttent réellement, ce qui est techniquement faisable, et quelles contraintes spécifiques à l'industrie vous affronterez.
+**Pourquoi.** Construire sur des suppositions est le moyen le plus rapide de construire quelque chose dont personne n’a besoin. La recherche ancre votre concept dans la réalité — quels concurrents existent déjà, avec quoi les utilisateurs luttent réellement, ce qui est techniquement faisable, et quelles contraintes spécifiques à l’industrie vous affronterez.
 
-**Quand.** Vous entrez dans un domaine inconnu, vous soupçonnez que des concurrents existent mais ne les avez pas cartographiés, ou votre concept dépend de capacités techniques que vous n'avez pas validées. Lancez-en un, deux ou les trois — chaque workflow de recherche fonctionne de manière autonome.
+**Quand.** Vous entrez dans un domaine inconnu, vous soupçonnez que des concurrents existent mais ne les avez pas cartographiés, ou votre concept dépend de capacités techniques que vous n’avez pas validées. Lancez-en un, deux ou les trois — chaque workflow de recherche fonctionne de manière autonome.
 
 ### Product Brief[^1]
 
-**Quoi.** Une session de découverte guidée qui produit un résumé exécutif de 1-2 pages de votre concept produit. L'IA agit comme un analyste commercial collaboratif, vous aidant à articuler la vision, le public cible, la proposition de valeur et le périmètre.
+**Quoi.** Une session de découverte guidée qui produit un résumé exécutif de 1-2 pages de votre concept produit. L’IA agit comme un analyste commercial collaboratif, vous aidant à articuler la vision, le public cible, la proposition de valeur et le périmètre.
 
 **Pourquoi.** Le product brief est le chemin le plus doux vers la planification. Il capture votre vision stratégique dans un format structuré qui alimente directement la création du PRD. Il fonctionne mieux quand vous avez déjà la conviction à propos de votre concept — vous connaissez le client, le problème et approximativement ce que vous voulez construire. Le brief organise et affine cette réflexion.
 
-**Quand.** Votre concept est relativement clair et vous voulez le documenter efficacement avant de créer un PRD. Vous êtes confiant dans la direction et n'avez pas besoin que vos suppositions soient agressivement remises en question.
+**Quand.** Votre concept est relativement clair et vous voulez le documenter efficacement avant de créer un PRD. Vous êtes confiant dans la direction et n’avez pas besoin que vos suppositions soient agressivement remises en question.
 
 ### PRFAQ (Working Backwards)
 
-**Quoi.** La méthodologie Working Backwards d'Amazon adaptée en défi interactif. Vous rédigez le communiqué de presse annonçant votre produit fini avant qu'une seule ligne de code n'existe, puis répondez aux questions les plus difficiles que les clients et les parties prenantes poseraient. L'IA agit comme un coach produit implacable mais constructif.
+**Quoi.** La méthodologie Working Backwards d’Amazon adaptée en défi interactif. Vous rédigez le communiqué de presse annonçant votre produit fini avant qu’une seule ligne de code n’existe, puis répondez aux questions les plus difficiles que les clients et les parties prenantes poseraient. L’IA agit comme un coach produit implacable mais constructif.
 
-**Pourquoi.** Le PRFAQ est le chemin rigoureux vers la planification. Il force la clarté orientée client en vous obligeant à défendre chaque affirmation. Si vous ne pouvez pas rédiger un communiqué de presse convaincant, le produit n'est pas prêt. Si les réponses de la FAQ client révèlent des lacunes, ce sont des lacunes que vous découvrirez bien plus tard — et plus coûteusement — pendant l'implémentation. Le défi fait remonter les failles de réflexion tôt, quand c'est le moins cher de les corriger.
+**Pourquoi.** Le PRFAQ est le chemin rigoureux vers la planification. Il force la clarté orientée client en vous obligeant à défendre chaque affirmation. Si vous ne pouvez pas rédiger un communiqué de presse convaincant, le produit n’est pas prêt. Si les réponses de la FAQ client révèlent des lacunes, ce sont des lacunes que vous découvrirez bien plus tard — et plus coûteusement — pendant l’implémentation. Le défi fait remonter les failles de réflexion tôt, quand c’est le moins cher de les corriger.
 
-**Quand.** Vous voulez que votre concept soit éprouvé avant d'engager des ressources. Vous n'êtes pas sûr que les utilisateurs s'en soucieront réellement. Vous voulez valider que vous pouvez articuler une proposition de valeur claire et défendable. Ou vous voulez simplement la discipline du Working Backwards pour affiner votre réflexion.
+**Quand.** Vous voulez que votre concept soit éprouvé avant d’engager des ressources. Vous n’êtes pas sûr que les utilisateurs s’en soucieront réellement. Vous voulez valider que vous pouvez articuler une proposition de valeur claire et défendable. Ou vous voulez simplement la discipline du Working Backwards pour affiner votre réflexion.
 
-## Lequel utiliser ?
+## Lequel utiliser ?
 
 | Situation                                                                     | Outil recommandé                           |
 |-------------------------------------------------------------------------------|--------------------------------------------|
-| « J'ai une idée vague, je ne sais pas par où commencer »                      | Brainstorming                              |
-| « J'ai besoin de comprendre le marché avant de décider »                      | Recherche                                  |
-| « Je sais ce que je veux construire, j'ai juste besoin de le documenter »     | Product Brief                              |
-| « Je veux m'assurer que cette idée vaut vraiment la peine d'être construite » | PRFAQ                                      |
-| « Je veux explorer, puis valider, puis documenter »                           | Brainstorming → Recherche → PRFAQ ou Brief |
+| « J’ai une idée vague, je ne sais pas par où commencer »                      | Brainstorming                              |
+| « J’ai besoin de comprendre le marché avant de décider »                      | Recherche                                  |
+| « Je sais ce que je veux construire, j’ai juste besoin de le documenter »     | Product Brief                              |
+| « Je veux m’assurer que cette idée vaut vraiment la peine d’être construite » | PRFAQ                                      |
+| « Je veux explorer, puis valider, puis documenter »                           | Brainstorming → Recherche → PRFAQ ou Brief |
 
-Le Product Brief et le PRFAQ produisent tous deux des entrées pour le PRD — choisissez-en un en fonction du niveau de défi que vous souhaitez. Le brief est une découverte collaborative. Le PRFAQ est un défi. Les deux vous mènent à la même destination ; le PRFAQ teste si votre concept mérite d'y arriver.
+Le Product Brief et le PRFAQ produisent tous deux des entrées pour le PRD — choisissez-en un en fonction du niveau de défi que vous souhaitez. Le brief est une découverte collaborative. Le PRFAQ est un défi. Les deux vous mènent à la même destination ; le PRFAQ teste si votre concept mérite d’y arriver.
 
-:::tip[Pas sûr ?]
+:::tip[Pas sûr ?]
 Exécutez `bmad-help` et décrivez votre situation. Il vous recommandera le bon point de départ en fonction de ce que vous avez déjà accompli et de ce que vous essayez de réaliser.
 :::
 
-## Que se passe-t-il après l'analyse ?
+## Que se passe-t-il après l’analyse ?
 
-Les résultats de l'analyse alimentent directement la Phase 2 (Planification). Le workflow PRD accepte les product briefs, les documents PRFAQ, les conclusions de recherche et les rapports de brainstorming en entrée — il synthétise tout ce que vous avez produit en exigences structurées. Plus vous faites d'analyse, plus votre PRD sera précis.
+Les résultats de l’analyse alimentent directement la Phase 2 (Planification). Le workflow PRD accepte les product briefs, les documents PRFAQ, les conclusions de recherche et les rapports de brainstorming en entrée — il synthétise tout ce que vous avez produit en exigences structurées. Plus vous faites d’analyse, plus votre PRD sera précis.
 
 ## Glossaire
 
-[^1]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d'un projet ou d'une demande, afin d'aligner rapidement les parties prenantes avant le travail détaillé.
+[^1]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.

docs/fr/explanation/brainstorming.md

@@ -1,27 +1,27 @@
 ---
 title: "Brainstorming"
-description: Sessions interactives créatives utilisant plus de 60 techniques d'idéation éprouvées
+description: Sessions interactives créatives utilisant plus de 60 techniques d’idéation éprouvées
 sidebar:
-  order: 2
+  order: 3
 ---
 
 Libérez votre créativité grâce à une exploration guidée.
 
-## Qu'est-ce que le Brainstorming ?
+## Qu’est-ce que le Brainstorming ?
 
-Lancez `bmad-brainstorming` et vous obtenez un facilitateur créatif qui fait émerger vos idées - pas qui les génère pour vous. L'IA agit comme coach et guide, utilisant des techniques éprouvées pour créer les conditions où votre meilleure réflexion émerge.
+Lancez `bmad-brainstorming` et vous obtenez un facilitateur créatif qui fait émerger vos idées - pas qui les génère pour vous. L’IA agit comme coach et guide, utilisant des techniques éprouvées pour créer les conditions où votre meilleure réflexion émerge.
 
-**Idéal pour :**
+**Idéal pour :**
 
 - Surmonter les blocages créatifs
 - Générer des idées de produits ou de fonctionnalités
 - Explorer des problèmes sous de nouveaux angles
-- Développer des concepts bruts en plans d'action
+- Développer des concepts bruts en plans d’action
 
 ## Comment ça fonctionne
 
 1. **Configuration** - Définir le sujet, les objectifs, les contraintes
-2. **Choisir l'approche** - Choisir vous-même les techniques, obtenir des recommandations de l'IA, aller au hasard, ou suivre un flux progressif
+2. **Choisir l’approche** - Choisir vous-même les techniques, obtenir des recommandations de l’IA, aller au hasard, ou suivre un flux progressif
 3. **Facilitation** - Travailler à travers les techniques avec des questions approfondies et un coaching collaboratif
 4. **Organiser** - Idées regroupées par thèmes et priorisées
 5. **Action** - Les meilleures idées reçoivent des prochaines étapes et des indicateurs de succès

docs/fr/explanation/checkpoint-preview.md

@@ -2,91 +2,91 @@
 title: "Checkpoint Preview"
 description: Revue assistée par LLM, avec intervention humaine, qui vous guide à travers une modification, de son objectif jusqu’aux détails
 sidebar:
-  order: 7
+  order: 8
 ---
 
-`bmad-checkpoint-preview` est un workflow de revue interactif, assisté par LLM, avec intervention humaine. Il vous guide à travers une modification de code — de l'intention et du contexte jusqu'aux détails — afin que vous puissiez prendre une décision éclairée sur la mise en production, la refonte ou l'approfondissement.
+`bmad-checkpoint-preview` est un workflow de revue interactif, assisté par LLM, avec intervention humaine. Il vous guide à travers une modification de code — de l’intention et du contexte jusqu’aux détails — afin que vous puissiez prendre une décision éclairée sur la mise en production, la refonte ou l’approfondissement.
 
 ![Diagramme du workflow Checkpoint Preview](/diagrams/checkpoint-preview-diagram-fr.webp)
 
 ## Le Flux Typique
 
-Vous lancez `bmad-quick-dev`. Il clarifie votre intention, construit une spécification, implémente la modification, et une fois terminé, il ajoute un historique de revue au fichier de spécification et l'ouvre dans votre éditeur. Vous regardez la spec et constatez que la modification a touché 20 fichiers dans plusieurs modules.
+Vous lancez `bmad-quick-dev`. Il clarifie votre intention, construit une spécification, implémente la modification, et une fois terminé, il ajoute un historique de revue au fichier de spécification et l’ouvre dans votre éditeur. Vous regardez la spec et constatez que la modification a touché 20 fichiers dans plusieurs modules.
 
-Vous pourriez survoler le diff. Mais 20 fichiers, c'est le moment où le survol commence à échouer — on perd le fil, on rate un lien entre deux modifications éloignées, ou on approuve quelque chose qu'on n'a pas pleinement compris. Alors au lieu de cela, vous dites « checkpoint » et le LLM vous guide à travers la modification.
+Vous pourriez survoler le diff. Mais 20 fichiers, c’est le moment où le survol commence à échouer — on perd le fil, on rate un lien entre deux modifications éloignées, ou on approuve quelque chose qu’on n’a pas pleinement compris. Alors au lieu de cela, vous dites « checkpoint » et le LLM vous guide à travers la modification.
 
-Ce passage de relais — de l'implémentation autonome au jugement humain — est le cas d'usage principal. Quick-dev s'exécute longtemps avec une supervision minimale. Checkpoint Preview, c'est là où vous reprenez le volant.
+Ce passage de relais — de l’implémentation autonome au jugement humain — est le cas d’usage principal. Quick-dev s’exécute longtemps avec une supervision minimale. Checkpoint Preview, c’est là où vous reprenez le volant.
 
 ## Pourquoi
 
-La revue de code a deux modes d'échec. Dans le premier, le réviseur survole le diff, rien ne saute aux yeux, et il approuve. Dans le second, il lit méthodiquement chaque fichier mais perd le fil — il voit les arbres et rate la forêt. Les deux aboutissent au même résultat : la revue n'a pas repéré ce qui comptait.
+La revue de code a deux modes d’échec. Dans le premier, le réviseur survole le diff, rien ne saute aux yeux, et il approuve. Dans le second, il lit méthodiquement chaque fichier mais perd le fil — il voit les arbres et rate la forêt. Les deux aboutissent au même résultat : la revue n’a pas repéré ce qui comptait.
 
-Le problème sous-jacent est le séquençage. Un diff brut présente les modifications dans l'ordre des fichiers, ce qui est presque jamais l'ordre qui construit la compréhension. Vous voyez une fonction utilitaire avant de savoir pourquoi elle existe. Vous voyez une modification de schéma avant de comprendre quelle fonctionnalité elle supporte. Le réviseur doit reconstruire l'intention de l'auteur à partir d'indices dispersés, et c'est cette reconstruction qui fait défaut à l'attention.
+Le problème sous-jacent est le séquençage. Un diff brut présente les modifications dans l’ordre des fichiers, ce qui est presque jamais l’ordre qui construit la compréhension. Vous voyez une fonction utilitaire avant de savoir pourquoi elle existe. Vous voyez une modification de schéma avant de comprendre quelle fonctionnalité elle supporte. Le réviseur doit reconstruire l’intention de l’auteur à partir d’indices dispersés, et c’est cette reconstruction qui fait défaut à l’attention.
 
 Checkpoint Preview résout ce problème en confiant le travail de reconstruction au LLM. Il lit le diff, la spécification (si elle existe) et la base de code environnante, puis présente la modification dans un ordre conçu pour la compréhension — et non pour `git diff`.
 
 ## Comment ça fonctionne
 
-Le workflow comporte cinq étapes. Chaque étape s'appuie sur la précédente, passant progressivement de « qu'est-ce que c'est ? » à « devons-nous publier ça ? »
+Le workflow comporte cinq étapes. Chaque étape s’appuie sur la précédente, passant progressivement de « qu’est-ce que c’est ? » à « devons-nous publier ça ? »
 
 ### 1. Orientation
 
-Le workflow identifie la modification (à partir d'une PR, d'un commit, d'une branche, d'un fichier de spécification ou de l'état git actuel) et produit un résumé d'intention en une ligne ainsi que des statistiques de surface : fichiers modifiés, modules touchés, lignes de logique, dépassements de boundaries et nouvelles interfaces publiques.
+Le workflow identifie la modification (à partir d’une PR, d’un commit, d’une branche, d’un fichier de spécification ou de l’état git actuel) et produit un résumé d’intention en une ligne ainsi que des statistiques de surface : fichiers modifiés, modules touchés, lignes de logique, dépassements de boundaries et nouvelles interfaces publiques.
 
-C'est le moment « est-ce bien ce que je crois ? ». Avant de lire le moindre code, le réviseur confirme qu'il regarde la bonne chose et calibre ses attentes quant à la portée.
+C’est le moment « est-ce bien ce que je crois ? ». Avant de lire le moindre code, le réviseur confirme qu’il regarde la bonne chose et calibre ses attentes quant à la portée.
 
 ### 2. Visite guidée
 
-La modification est organisée par **préoccupation** — des intentions de conception cohérentes comme « validation des entrées » ou « contrat d'API » — et non par fichier. Chaque préoccupation fait l'objet d'une courte explication du *pourquoi* de cette approche, suivie d'arrêts cliquables `chemin:ligne` que le réviseur peut suivre dans le code.
+La modification est organisée par **préoccupation** — des intentions de conception cohérentes comme « validation des entrées » ou « contrat d’API » — et non par fichier. Chaque préoccupation fait l’objet d’une courte explication du *pourquoi* de cette approche, suivie d’arrêts cliquables `chemin:ligne` que le réviseur peut suivre dans le code.
 
-C'est l'étape du jugement de conception. Le réviseur évalue si l'approche est adaptée au système, et non si le code est correct. Les préoccupations sont séquencées de haut en bas : l'intention de plus haut niveau en premier, puis l'implémentation de support. Le réviseur ne rencontre jamais une référence à quelque chose qu'il n'a pas encore vu.
+C’est l’étape du jugement de conception. Le réviseur évalue si l’approche est adaptée au système, et non si le code est correct. Les préoccupations sont séquencées de haut en bas : l’intention de plus haut niveau en premier, puis l’implémentation de support. Le réviseur ne rencontre jamais une référence à quelque chose qu’il n’a pas encore vu.
 
 ### 3. Passage en revue des détails
 
-Une fois que le réviseur comprend la conception, le workflow met en évidence 2 à 5 endroits où une erreur aurait l’impact le plus important. Ceux-ci sont étiquetés par catégorie de risque — `[auth]`, `[schéma]`, `[facturation]`, `[API publique]`, `[sécurité]`, et d'autres — et ordonnés selon l'impact en cas d'erreur.
+Une fois que le réviseur comprend la conception, le workflow met en évidence 2 à 5 endroits où une erreur aurait l’impact le plus important. Ceux-ci sont étiquetés par catégorie de risque — `[auth]`, `[schéma]`, `[facturation]`, `[API publique]`, `[sécurité]`, et d’autres — et ordonnés selon l’impact en cas d’erreur.
 
-Ce n'est pas une chasse aux bugs. Les tests automatisés et la CI gèrent la correction. Le passage en revue des détails active la conscience du risque : « voici les endroits où se tromper coûte le plus cher ». Si le réviseur veut approfondir un domaine spécifique, il peut dire « approfondis [domaine] » pour une re-revue ciblée axée sur la correction.
+Ce n’est pas une chasse aux bugs. Les tests automatisés et la CI gèrent la correction. Le passage en revue des détails active la conscience du risque : « voici les endroits où se tromper coûte le plus cher ». Si le réviseur veut approfondir un domaine spécifique, il peut dire « approfondis [domaine] » pour une re-revue ciblée axée sur la correction.
 
 Si la spécification a passé des boucles de revues contradictoires (machine hardening), ces résultats sont également présentés ici — pas les bugs qui ont été corrigés, mais les décisions que la boucle de revue a signalées et dont le réviseur devrait être conscient.
 
 ### 4. Tests
 
-Propose 2 à 5 façons d'observer manuellement la modification en action. Pas des commandes de test automatisé — des observations manuelles qui renforcent la confiance au-delà de ce que toute suite de tests peut fournir. Une interaction UI à essayer, une commande CLI à lancer, une requête API à envoyer, avec les résultats attendus pour chacune.
+Propose 2 à 5 façons d’observer manuellement la modification en action. Pas des commandes de test automatisé — des observations manuelles qui renforcent la confiance au-delà de ce que toute suite de tests peut fournir. Une interaction UI à essayer, une commande CLI à lancer, une requête API à envoyer, avec les résultats attendus pour chacune.
 
-Si la modification n'a aucun comportement visible par l'utilisateur, il le dit. Pas de travail inventé.
+Si la modification n’a aucun comportement visible par l’utilisateur, il le dit. Pas de travail inventé.
 
 ### 5. Conclusion
 
-Le réviseur prend la décision : approuver, retravailler ou continuer la discussion. S'il approuve une PR, le workflow peut aider avec `gh pr review --approve`. S'il demande une refonte, il aide à diagnostiquer si le problème vient de l'approche, de la spécification ou de l'implémentation, et aide à rédiger un retour actionnable lié à des emplacements de code spécifiques.
+Le réviseur prend la décision : approuver, retravailler ou continuer la discussion. S’il approuve une PR, le workflow peut aider avec `gh pr review --approve`. S’il demande une refonte, il aide à diagnostiquer si le problème vient de l’approche, de la spécification ou de l’implémentation, et aide à rédiger un retour actionnable lié à des emplacements de code spécifiques.
 
-## C'est une conversation, pas un rapport
+## C’est une conversation, pas un rapport
 
-Le workflow présente chaque étape comme un point de départ, pas un mot final. Entre les étapes — ou au milieu d'une — vous pouvez parler au LLM, poser des questions, remettre en question son cadrage ou faire appel à d'autres skills pour obtenir une perspective différente :
+Le workflow présente chaque étape comme un point de départ, pas un mot final. Entre les étapes — ou au milieu d’une — vous pouvez parler au LLM, poser des questions, remettre en question son cadrage ou faire appel à d’autres skills pour obtenir une perspective différente :
 
-- **« lance l'élicitation avancée sur la gestion des erreurs »** — pousse le LLM à reconsidérer et affiner son analyse d'un domaine spécifique
-- **« active le party mode sur la sécurité de cette migration de schéma »** — fait intervenir plusieurs perspectives agentiques dans un débat ciblé
-- **« lance la revue de code »** — génère des résultats structurés avec analyse adversariale et cas limites
+- **« lance l’élicitation avancée sur la gestion des erreurs »** — pousse le LLM à reconsidérer et affiner son analyse d’un domaine spécifique
+- **« active le party mode sur la sécurité de cette migration de schéma »** — fait intervenir plusieurs perspectives agentiques dans un débat ciblé
+- **« lance la revue de code »** — génère des résultats structurés avec analyse adversariale et cas limites
 
-Le workflow checkpoint ne vous enferme pas dans un chemin linéaire. Il vous donne de la structure quand vous la souhaitez et s'efface quand vous voulez explorer. Les cinq étapes sont là pour s'assurer que vous voyez le tableau complet, mais la profondeur à laquelle vous allez à chaque étape — et les outils que vous y apportez — est entièrement entre vos mains.
+Le workflow checkpoint ne vous enferme pas dans un chemin linéaire. Il vous donne de la structure quand vous la souhaitez et s’efface quand vous voulez explorer. Les cinq étapes sont là pour s’assurer que vous voyez le tableau complet, mais la profondeur à laquelle vous allez à chaque étape — et les outils que vous y apportez — est entièrement entre vos mains.
 
-## L'historique de revue
+## L’historique de revue
 
-L'étape de visite guidée fonctionne mieux lorsqu'elle dispose d'un **ordre de revue suggéré** — une liste d'arrêts que l'auteur de la spécification a rédigée pour guider les réviseurs à travers la modification. Lorsqu'une spécification inclut cet ordre, le workflow l'utilise directement.
+L’étape de visite guidée fonctionne mieux lorsqu’elle dispose d’un **ordre de revue suggéré** — une liste d’arrêts que l’auteur de la spécification a rédigée pour guider les réviseurs à travers la modification. Lorsqu’une spécification inclut cet ordre, le workflow l’utilise directement.
 
-Lorsqu'aucun historique produit par l'auteur n'existe, le workflow en génère un à partir du diff et du contexte de la base de code. Un historique généré est de qualité inférieure à un historique produit par l'auteur, mais nettement supérieur à la lecture des modifications dans l'ordre des fichiers.
+Lorsqu’aucun historique produit par l’auteur n’existe, le workflow en génère un à partir du diff et du contexte de la base de code. Un historique généré est de qualité inférieure à un historique produit par l’auteur, mais nettement supérieur à la lecture des modifications dans l’ordre des fichiers.
 
-## Quand l'utiliser
+## Quand l’utiliser
 
-Le scénario principal est le passage de relais depuis `bmad-quick-dev` : l'implémentation est terminée, le fichier de spécification est ouvert dans votre éditeur avec un historique de revue ajouté, et vous devez décider si vous publiez. Dites « checkpoint » et c'est parti.
+Le scénario principal est le passage de relais depuis `bmad-quick-dev` : l’implémentation est terminée, le fichier de spécification est ouvert dans votre éditeur avec un historique de revue ajouté, et vous devez décider si vous publiez. Dites « checkpoint » et c’est parti.
 
-Il fonctionne aussi de manière autonome :
+Il fonctionne aussi de manière autonome :
 
-- **Revue d'une PR** — surtout celles avec plus de quelques fichiers ou des modifications transversales
-- **Prise en main d'une modification** — quand vous devez comprendre ce qui s'est passé sur une branche que vous n'avez pas écrite
+- **Revue d’une PR** — surtout celles avec plus de quelques fichiers ou des modifications transversales
+- **Prise en main d’une modification** — quand vous devez comprendre ce qui s’est passé sur une branche que vous n’avez pas écrite
 - **Revue de sprint** — le workflow peut récupérer les stories marquées `review` dans votre fichier de statut de sprint
 
-Invoquez-le en disant « checkpoint » ou « guide-moi à travers cette modification ». Il fonctionne dans n'importe quel terminal, mais vous en tirerez plus de parti dans un IDE — VS Code, Cursor ou similaire — car le workflow produit des références `chemin:ligne` à chaque étape. Dans un terminal intégré à un IDE, celles-ci sont cliquables, ce qui vous permet de sauter de fichier en fichier en suivant l'historique de revue.
+Invoquez-le en disant « checkpoint » ou « guide-moi à travers cette modification ». Il fonctionne dans n’importe quel terminal, mais vous en tirerez plus de parti dans un IDE — VS Code, Cursor ou similaire — car le workflow produit des références `chemin:ligne` à chaque étape. Dans un terminal intégré à un IDE, celles-ci sont cliquables, ce qui vous permet de sauter de fichier en fichier en suivant l’historique de revue.
 
-## Ce que ce n'est pas
+## Ce que ce n’est pas
 
-Checkpoint Preview ne remplace pas la revue automatisée. Il ne lance pas de linters, de vérificateurs de types ou de suites de tests. Il n'attribue pas de scores de sévérité et ne produit pas de verdicts pass/échec. C'est un guide de lecture qui aide un humain à appliquer son jugement là où cela compte le plus.
+Checkpoint Preview ne remplace pas la revue automatisée. Il ne lance pas de linters, de vérificateurs de types ou de suites de tests. Il n’attribue pas de scores de sévérité et ne produit pas de verdicts pass/échec. C’est un guide de lecture qui aide un humain à appliquer son jugement là où cela compte le plus.

docs/fr/explanation/established-projects-faq.md

@@ -1,35 +1,35 @@
 ---
 title: "FAQ Projets Existants"
-description: Questions courantes sur l'utilisation de la méthode BMad sur des projets existants
+description: Questions courantes sur l’utilisation de la méthode BMad sur des projets existants
 sidebar:
-  order: 12
+  order: 13
 ---
-Réponses rapides aux questions courantes sur l'utilisation de la méthode BMad (BMM) sur des projets existants.
+Réponses rapides aux questions courantes sur l’utilisation de la méthode BMad (BMM) sur des projets existants.
 
 ## Questions
 
-- [Dois-je d'abord exécuter document-project ?](#dois-je-dabord-exécuter-document-project)
-- [Que faire si j'oublie d'exécuter document-project ?](#que-faire-si-joublie-dexécuter-document-project)
-- [Puis-je utiliser Quick Dev pour les projets existants ?](#puis-je-utiliser-quick-dev-pour-les-projets-existants)
-- [Que faire si mon code existant ne suit pas les bonnes pratiques ?](#que-faire-si-mon-code-existant-ne-suit-pas-les-bonnes-pratiques)
+- [Dois-je d’abord exécuter document-project ?](#dois-je-dabord-exécuter-document-project)
+- [Que faire si j’oublie d’exécuter document-project ?](#que-faire-si-joublie-dexécuter-document-project)
+- [Puis-je utiliser Quick Dev pour les projets existants ?](#puis-je-utiliser-quick-dev-pour-les-projets-existants)
+- [Que faire si mon code existant ne suit pas les bonnes pratiques ?](#que-faire-si-mon-code-existant-ne-suit-pas-les-bonnes-pratiques)
 
-### Dois-je d'abord exécuter `document-project` ?
+### Dois-je d’abord exécuter `document-project` ?
 
-Hautement recommandé, surtout si :
+Hautement recommandé, surtout si :
 
 - Aucune documentation existante
 - La documentation est obsolète
 - Les agents IA ont besoin de contexte sur le code existant
 
-Vous pouvez l'ignorer si vous disposez d'une documentation complète et à jour incluant `docs/index.md` ou si vous utiliserez d'autres outils ou techniques pour aider à la découverte afin que l'agent puisse construire sur un système existant.
+Vous pouvez l’ignorer si vous disposez d’une documentation complète et à jour incluant `docs/index.md` ou si vous utiliserez d’autres outils ou techniques pour aider à la découverte afin que l’agent puisse construire sur un système existant.
 
-### Que faire si j'oublie d'exécuter `document-project` ?
+### Que faire si j’oublie d’exécuter `document-project` ?
 
 Ne vous inquiétez pas — vous pouvez le faire à tout moment. Vous pouvez même le faire pendant ou après un projet pour aider à maintenir la documentation à jour.
 
-### Puis-je utiliser Quick Dev pour les projets existants ?
+### Puis-je utiliser Quick Dev pour les projets existants ?
 
-Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
+Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
 
 - Détecter automatiquement votre pile technologique existante
 - Analyser les patterns de code existants
@@ -38,13 +38,13 @@ Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
 
 Parfait pour les corrections de bugs et les petites fonctionnalités dans des bases de code existantes.
 
-### Que faire si mon code existant ne suit pas les bonnes pratiques ?
+### Que faire si mon code existant ne suit pas les bonnes pratiques ?
 
-Quick Dev détecte vos conventions et demande : « Dois-je suivre ces conventions existantes ? » Vous décidez :
+Quick Dev détecte vos conventions et demande : « Dois-je suivre ces conventions existantes ? » Vous décidez :
 
 - **Oui** → Maintenir la cohérence avec la base de code actuelle
 - **Non** → Établir de nouvelles normes (documenter pourquoi dans la spécification technique)
 
 BMM respecte votre choix — il ne forcera pas la modernisation, mais la proposera.
 
-**Une question sans réponse ici ?** Veuillez [ouvrir un ticket](https://github.com/bmad-code-org/BMAD-METHOD/issues) ou poser votre question sur [Discord](https://discord.gg/gk8jAdXWmj) afin que nous puissions l'ajouter !
+**Une question sans réponse ici ?** Veuillez [ouvrir un ticket](https://github.com/bmad-code-org/BMAD-METHOD/issues) ou poser votre question sur [Discord](https://discord.gg/gk8jAdXWmj) afin que nous puissions l’ajouter !

docs/fr/explanation/forensic-investigation.md

@@ -1,157 +1,156 @@
 ---
 title: "Enquête de code"
-description: Comment bmad-investigate traite chaque problème comme une scène d'enquête, classe les preuves et produit un dossier structuré sur lequel les ingénieurs peuvent agir
+description: Comment bmad-investigate traite chaque problème comme une scène de crime, classe les preuves et produit un dossier structuré sur lequel les ingénieurs peuvent agir
 sidebar:
-  order: 9
+  order: 10
 ---
 
-Vous confiez à `bmad-investigate` un journal de plantage, une trace de pile, ou simplement un « ça marchait avant, plus
-maintenant ». Le skill prend le relais avec la discipline d'enquête le temps de l'exécution. Il ne se met pas à
-corriger. Il ouvre un dossier d'enquête.
+Vous confiez à `bmad-investigate` un journal de plantage, une stack trace, ou simplement un « ça marchait avant, plus
+maintenant ». Le skill prend le relais et applique la rigueur d’un enquêteur pendant toute son exécution. Il ne se lance pas dans
+la correction. Il ouvre un dossier d’enquête.
 
-Chaque constatation reçoit une note. Chaque hypothèse a un statut. Les fausses pistes sont conservées, pas effacées. Le
-livrable est un document qu'un autre ingénieur peut reprendre à froid.
+Chaque constatation est classée. Chaque hypothèse a un statut. Les fausses pistes sont conservées, pas effacées. Le
+livrable est un document qu’un autre ingénieur peut reprendre à froid.
 
-Cette page explique pourquoi l'enquête est une discipline à part entière, et ce que le skill apporte qu'un workflow de
-développement classique n'apporte pas.
+Cette page explique pourquoi l’enquête est une discipline à part entière, et ce que le skill apporte de plus qu’un flux de
+développement classique.
 
-## Le problème du « débogue, c'est tout »
+## Le problème avec « il suffit de déboguer »
 
-Le débogage classique mélange trois activités : examiner les preuves, raisonner sur la cause, et modifier le code pour
+Le débogage classique mélange trois activités : examiner les preuves, raisonner sur la cause, et modifier le code pour
 tester la théorie. Quand elles sont mélangées, deux modes de défaillance apparaissent.
 
-Le premier est le **verrouillage narratif**[^1]. La première histoire plausible devient la théorie de travail, et chaque
-observation est tordue pour la confirmer. Le bug reste non corrigé jusqu'à ce que quelqu'un abandonne et reparte de
-zéro. Des heures plus tard.
+Le premier est le **verrouillage narratif**[^1]. Le premier scénario plausible devient la théorie de travail, et chaque
+observation est déformée pour s’y ajuster. Le bug persiste jusqu’à ce que quelqu’un abandonne et reparte de zéro. Des
+heures plus tard.
 
-Le second est l'**amnésie probatoire**. Vous avez tracé quelque chose, l'avez écarté, mais n'avez pas écrit pourquoi.
-Deux jours plus tard, avec un regard frais, vous le retracez. Pire encore, un collègue reprend le bug et refait la même
-impasse que vous aviez déjà éliminée.
+Le second est l’**amnésie des preuves**. Vous avez suivi une piste, l’avez écartée, mais n’avez pas écrit pourquoi. Deux
+jours plus tard, avec un regard frais, vous la suivez à nouveau. Pire encore, un collègue reprend le bug et suit
+à nouveau la même fausse piste que vous aviez déjà écartée.
 
 La conception du skill est une réponse directe à ces deux modes.
 
 ## Classement des preuves
 
-Chaque constatation dans une enquête appartient à l'une de trois catégories.
+Chaque constatation dans une enquête appartient à l’une de trois catégories.
 
-- **Confirmé.** Directement observé dans les logs, le code ou les dumps ; cité avec une référence spécifique (un
-  `chemin:ligne`, un horodatage de log, un hash de commit). Si quelqu'un demande « comment le sais-tu ? », vous pointez
-  la citation.
-- **Déduit.** Découle logiquement de preuves confirmées ; la chaîne de raisonnement est explicite. Si une étape de la
-  chaîne est fausse, la déduction est fausse, et on peut voir précisément quelle étape.
-- **Hypothétique.** Plausible mais non confirmé. Énonce quelle preuve confirmerait ou réfuterait, et déclare d'avance ce
-  qui le clôturerait. Les hypothèses sont explicitement *non factuelles*.
+- **Confirmé.** Directement observée dans les logs, le code ou les dumps ; citée avec une référence spécifique (un
+  `chemin:ligne`, un horodatage de log, un hash de commit). Si quelqu’un demande « comment le savez-vous ? », vous indiquez
+  la référence.
+- **Déduit.** Découle logiquement de preuves confirmées ; la chaîne de raisonnement est explicite. Si une étape de la
+  chaîne est fausse, la déduction est fausse, et on peut voir précisément laquelle.
+- **Hypothétique.** Plausible mais non confirmé. Précise quelle preuve la confirmerait ou la réfuterait, et indique à
+  l’avance ce qui permettrait de la clore. Les hypothèses sont explicitement *des suppositions, pas des faits*.
 
-Le classement n'est pas une posture d'humilité. Il rend le dossier lisible. Un lecteur peut parcourir la section
-Confirmé pour savoir ce qui est vrai, la section Déduit pour savoir ce qui en découle, et la section Hypothétique pour
-savoir ce qui reste ouvert. Confondre les trois est la première raison pour laquelle les enquêtes dérapent.
+Le classement n’est pas là par modestie. Il rend le dossier lisible. Un lecteur peut parcourir la section
+**Confirmé** pour savoir ce qui est vrai, la section **Déduit** pour savoir ce qui en découle, et la section **Hypothétique** pour
+savoir ce qui reste ouvert. Confondre les trois est la raison la plus fréquente pour laquelle les enquêtes dérapent.
 
-## Tête de pont d'abord
+## Point d’ancrage d’abord
 
-L'enquête ne part jamais d'une théorie. Elle part d'une seule preuve confirmée et étend la zone à partir de là. Cette
-preuve peut être un message d'erreur précis, une trame de pile, ou une entrée de log horodatée.
+L’enquête ne part jamais d’une théorie. Elle part d’une seule preuve confirmée et s’étend à partir de là. Cette
+preuve peut être un message d’erreur précis, une stack trace, ou une entrée de log horodatée.
 
-C'est l'inverse de la manière dont les enquêtes se déroulent souvent : quelqu'un a une intuition, construit une théorie,
-puis cherche les preuves qui la soutiennent. L'intuition peut être correcte ; la *méthode* est fragile parce qu'elle
-fait du biais de confirmation[^2] le comportement par défaut.
+C’est l’inverse du déroulement habituel des enquêtes : quelqu’un a une intuition, construit une théorie,
+puis cherche les preuves qui la soutiennent. L’intuition peut être correcte ; la *méthode* est fragile parce qu’elle
+transforme le biais de confirmation[^2] en comportement par défaut.
 
-Une tête de pont est un fait sur lequel vous pouvez revenir quand le raisonnement devient flou. Si une déduction vous
-emmène quelque part d'étrange, vous pouvez remonter jusqu'à la tête de pont et essayer une autre branche. Sans elle,
-vous ne savez pas quelle étape annuler.
+Un point d’ancrage est un fait sur lequel vous pouvez revenir quand le raisonnement devient flou. Si une déduction vous
+mène à une conclusion inattendue, vous pouvez remonter au point d’ancrage et essayer une autre branche. Sans point
+d’ancrage, vous ne savez pas quelle étape annuler.
 
-Quand les preuves sont rares, le skill le dit et bascule en exploration guidée par hypothèses : formuler des hypothèses
+Quand les preuves sont rares, le skill le signale et bascule en exploration guidée par hypothèses : formuler des hypothèses
 à partir de ce qui est disponible, identifier ce qui testerait chacune, présenter une liste priorisée de données à
-collecter. L'absence de preuve est elle-même une constatation.
+collecter. L’absence de preuve est elle-même un constat.
 
 ## Discipline des hypothèses
 
 Les hypothèses ne sont jamais supprimées du dossier. Quand une preuve en confirme ou en réfute une, son champ **Statut**
-passe d'Ouvert à Confirmé ou Réfuté, et une **Résolution** explique quelle preuve a tranché.
+passe d’Ouvert à Confirmé ou Réfuté, et une **Résolution** explique quelle preuve a tranché.
 
-Cette règle a un coût réel : les dossiers grossissent. Le bénéfice est réel aussi. L'historique complet du raisonnement
+Cette règle a un coût réel : les dossiers grossissent. Le bénéfice est tout aussi réel. L’historique complet du raisonnement
 fait partie du livrable. Six mois plus tard, quand un bug similaire surgit, le prochain enquêteur peut lire le dossier
-original et voir quelles pistes ont déjà été éliminées et pourquoi. Sans cet historique, chaque nouvel enquêteur refait
-les mêmes impasses.
+original et voir quelles pistes ont déjà été éliminées et pourquoi. Sans cet historique, chaque nouvel enquêteur reprend
+les mêmes fausses pistes.
 
-Cela discipline aussi l'enquêteur du présent. Si vous ne pouvez pas supprimer une hypothèse fausse, vous devez la
-réfuter avec une preuve citée. L'abandonner discrètement quand elle devient gênante n'est plus une option.
+Cela discipline aussi l’enquêteur sur le moment. Si vous ne pouvez pas supprimer une hypothèse fausse, vous devez la
+réfuter avec une preuve citée. L’abandonner discrètement quand elle devient gênante n’est plus une option.
 
 ## Remettre en question la prémisse
 
-La description du problème par l'utilisateur est une hypothèse, pas un fait. « Le cache est cassé » est quelque chose
-que l'utilisateur *croit*. Avant que le skill ne construise une enquête autour, les affirmations techniques sont
-vérifiées de manière indépendante. Si la preuve contredit la prémisse, le rapport le dit directement.
+La description du problème par l’utilisateur est une hypothèse, pas un fait. « Le cache est cassé » est ce
+que l’utilisateur *croit*. Avant que le skill ne construise une enquête autour de cette prémisse, les affirmations
+techniques sont vérifiées de manière indépendante. Si la preuve contredit la prémisse, le rapport le signale sans détour.
 
-C'est l'instinct de l'enquêteur : le récit du témoin est une donnée, pas la vérité. Parfois le bug rapporté est réel
-mais mal étiqueté. Parfois le symptôme décrit est en aval d'une cause différente. Les enquêtes qui prennent la prémisse
-pour argent comptant diagnostiquent le mauvais défaut, et le bug revient sous une forme légèrement différente.
+C’est l’instinct de l’enquêteur : le récit du témoin est une donnée, pas la vérité. Parfois le bug rapporté est réel
+mais mal étiqueté. Parfois le symptôme décrit est en aval d’une cause différente. Les enquêtes qui prennent la prémisse
+pour argent comptant diagnostiquent le mauvais problème, et le bug revient sous une forme légèrement différente.
 
-## Une marche calibrée
+## Une approche calibrée
 
-Le skill est une seule procédure, pas deux modes. Il calibre la part d'investigation de défaut versus la part
-d'exploration de zone que l'entrée demande, sur une échelle continue.
+Le skill est une seule procédure, pas deux modes. Il ajuste en continu l’équilibre entre la recherche du défaut et l’exploration du code
+environnant, selon ce que le cas requiert.
 
-Un cas piloté par symptôme (un ticket, un plantage, un message d'erreur, un « ça marchait avant ») penche vers le suivi
-d'hypothèses, la reconstruction de la chronologie et une direction de correction. Un cas sans symptôme (comprendre un
+Un cas orienté symptôme (un ticket, un plantage, un message d’erreur, un « ça marchait avant ») penche vers le suivi
+d’hypothèses, la reconstruction de la chronologie et une piste de correction. Un cas sans symptôme (comprendre un
 module avant de le toucher, évaluer la réutilisabilité, bâtir un modèle mental) penche vers la cartographie
 entrées/sorties, le filtrage du flux de contrôle et un plan de vérification. La plupart des cas réels se situent quelque
-part entre les deux, et le dossier reflète l'équilibre que les preuves ont exigé.
+part entre les deux, et le dossier reflète l’équilibre que les preuves ont exigé.
 
-La discipline est la même quel que soit l'endroit de l'échelle où se situe un cas : tête de pont d'abord, classement
-des preuves, suivi des hypothèses, jamais effacer. La sortie est toujours
-`{implementation_artifacts}/investigations/{slug}-investigation.md`, avec les sections qui ne s'appliquent pas à un cas
-laissées vides ou omises.
+La discipline est la même quel que soit le positionnement du cas sur l’échelle : point d’ancrage d’abord, classement
+des preuves, suivi des hypothèses, rien n’est jamais effacé. La sortie est toujours
+`{implementation_artifacts}/investigations/{slug}-investigation.md`, les sections non
+pertinentes étant laissées vides ou omises.
 
-Quand un bug profond exige de comprendre un sous-système plus large, la procédure intègre en ligne les techniques de
+Quand un bug profond exige de comprendre un sous-système plus large, la procédure intègre directement les techniques de
 cartographie entrées/sorties, de filtrage du flux de contrôle, de raisonnement à rebours depuis les sorties et de
-traçage des frontières inter-composants[^3]. Le modèle de la zone atterrit dans le même dossier. Pas de changement de
+traçage des frontières inter-composants[^3]. La modélisation de la zone explorée figure dans le même dossier. Pas de changement de
 mode.
 
-## La méthodologie vit dans le skill
+## La méthodologie réside dans le skill
 
-La discipline d'enquête est une propriété du skill lui-même. Quiconque invoque `bmad-investigate` adopte la méthodologie
-et le style de communication pour l'exécution : précision clinique, langage centré sur la preuve, pas de prudence
-inutile, présentation en dossier de cas. Quand le skill se termine, l'appelant retrouve sa voix d'avant. Pas de
-changement de persona, juste un déplacement de ton issu des principes du skill.
+La discipline d’enquête est une propriété du skill lui-même. Quiconque invoque `bmad-investigate` adopte la méthodologie
+et le style de communication pendant l’exécution : précision clinique, langage centré sur la preuve, pas de prudence
+inutile, structuration en dossier d’enquête. Quand le skill se termine, l’appelant retrouve sa voix habituelle. Pas de
+changement de persona, juste un ajustement de ton dicté par les principes du skill.
 
-Cela compte parce que l'enquête et l'implémentation récompensent des instincts différents. Les enquêteurs sont lents et
-précis. Les implémenteurs sont rapides et confiants. Le même cerveau faisant les deux dans une seule session finit par
-mal faire les deux. Le skill délimite la posture d'enquête en ligne, sans changement de contexte vers une identité
-séparée.
+C’est important car l’enquête et l’implémentation sollicitent des réflexes différents. Les enquêteurs sont lents et
+précis. Les développeurs sont rapides et confiants. Essayer de faire les deux dans une même session finit
+généralement par mal faire l’un et l’autre. Le skill délimite la posture d’enquête directement dans le flux de travail, sans basculer dans une
+identité distincte.
 
 ## Ce que vous obtenez
 
-Un fichier d'enquête achevé :
+Un dossier d’enquête complet :
 
-- Sépare les constatations Confirmées (avec citations) des Déductions et des Hypothèses
-- Préserve toutes les hypothèses jamais formulées, avec leur Statut final et leur Résolution
+- Sépare les constatations **Confirmées** (avec citations) des **Déductions** et des **Hypothèses**
+- Préserve l’intégralité des hypothèses formulées, avec leur Statut final et leur Résolution
 - Reconstruit une chronologie des événements à partir de plusieurs sources de preuves
-- Identifie les lacunes de données et ce qu'elles résoudraient
-- Fournit des conclusions actionnables ancrées dans les preuves
+- Identifie les lacunes de données et ce qu’elles permettraient de résoudre
+- Fournit des conclusions exploitables ancrées dans les preuves
 - Inclut un plan de reproduction quand une cause racine est identifiée
-- Maintient un backlog d'enquête de pistes encore à explorer
+- Maintient un backlog des pistes restant à explorer
 
-Donnez-le à un ingénieur qui n'était pas là, et il comprend ce qui s'est passé, ce qui est connu, et ce qui reste
-incertain. C'est la barre.
+Transmettez-le à un ingénieur qui n’était pas là, et il comprendra ce qui s’est passé, ce qui est connu, et ce qui reste
+incertain. C’est le standard visé.
 
-## L'idée plus large
+## La vision d’ensemble
 
-La plupart du « débogage par IA » d'aujourd'hui mélange preuves, raisonnement et changements de code en un seul flux de
-texte plausible. Le signal est difficile à trouver, les impasses se répètent, et le dossier, s'il en existe un, est un
-journal de chat que personne ne veut lire.
+La plupart des approches de « débogage par IA » actuelles mêlent preuves, raisonnement et changements de code en un seul
+flux de texte plausible. Le signal est difficile à trouver, les impasses se répètent, et le dossier, s’il en existe un, est
+un historique de conversation que personne ne veut lire.
 
-`bmad-investigate` traite l'enquête comme une discipline avec son propre livrable. La preuve a une note. Les hypothèses
-ont un statut. Les fausses pistes sont documentées, pas effacées. Le dossier survit à la session.
+`bmad-investigate` traite l’enquête comme une discipline avec son propre livrable. Chaque preuve est classée. Les
+hypothèses ont un statut. Les fausses pistes sont documentées, pas effacées. Le dossier survit à la session.
 
-Quand le prochain bug ressemblant à un que vous avez déjà vu apparaîtra, vous aurez un point de départ qui ne sera pas
-une invite vide.
+Quand un bug similaire réapparaîtra, vous aurez un point de départ concret, pas un prompt vide.
 
 ## Glossaire
 
-[^1]: **Verrouillage narratif** : phénomène cognitif par lequel un raisonnement adopte la première explication plausible
-et l'enrichit progressivement, devenant de plus en plus difficile à abandonner même face à des preuves contraires.
-[^2]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui
+[^1]: **Verrouillage narratif** : phénomène cognitif par lequel un raisonnement adopte la première explication plausible
+et l’enrichit progressivement, devenant de plus en plus difficile à abandonner même face à des preuves contraires.
+[^2]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui
 confirment des croyances préexistantes, tout en ignorant ou minimisant celles qui les contredisent.
-[^3]: **Passage de frontière** : transition entre deux zones d'exécution distinctes (langage, processus, machine,
-client/serveur, code/configuration). Les frontières concentrent les bugs car chaque côté suppose que l'autre s'est
+[^3]: **Passage de frontière** : transition entre deux zones d’exécution distinctes (langage, processus, machine,
+client/serveur, code/configuration). Les frontières concentrent les bugs car chaque côté suppose que l’autre s’est
 comporté comme documenté.

docs/fr/explanation/named-agents.md

@@ -0,0 +1,94 @@
+---
+title: "Agents nommés"
+description: Pourquoi les agents BMad ont des noms, des personas et des options de personnalisation — et ce que cela permet par rapport aux alternatives basées sur des menus ou des prompts
+sidebar:
+  order: 1
+---
+
+Vous dites « Hey Mary, brainstormons » et Mary s’active. Elle vous salue par votre nom, dans la langue que vous avez configurée, avec son persona distinctif. Elle vous rappelle que `bmad-help` est toujours disponible. Puis elle saute le menu et se lance directement dans le brainstorming — parce que votre intention était claire.
+
+Cette page explique ce qui se passe réellement et pourquoi BMad est conçu ainsi.
+
+## Le tabouret à trois pieds
+
+Le modèle d’agent de BMad repose sur trois primitives qui s’articulent :
+
+| Primitive            | Ce qu’elle apporte                                                                                                                                                                      | Où elle se trouve                                                                                                      |
+|----------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------|
+| **Skill**            | Capacité — une chose distincte que l’assistant peut faire (brainstormer, rédiger un PRD, implémenter une story)                                                                         | `.claude/skills/{skill-name}/SKILL.md` (ou l’équivalent de votre IDE)                                                  |
+| **Agent nommé**      | Continuité du persona — une identité reconnaissable qui englobe un menu de skills associés avec une voix, des principes et des repères visuels cohérents                                | Skills dont le répertoire commence par `bmad-agent-*`                                                                  |
+| **Personnalisation** | Rendre le système vôtre — des overrides qui remodèlent le comportement d’un agent, ajoutent des intégrations MCP, remplacent des templates, intègrent les conventions de l’organisation | `_bmad/custom/{skill-name}.toml` (overrides d’équipe, versionnés dans git) et `.user.toml` (personnel, ignoré par git) |
+
+Retirez l’un des pieds et l’expérience s’effondre :
+
+- Skills sans agents → des listes de capacités que l’utilisateur doit parcourir par nom ou par code
+- Agents sans skills → des personas sans rien à faire
+- Pas de personnalisation → chaque utilisateur reçoit le même comportement par défaut, obligeant à forker pour tout besoin spécifique à l’organisation
+
+## Ce que les agents nommés vous apportent
+
+BMad embarque six agents nommés, chacun ancré à une phase de la méthode BMad :
+
+| Agent                              | Phase          | Module                                                                                                                  |
+|------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------|
+| 📊 **Mary**, Analyste d’affaires   | Analyse        | étude de marché, brainstorming, product briefs, PRFAQs                                                                   |
+| 📚 **Paige**, Rédactrice technique | Analyse        | documentation de projet, diagrammes, validation de docs                                                                  |
+| 📋 **John**, Chef de produit       | Planification  | création de PRD, décomposition epic/story, vérification de la préparation à l’implémentation                             |
+| 🎨 **Sally**, Designer UX          | Planification  | spécifications de design UX                                                                                              |
+| 🏗️ **Winston**, Architecte système  | Solutioning    | architecture technique, vérifications d’alignement                                                                     |
+| 💻 **Amelia**, Ingénieure senior   | Implémentation | exécution de stories, quick-dev, revue de code, planification de sprint, [enquête de code](./forensic-investigation.md)  |
+
+Chacun possède une identité codée en dur (nom, titre, domaine) et une couche personnalisable (rôle, principes, style de communication, icône, menu). Vous pouvez réécrire les principes de Mary ou ajouter des éléments de menu ; vous ne pouvez pas la renommer — c’est délibéré. La reconnaissance de marque persiste après personnalisation pour que « hey Mary » active toujours l’analyste, indépendamment de la façon dont une équipe a façonné son comportement.
+
+## Le flux d’activation
+
+Quand vous invoquez un agent nommé, huit étapes s’exécutent dans l’ordre :
+
+1. **Résoudre le bloc agent** — fusionner le `customize.toml` livré avec les overrides d’équipe et personnels, via un résolveur Python utilisant `tomllib` de la bibliothèque standard
+2. **Exécuter les étapes préliminaires** — tout comportement préalablement configuré par l’équipe
+3. **Adopter le persona** — identité codée en dur ainsi que rôle personnalisé, style de communication, principes
+4. **Charger les faits persistants** — règles d’organisation, notes de conformité, éventuellement des fichiers chargés via un préfixe `file:` (ex. `file:{project-root}/docs/project-context.md`)
+5. **Charger la configuration** — nom d’utilisateur, langue de communication, langue de sortie, chemins des artefacts
+6. **Saluer** — personnalisé, dans la langue configurée, avec le préfixe emoji de l’agent pour identifier d’un coup d’œil qui parle
+7. **Exécuter les étapes de finalisation** — toute configuration post-salutation que l’équipe a définie
+8. **Aiguiller ou présenter le menu** — si votre message d’ouverture correspond à un élément de menu, aller directement ; sinon afficher le menu et attendre une saisie
+
+L’étape 8, c’est là que la magie opère. « Hey Mary, brainstormons » évite l’affichage du menu parce que `bmad-brainstorming` correspond évidemment à `BP` dans le menu de Mary. Si vous dites quelque chose d’ambigu, elle demande une fois, brièvement, sans en faire un rituel de confirmation. Si rien ne correspond, elle poursuit la conversation normalement.
+
+## Pourquoi pas simplement un menu ?
+
+Les menus obligent l’utilisateur à aller chercher l’outil. Vous devez retenir que le brainstorming se trouve sous le code `BP` chez l’agent analyste, pas chez l’agent PM, et savoir quel persona possède quelles capacités. C’est une charge cognitive que l’outil vous fait porter.
+
+Les agents nommés inversent la logique. Vous dites ce que vous voulez, à qui, avec les mots qui vous semblent naturels. L’agent sait qui il est et ce qu’il fait. Quand votre intention est suffisamment claire, il agit simplement.
+
+Le menu reste disponible comme solution de secours — affiché quand vous explorez, ignoré quand ce n’est pas le cas.
+
+## Pourquoi pas simplement un prompt libre ?
+
+Les prompts libres supposent que vous connaissez les mots magiques. « Aide-moi à brainstormer » pourrait fonctionner, mais « explorons mon idée de SaaS » pourrait ne pas fonctionner, et les résultats dépendent de la façon dont vous avez formulé la demande. Vous devenez responsable de l’ingénierie du prompt.
+
+Les agents nommés ajoutent de la structure sans restreindre la liberté. Le persona reste cohérent, les capacités sont découvrables, et `bmad-help` est toujours à portée de commande. Vous n’avez pas à deviner ce que l’agent peut faire, et vous n’avez pas besoin d’un manuel pour l’utiliser non plus.
+
+## La personnalisation comme principe fondamental
+
+Le modèle de personnalisation est ce qui permet à tout cela de passer à l’échelle au-delà d’un seul développeur.
+
+Chaque agent embarque un fichier `customize.toml` avec des valeurs par défaut judicieuses. Les équipes versionnent des overrides dans `_bmad/custom/bmad-agent-{role}.toml`. Les individus peuvent superposer des préférences personnelles dans `.user.toml` (ignoré par git). Le résolveur fusionne les trois couches à l’activation avec des règles structurelles prévisibles.
+
+La plupart des utilisateurs ne rédigent jamais ces fichiers à la main. Le skill `bmad-customize` guide le choix de la cible, la sélection du périmètre agent vs workflow, la rédaction de l’override et la vérification de la fusion — pour que la surface de personnalisation reste accessible à quiconque comprend son intention, pas seulement à ceux qui maîtrisent le TOML.
+
+Exemple concret : une équipe versionne dans git un seul fichier demandant à Amelia d’utiliser systématiquement l’outil MCP Context7 pour la documentation des bibliothèques et de se rabattre sur Linear quand une story n’est pas dans la liste locale des epics. Chaque workflow de développement qu’Amelia lance (dev-story, quick-dev, create-story, code-review) hérite de ce comportement, sans modification du code ni duplication par workflow.
+
+Il existe aussi une seconde surface de personnalisation pour les préoccupations *transversales* : la configuration centrale `_bmad/config.toml` et `_bmad/config.user.toml` (tous deux gérés par l’installateur, reconstruits à partir du `module.yaml` de chaque module) plus `_bmad/custom/config.toml` (équipe, versionné dans git) et `_bmad/custom/config.user.toml` (personnel, ignoré par git) pour les overrides. C’est là que se trouve le **registre des agents** — les descripteurs légers que les consommateurs du registre comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation` lisent pour savoir qui est disponible et comment l’incarner. Redéfinissez l’image d’un agent pour toute l’organisation avec un override d’équipe ; ajoutez des personnages fictifs (Kirk, Spock, un persona expert du domaine) comme expériences personnelles via l’override `.user.toml` — sans toucher aucun dossier de skill. Le fichier par skill façonne la façon dont Mary *se comporte* quand elle s’active ; la configuration centrale façonne la façon dont les autres skills *la perçoivent* quand ils consultent le registre.
+
+Pour la surface de personnalisation complète et des exemples concrets, consultez :
+
+- [Comment personnaliser BMad](../how-to/customize-bmad.md) — la référence sur ce qui est personnalisable et comment fonctionne la fusion
+- [Comment étendre BMad pour votre organisation](../how-to/expand-bmad-for-your-org.md) — six recettes pratiques couvrant les règles globales des agents, les conventions de workflow, la publication externe, les remplacements de templates et la personnalisation du registre des agents
+- Skill `bmad-customize` — l’assistant de rédaction guidée qui transforme une intention en fichier d’override correctement placé et vérifié
+
+## L’idée plus grande
+
+La plupart des assistants IA aujourd’hui sont soit des menus, soit des prompts, et les deux déplacent la charge cognitive vers l’utilisateur. Les agents nommés associés à des skills personnalisables vous permettent de parler à un coéquipier qui connaît déjà le travail, et laissent votre organisation façonner ce coéquipier sans forker.
+
+La prochaine fois que vous tapez « Hey Mary, brainstormons » et qu’elle se met directement au travail, remarquez ce qui ne s’est pas produit. Il n’y a eu ni commande slash, ni menu à parcourir, ni rappel maladroit de ce qu’elle peut faire. Cette absence, c’est le design.

docs/fr/explanation/party-mode.md

@@ -2,18 +2,18 @@
 title: "Party Mode"
 description: Collaboration multi-agents - regroupez tous vos agents IA dans une seule conversation
 sidebar:
-  order: 10
+  order: 11
 ---
 
 Regroupez tous vos agents IA dans une seule conversation.
 
-## Qu'est-ce que le Party Mode ?
+## Qu’est-ce que le Party Mode ?
 
-Lancez `bmad-party-mode` et vous avez toute votre équipe IA dans une même pièce - PM, Architecte, Développeur, Designer UX, selon vos besoins. BMad Master orchestre, en sélectionnant les agents pertinents à chaque message. Les agents répondent en personnage, sont en accord ou désaccord, et construisent sur les idées des autres.
+Lancez `bmad-party-mode` et vous avez toute votre équipe IA dans une même pièce - PM, Architecte, Développeur, Designer UX, selon vos besoins. Le Party Mode orchestre la discussion en sélectionnant, à chaque message, les agents pertinents parmi ceux installés. Les agents répondent en personnage, sont en accord ou désaccord, et construisent sur les idées des autres.
 
-La conversation continue aussi longtemps que vous le souhaitez. Posez des questions de suivi, remettez en question les réponses, redirigez la discussion - c'est un véritable échange avec vos agents jusqu'à ce que vous ayez terminé.
+La conversation continue aussi longtemps que vous le souhaitez. Posez des questions de suivi, remettez en question les réponses, redirigez la discussion - c’est un véritable échange avec vos agents jusqu’à ce que vous ayez terminé.
 
-**Idéal pour :**
+**Idéal pour**
 
 - Les grandes décisions avec des compromis
 - Les sessions de brainstorming
@@ -24,35 +24,35 @@ La conversation continue aussi longtemps que vous le souhaitez. Posez des questi
 
 ### Remettre en question une mauvaise architecture
 
-**Vous :** « Ok l'équipe, notre dernier sprint a été un désastre. Le service d'authentification est tombé trois fois. Qui a cafouillé ? »
+**Vous :** « Ok l’équipe, notre dernier sprint a été un désastre. Le service d’authentification est tombé trois fois. Qui a cafouillé ? »
 
-**Architecte :** « Le design était solide - authentification distribuée avec des fallbacks appropriés. Si l'implémentation a dévié des specs... »
+**Architecte :** « Le design était solide - authentification distribuée avec des fallbacks appropriés. Si l’implémentation a dévié des specs... »
 
-**Développeur :** « J'ai suivi le document d'architecture à la lettre. Les specs ne prenaient pas en compte les race conditions lors de l'invalidation de sessions concurrentes. »
+**Développeur :** « J’ai suivi le document d’architecture à la lettre. Les specs ne prenaient pas en compte les race conditions lors de l’invalidation de sessions concurrentes. »
 
-**PM :** « Vous avez tous les deux raté le vrai problème - nous n'avons pas validé les exigences de gestion des sessions dans le PRD. C'est de ma faute de ne pas l'avoir repéré. »
+**PM :** « Vous avez tous les deux raté le vrai problème - nous n’avons pas validé les exigences de gestion des sessions dans le PRD. C’est de ma faute de ne pas l’avoir repéré. »
 
-**TEA :** « Et j'aurais dû le repérer dans les tests d'intégration. Les scénarios de test ne couvraient pas l'invalidation concurrente. »
+**TEA :** « Et j’aurais dû le repérer dans les tests d’intégration. Les scénarios de test ne couvraient pas l’invalidation concurrente. »
 
 ### Brainstorming créatif
 
-**Vous :** « Comment rendre l'onboarding magique au lieu d'ennuyeux ? »
+**Vous :** « Comment rendre l’onboarding magique au lieu d’ennuyeux ? »
 
-**Designer UX :** « Commençons par la divulgation progressive - révélons les fonctionnalités au fur et à mesure que les utilisateurs en ont besoin, pas d'un coup dans un tutoriel. »
+**Designer UX :** « Commençons par la divulgation progressive - révélons les fonctionnalités au fur et à mesure que les utilisateurs en ont besoin, pas d’un coup dans un tutoriel. »
 
-**Storyteller :** « Et si l'onboarding était une histoire ? Chaque étape révèle le parcours d'un personnage - l'utilisateur EST le héros. »
+**Storyteller :** « Et si l’onboarding était une histoire ? Chaque étape révèle le parcours d’un personnage - l’utilisateur EST le héros. »
 
-**Game Designer :** « En partant de là - et si la première "quête" consistait à résoudre un vrai problème utilisateur ? Ils apprennent en faisant quelque chose d'utile. »
+**Game Designer :** « En partant de là - et si la première « quête » consistait à résoudre un vrai problème utilisateur ? Ils apprennent en faisant quelque chose d’utile. »
 
 ### Décision technique
 
-**Vous :** « Monolithe ou microservices pour le MVP[^1] ? »
+**Vous :** « Monolithe ou microservices pour le MVP[^1] ? »
 
-**Architecte :** « Commencez en monolithe. Les microservices ajoutent une complexité dont vous n'avez pas besoin à 1000 utilisateurs. »
+**Architecte :** « Commencez en monolithe. Les microservices ajoutent une complexité dont vous n’avez pas besoin à 1 000 utilisateurs. »
 
-**PM :** « D'accord. Le time-to-market[^2] compte plus que la scalabilité théorique. »
+**PM :** « D’accord. Le time-to-market[^2] compte plus que la scalabilité théorique. »
 
-**Développeur :** « Monolithe avec des frontières de modules claires. On pourra extraire des services plus tard si nécessaire. »
+**Développeur :** « Monolithe avec des frontières de modules claires. On pourra extraire des services plus tard si nécessaire. »
 
 :::tip[Meilleures décisions]
 De meilleures décisions grâce à des perspectives diverses. Bienvenue dans le party mode.
@@ -60,5 +60,5 @@ De meilleures décisions grâce à des perspectives diverses. Bienvenue dans le
 
 ## Glossaire
 
-[^1]: MVP (Minimum Viable Product) : version minimale d'un produit contenant juste assez de fonctionnalités pour être utilisée par des utilisateurs précoces et valider les hypothèses de marché avant d'investir dans un développement plus complet.
-[^2]: Time-to-market : délai nécessaire pour concevoir, développer et lancer un produit sur le marché. Plus ce délai est court, plus l'entreprise peut prendre de l'avance sur ses concurrents.
+[^1]: MVP (Minimum Viable Product) : version minimale d’un produit contenant juste assez de fonctionnalités pour être utilisée par des utilisateurs précoces et valider les hypothèses de marché avant d’investir dans un développement plus complet.
+[^2]: Time-to-market : délai nécessaire pour concevoir, développer et lancer un produit sur le marché. Plus ce délai est court, plus l’entreprise peut prendre de l’avance sur ses concurrents.

docs/fr/explanation/preventing-agent-conflicts.md

@@ -1,48 +1,48 @@
 ---
 title: "Prévention des conflits entre agents"
-description: Comment l'architecture empêche les conflits lorsque plusieurs agents implémentent un système
+description: Comment l’architecture empêche les conflits lorsque plusieurs agents implémentent un système
 sidebar:
-  order: 5
+  order: 6
 ---
 
-Lorsque plusieurs agents IA implémentent différentes parties d'un système, ils peuvent prendre des décisions techniques contradictoires. La documentation d'architecture prévient cela en établissant des standards partagés.
+Lorsque plusieurs agents IA implémentent différentes parties d’un système, ils peuvent prendre des décisions techniques contradictoires. La documentation d’architecture prévient cela en établissant des standards partagés.
 
 ## Types de conflits courants
 
-### Conflits de style d'API
+### Conflits de style d’API
 
 Sans architecture :
-- L'agent A utilise REST avec `/users/{id}`
-- L'agent B utilise des mutations GraphQL
-- Résultat : Patterns d'API incohérents, consommateurs confus
+- L’agent A utilise REST avec `/users/{id}`
+- L’agent B utilise des mutations GraphQL
+- Résultat : Patterns d’API incohérents, consommateurs confus
 
 Avec architecture :
-- L'ADR[^1] spécifie : « Utiliser GraphQL pour toute communication client-serveur »
+- L’ADR[^1] spécifie : « Utiliser GraphQL pour toute communication client-serveur »
 - Tous les agents suivent le même pattern
 
 ### Conflits de conception de base de données
 
 Sans architecture :
-- L'agent A utilise des noms de colonnes en snake_case
-- L'agent B utilise des noms de colonnes en camelCase
-- Résultat : Schéma incohérent, requêtes illisibles
+- L’agent A utilise des noms de colonnes en snake_case
+- L’agent B utilise des noms de colonnes en camelCase
+- Résultat : Schéma incohérent, requêtes illisibles
 
 Avec architecture :
 - Un document de standards spécifie les conventions de nommage
 - Tous les agents suivent les mêmes patterns
 
-### Conflits de gestion d'état
+### Conflits de gestion d’état
 
 Sans architecture :
-- L'agent A utilise Redux pour l'état global
-- L'agent B utilise React Context
-- Résultat : Multiples approches de gestion d'état, complexité
+- L’agent A utilise Redux pour l’état global
+- L’agent B utilise React Context
+- Résultat : Multiples approches de gestion d’état, complexité
 
 Avec architecture :
-- L'ADR spécifie l'approche de gestion d'état
+- L’ADR spécifie l’approche de gestion d’état
 - Tous les agents implémentent de manière cohérente
 
-## Comment l'architecture prévient les conflits
+## Comment l’architecture prévient les conflits
 
 ### 1. Décisions explicites via les ADR[^1]
 
@@ -55,21 +55,21 @@ Chaque choix technologique significatif est documenté avec :
 
 ### 2. Guidance spécifique aux FR/NFR[^2]
 
-L'architecture associe chaque exigence fonctionnelle à une approche technique :
-- FR-001 : Gestion des utilisateurs → Mutations GraphQL
-- FR-002 : Application mobile → Requêtes optimisées
+L’architecture associe chaque exigence fonctionnelle à une approche technique :
+- FR-001 : Gestion des utilisateurs → Mutations GraphQL
+- FR-002 : Application mobile → Requêtes optimisées
 
 ### 3. Standards et conventions
 
 Documentation explicite de :
 - La structure des répertoires
 - Les conventions de nommage
-- L'organisation du code
+- L’organisation du code
 - Les patterns de test
 
-## L'architecture comme contexte partagé
+## L’architecture comme contexte partagé
 
-Considérez l'architecture comme le contexte partagé que tous les agents lisent avant d'implémenter :
+Considérez l’architecture comme le contexte partagé que tous les agents lisent avant d’implémenter :
 
 ```text
 PRD : "Que construire"
@@ -88,18 +88,18 @@ Résultat : Implémentation cohérente
 Décisions courantes qui préviennent les conflits :
 
 | Sujet            | Exemple de décision                          |
-| ---------------- | -------------------------------------------- |
-| Style d'API      | GraphQL vs REST vs gRPC                      |
+|------------------|----------------------------------------------|
+| Style d’API      | GraphQL vs REST vs gRPC                      |
 | Base de données  | PostgreSQL vs MongoDB                        |
 | Authentification | JWT vs Sessions                              |
-| Gestion d'état   | Redux vs Context vs Zustand                  |
+| Gestion d’état   | Redux vs Context vs Zustand                  |
 | Styling          | CSS Modules vs Tailwind vs Styled Components |
 | Tests            | Jest + Playwright vs Vitest + Cypress        |
 
 ## Anti-patterns à éviter
 
 :::caution[Erreurs courantes]
-- **Décisions implicites** — « On décidera du style d'API au fur et à mesure » mène à l'incohérence
+- **Décisions implicites** — « On décidera du style d’API au fur et à mesure » mène à l’incohérence
 - **Sur-documentation** — Documenter chaque choix mineur cause une paralysie analytique
 - **Architecture obsolète** — Les documents écrits une fois et jamais mis à jour poussent les agents à suivre des patterns dépassés
 :::
@@ -107,7 +107,7 @@ Décisions courantes qui préviennent les conflits :
 :::tip[Approche correcte]
 - Documenter les décisions qui traversent les frontières des epics
 - Se concentrer sur les zones sujettes aux conflits
-- Mettre à jour l'architecture au fur et à mesure des apprentissages
+- Mettre à jour l’architecture au fur et à mesure des apprentissages
 - Utiliser `bmad-correct-course` pour les changements significatifs
 :::
 

docs/fr/explanation/project-context.md

@@ -2,48 +2,48 @@
 title: "Contexte du Projet"
 description: Comment project-context.md guide les agents IA avec les règles et préférences de votre projet
 sidebar:
-  order: 11
+  order: 12
 ---
 
-Le fichier `project-context.md` est le guide d'implémentation de votre projet pour les agents IA. Similaire à une « constitution » dans d'autres systèmes de développement, il capture les règles, les patterns et les préférences qui garantissent une génération de code cohérente à travers tous les workflows.
+Le fichier `project-context.md` est le guide d’implémentation de votre projet pour les agents IA. Similaire à une « constitution » dans d’autres systèmes de développement, il capture les règles, les patterns et les préférences qui garantissent une génération de code cohérente à travers tous les workflows.
 
-## Ce Qu'il Fait
+## Ce Qu’il Fait
 
-Les agents IA prennent constamment des décisions d'implémentation — quels patterns suivre, comment structurer le code, quelles conventions utiliser. Sans guidance claire, ils peuvent :
+Les agents IA prennent constamment des décisions d’implémentation — quels patterns suivre, comment structurer le code, quelles conventions utiliser. Sans guidance claire, ils peuvent :
 - Suivre des bonnes pratiques génériques qui ne correspondent pas à votre codebase
 - Prendre des décisions incohérentes selon les différentes stories
-- Passer à côté d'exigences ou de contraintes spécifiques au projet
+- Passer à côté d’exigences ou de contraintes spécifiques au projet
 
 Le fichier `project-context.md` résout ce problème en documentant ce que les agents doivent savoir dans un format concis et optimisé pour les LLM.
 
 ## Comment Ça Fonctionne
 
-Chaque workflow d'implémentation charge automatiquement `project-context.md` s'il existe. Le workflow architecte le charge également pour respecter vos préférences techniques lors de la conception de l'architecture.
+Chaque workflow d’implémentation charge automatiquement `project-context.md` s’il existe. Le workflow architecte le charge également pour respecter vos préférences techniques lors de la conception de l’architecture.
 
-**Chargé par ces workflows :**
+**Chargé par ces workflows :**
 - `bmad-create-architecture` — respecte les préférences techniques pendant la phase de solutioning
 - `bmad-create-story` — informe la création de stories avec les patterns du projet
-- `bmad-dev-story` — guide les décisions d'implémentation
+- `bmad-dev-story` — guide les décisions d’implémentation
 - `bmad-code-review` — valide par rapport aux standards du projet
-- `bmad-quick-dev` — applique les patterns lors de l'implémentation des spécifications techniques
+- `bmad-quick-dev` — applique les patterns lors de l’implémentation des spécifications techniques
 - `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` — fournit le contexte global du projet
 
 ## Quand Le Créer
 
-Le fichier `project-context.md` est utile à n'importe quel stade d'un projet :
+Le fichier `project-context.md` est utile à n’importe quel stade d’un projet :
 
 | Scénario                                 | Quand Créer                                         | Objectif                                                                              |
 |------------------------------------------|-----------------------------------------------------|---------------------------------------------------------------------------------------|
-| **Nouveau projet, avant l'architecture** | Manuellement, avant `bmad-create-architecture`      | Documenter vos préférences techniques pour que l'architecte les respecte              |
-| **Nouveau projet, après l'architecture** | Via `bmad-generate-project-context` ou manuellement | Capturer les décisions d'architecture pour les agents d'implémentation                |
+| **Nouveau projet, avant l’architecture** | Manuellement, avant `bmad-create-architecture`      | Documenter vos préférences techniques pour que l’architecte les respecte              |
+| **Nouveau projet, après l’architecture** | Via `bmad-generate-project-context` ou manuellement | Capturer les décisions d’architecture pour les agents d’implémentation                |
 | **Projet existant**                      | Via `bmad-generate-project-context`                 | Découvrir les patterns existants pour que les agents suivent les conventions établies |
-| **Projet Quick Dev**                   | Avant ou pendant `bmad-quick-dev`                   | Garantir que l'implémentation rapide respecte vos patterns                            |
+| **Projet Quick Dev**                     | Avant ou pendant `bmad-quick-dev`                   | Garantir que l’implémentation rapide respecte vos patterns                            |
 
 :::tip[Recommandé]
-Pour les nouveaux projets, créez-le manuellement avant l'architecture si vous avez de fortes préférences techniques. Sinon, générez-le après l'architecture pour capturer ces décisions.
+Pour les nouveaux projets, créez-le manuellement avant l’architecture si vous avez de fortes préférences techniques. Sinon, générez-le après l’architecture pour capturer ces décisions.
 :::
 
-## Ce Qu'il Contient
+## Ce Qu’il Contient
 
 Le fichier a deux sections principales :
 
@@ -88,7 +88,7 @@ Documente les patterns et conventions que les agents pourraient autrement manque
 - Les nouvelles routes suivent le modèle de routage basé sur les fichiers dans `/src/app/`
 ```
 
-Concentrez-vous sur ce qui est **non évident** — des choses que les agents pourraient ne pas déduire en lisant des extraits de code. Ne documentez pas les pratiques standard qui s'appliquent universellement.
+Concentrez-vous sur ce qui est **non évident** — des choses que les agents pourraient ne pas déduire en lisant des extraits de code. Ne documentez pas les pratiques standard qui s’appliquent universellement.
 
 ## Création du Fichier
 
@@ -104,9 +104,9 @@ mkdir -p _bmad-output
 touch _bmad-output/project-context.md
 ```
 
-Éditez-le avec votre pile technologique et vos règles d'implémentation. Les workflows architecture et implémentation le trouveront et le chargeront automatiquement.
+Éditez-le avec votre pile technologique et vos règles d’implémentation. Les workflows architecture et implémentation le trouveront et le chargeront automatiquement.
 
-### Générer Après L'Architecture
+### Générer Après L’Architecture
 
 Exécutez le workflow `bmad-generate-project-context` après avoir terminé votre architecture :
 
@@ -114,7 +114,7 @@ Exécutez le workflow `bmad-generate-project-context` après avoir terminé votr
 bmad-generate-project-context
 ```
 
-Cela analyse votre document d'architecture et vos fichiers projet pour générer un fichier de contexte capturant les décisions prises.
+Cela analyse votre document d’architecture et vos fichiers projet pour générer un fichier de contexte capturant les décisions prises.
 
 ### Générer Pour Les Projets Existants
 
@@ -126,7 +126,7 @@ bmad-generate-project-context
 
 Le workflow analyse votre codebase pour identifier les conventions, puis génère un fichier de contexte que vous pouvez examiner et affiner.
 
-## Pourquoi C'est Important
+## Pourquoi C’est Important
 
 Sans `project-context.md`, les agents font des suppositions qui peuvent ne pas correspondre à votre projet :
 
@@ -135,24 +135,24 @@ Sans `project-context.md`, les agents font des suppositions qui peuvent ne pas c
 | Utilise des patterns génériques                    | Suit vos conventions établies                   |
 | Style incohérent selon les stories                 | Implémentation cohérente                        |
 | Peut manquer les contraintes spécifiques au projet | Respecte toutes les exigences techniques        |
-| Chaque agent décide indépendamment                 | Tous les agents s'alignent sur les mêmes règles |
+| Chaque agent décide indépendamment                 | Tous les agents s’alignent sur les mêmes règles |
 
-C'est particulièrement important pour :
-- **Quick Dev** — saute le PRD et l'architecture, le fichier de contexte comble le vide
-- **Projets d'équipe** — garantit que tous les agents suivent les mêmes standards
+C’est particulièrement important pour :
+- **Quick Dev** — saute le PRD et l’architecture, le fichier de contexte comble le vide
+- **Projets d’équipe** — garantit que tous les agents suivent les mêmes standards
 - **Projets existants** — empêche de casser les patterns établis
 
 ## Édition et Mise à Jour
 
 Le fichier `project-context.md` est un document vivant. Mettez-le à jour quand :
 
-- Les décisions d'architecture changent
+- Les décisions d’architecture changent
 - De nouvelles conventions sont établies
-- Les patterns évoluent pendant l'implémentation
+- Les patterns évoluent pendant l’implémentation
 - Vous identifiez des lacunes dans le comportement des agents
 
-Vous pouvez l'éditer manuellement à tout moment, ou réexécuter `bmad-generate-project-context` pour le mettre à jour après des changements significatifs.
+Vous pouvez l’éditer manuellement à tout moment, ou réexécuter `bmad-generate-project-context` pour le mettre à jour après des changements significatifs.
 
 :::note[Emplacement du Fichier]
-L'emplacement par défaut est `_bmad-output/project-context.md`. Les workflows le recherchent là, et vérifient également `**/project-context.md` n'importe où dans votre projet.
+L’emplacement par défaut est `_bmad-output/project-context.md`. Les workflows le recherchent là, et vérifient également `**/project-context.md` n’importe où dans votre projet.
 :::

docs/fr/explanation/quick-dev.md

@@ -2,12 +2,12 @@
 title: "Quick Dev"
 description: Réduire la friction de l’interaction humaine sans renoncer aux points de contrôle qui protègent la qualité des résultats
 sidebar:
-  order: 6
+  order: 7
 ---
 
-Intention en entrée, modifications de code en sortie, avec aussi peu d'interactions humaines dans la boucle que possible — sans sacrifier la qualité.
+Intention en entrée, modifications de code en sortie, avec aussi peu d’interactions humaines dans la boucle que possible — sans sacrifier la qualité.
 
-Il permet au modèle de s'exécuter plus longtemps entre les points de contrôle, puis ne vous fait intervenir que lorsque la tâche ne peut pas se poursuivre en toute sécurité sans jugement humain, ou lorsqu'il est temps de revoir le résultat final.
+Il permet au modèle de s’exécuter plus longtemps entre les points de contrôle, puis ne vous fait intervenir que lorsque la tâche ne peut pas se poursuivre en toute sécurité sans jugement humain, ou lorsqu’il est temps de revoir le résultat final.
 
 ![Diagramme du workflow Quick Dev](/diagrams/quick-dev-diagram-fr.webp)
 
@@ -15,51 +15,51 @@ Il permet au modèle de s'exécuter plus longtemps entre les points de contrôle
 
 Les interactions humaines dans la boucle sont nécessaires et coûteuses.
 
-Les LLM actuels échouent encore de manière prévisible : ils interprètent mal l'intention, comblent les lacunes avec des suppositions assurées, dérivent vers du travail non lié, et génèrent des résultats à réviser bruyants. En même temps, l'intervention humaine constante limite la fluidité du développement. L'attention humaine est le goulot d'étranglement.
+Les LLM actuels échouent encore de manière prévisible : ils interprètent mal l’intention, comblent les lacunes avec des suppositions assurées, dérivent vers du travail non lié, et génèrent des résultats à réviser bruyants. En même temps, l’intervention humaine constante limite la fluidité du développement. L’attention humaine est le goulot d’étranglement.
 
-`bmad-quick-dev` rééquilibre ce compromis. Il fait confiance au modèle pour s'exécuter sans surveillance sur de plus longues périodes, mais seulement après que le workflow ait créé une frontière suffisamment solide pour rendre cela sûr.
+`bmad-quick-dev` rééquilibre ce compromis. Il fait confiance au modèle pour s’exécuter sans surveillance sur de plus longues périodes, mais seulement après que le workflow ait créé une frontière suffisamment solide pour rendre cela sûr.
 
 ## La conception fondamentale
 
-### 1. Compresser l'intention d'abord
+### 1. Compresser l’intention d’abord
 
-Le workflow commence par compresser l’interaction de la personne et du modèle à partir de la requête en un objectif cohérent. L'entrée peut commencer sous forme d'une expression grossière de l'intention, mais avant que le workflow ne s'exécute de manière autonome, elle doit devenir suffisamment petite, claire et sans contradiction pour être exécutable.
+Le workflow commence par compresser l’interaction de la personne et du modèle à partir de la requête en un objectif cohérent. L’entrée peut commencer sous forme d’une expression grossière de l’intention, mais avant que le workflow ne s’exécute de manière autonome, elle doit devenir suffisamment petite, claire et sans contradiction pour être exécutable.
 
-L'intention peut prendre plusieurs formes : quelques phrases, un lien vers un outil de suivi de bugs, une sortie du mode planification, du texte copié depuis une session de chat, ou même un numéro de story depuis un fichier `epics.md` de BMAD. Dans ce dernier cas, le workflow ne comprendra pas la sémantique de suivi des stories de BMAD, mais il peut quand même prendre la story elle-même et l'exécuter.
+L’intention peut prendre plusieurs formes : quelques phrases, un lien vers un outil de suivi de bugs, une sortie du mode planification, du texte copié depuis une session de chat, ou même un numéro de story depuis un fichier `epics.md` de BMAD. Dans ce dernier cas, le workflow ne comprendra pas la sémantique de suivi des stories de BMAD, mais il peut quand même prendre la story elle-même et l’exécuter.
 
-Ce workflow n'élimine pas le contrôle humain. Il le déplace vers un nombre réduit d’étapes à forte valeur :
+Ce workflow n’élimine pas le contrôle humain. Il le déplace vers un nombre réduit d’étapes à forte valeur :
 
-- **Clarification de l'intention** - transformer une demande confuse en un objectif cohérent sans contradictions cachées
-- **Approbation de la spécification** - confirmer que la compréhension figée correspond bien à ce qu'il faut construire
+- **Clarification de l’intention** - transformer une demande confuse en un objectif cohérent sans contradictions cachées
+- **Approbation de la spécification** - confirmer que la compréhension figée correspond bien à ce qu’il faut construire
 - **Revue du produit final** - le point de contrôle principal, où la personne décide si le résultat est acceptable à la fin
 
 ### 2. Router vers le chemin le plus court et sûr
 
-Une fois l'objectif clair, le workflow décide s'il s'agit d'un véritable changement en une seule étape ou s'il nécessite le chemin complet. Les petits changements à zéro impact peuvent aller directement à l'implémentation. Tout le reste passe par la planification pour que le modèle dispose d'un cadre plus solide avant de s'exécuter plus longtemps de manière autonome.
+Une fois l’objectif clair, le workflow décide s’il s’agit d’un véritable changement en une seule étape ou s’il nécessite le chemin complet. Les petits changements à zéro impact peuvent aller directement à l’implémentation. Tout le reste passe par la planification pour que le modèle dispose d’un cadre plus solide avant de s’exécuter plus longtemps de manière autonome.
 
-### 3. S'exécuter plus longtemps avec moins de supervision
+### 3. S’exécuter plus longtemps avec moins de supervision
 
-Après cette décision de routage, le modèle peut prendre en charge une plus grande partie du travail par lui-même. Sur le chemin complet, la spécification approuvée devient le cadre dans lequel le modèle s'exécute avec moins de supervision, ce qui est tout l'intérêt de la conception.
+Après cette décision de routage, le modèle peut prendre en charge une plus grande partie du travail par lui-même. Sur le chemin complet, la spécification approuvée devient le cadre dans lequel le modèle s’exécute avec moins de supervision, ce qui est tout l’intérêt de la conception.
 
 ### 4. Diagnostiquer les échecs au bon niveau
 
-Si l'implémentation est incorrecte parce que l'intention était mauvaise, corriger le code n'est pas la bonne solution. Si le code est incorrect parce que la spécification était faible, corriger le diff n'est pas non plus la bonne solution. Le workflow est conçu pour diagnostiquer où l'échec est entré dans le système, revenir à ce niveau, et régénérer à partir de ce point.
+Si l’implémentation est incorrecte parce que l’intention était mauvaise, corriger le code n’est pas la bonne solution. Si le code est incorrect parce que la spécification était faible, corriger le diff n’est pas non plus la bonne solution. Le workflow est conçu pour diagnostiquer où l’échec est entré dans le système, revenir à ce niveau, et régénérer à partir de ce point.
 
-Les résultats de la revue sont utilisés pour décider si le problème provenait de l'intention, de la génération de la spécification, ou de l'implémentation locale. Seuls les véritables problèmes locaux sont corrigés localement.
+Les résultats de la revue sont utilisés pour décider si le problème provenait de l’intention, de la génération de la spécification, ou de l’implémentation locale. Seuls les véritables problèmes locaux sont corrigés localement.
 
 ### 5. Ne faire intervenir l’humain que si nécessaire
 
-L'entretien sur l'intention implique la personne dans la boucle, mais ce n'est pas le même type d'interruption qu'un point de contrôle récurrent. Le workflow essaie de garder ces points de contrôle récurrents au minimum. Après la mise en forme initiale de l'intention, la personne revient principalement lorsque le workflow ne peut pas continuer en toute sécurité sans jugement, et à la fin, lorsqu'il est temps de revoir le résultat.
+L’entretien sur l’intention implique la personne dans la boucle, mais ce n’est pas le même type d’interruption qu’un point de contrôle récurrent. Le workflow essaie de garder ces points de contrôle récurrents au minimum. Après la mise en forme initiale de l’intention, la personne revient principalement lorsque le workflow ne peut pas continuer en toute sécurité sans jugement, et à la fin, lorsqu’il est temps de revoir le résultat.
 
-- **Résolution des lacunes d'intention** - intervenir à nouveau lors de la revue prouve que le workflow n'a pas pu déduire correctement ce qui était voulu
+- **Résolution des lacunes d’intention** - intervenir à nouveau lors de la revue prouve que le workflow n’a pas pu déduire correctement ce qui était voulu
 
-Tout le reste est candidat à une exécution autonome plus longue. Ce compromis est délibéré. Les anciens patterns dépensent plus d'attention humaine en supervision continue. Quick Dev fait davantage confiance au modèle, mais préserve l'attention humaine pour les moments où le raisonnement humain a le plus d'impact.
+Tout le reste est candidat à une exécution autonome plus longue. Ce compromis est délibéré. Les anciens patterns dépensent plus d’attention humaine en supervision continue. Quick Dev fait davantage confiance au modèle, mais préserve l’attention humaine pour les moments où le raisonnement humain a le plus d’impact.
 
 ## Pourquoi le système de revue est important
 
-La phase de revue n'est pas seulement là pour trouver des bugs. Elle est là pour router la correction sans détruire l'élan.
+La phase de revue n’est pas seulement là pour trouver des bugs. Elle est là pour router la correction sans détruire l’élan.
 
-Ce workflow fonctionne mieux sur une plateforme capable de générer des sous-agents[^1], ou au moins d'invoquer un autre LLM via la ligne de commande et d'attendre un résultat. Si votre plateforme ne supporte pas cela nativement, vous pouvez ajouter un skill pour le faire. Les sous-agents sans contexte sont une pierre angulaire de la conception de la revue.
+Ce workflow fonctionne mieux sur une plateforme capable de générer des sous-agents[^1], ou au moins d’invoquer un autre LLM via la ligne de commande et d’attendre un résultat. Si votre plateforme ne supporte pas cela nativement, vous pouvez ajouter un skill pour le faire. Les sous-agents sans contexte sont une pierre angulaire de la conception de la revue.
 
 Les revues agentiques[^2] échouent souvent de deux manières :
 
@@ -68,7 +68,7 @@ Les revues agentiques[^2] échouent souvent de deux manières :
 
 Quick Dev aborde ces deux problèmes en traitant la revue comme un triage[^3].
 
-Lorsqu’une observation est fortuite plutôt que directement liée au travail en cours, le processus peut la mettre de côté au lieu d’obliger la personne à s’en occuper immédiatement. Cela permet de rester concentré sur l’exécution et d’éviter que des digressions aléatoires ne viennent épuiser le capital d’attention.
+Certaines observations concernent le changement en cours, d’autres non. Si une observation est incidente plutôt que directement liée au travail en cours, le workflow peut la différer au lieu d’obliger la personne à la traiter immédiatement. Cela permet de rester concentré sur l’exécution et d’éviter que des digressions aléatoires ne viennent épuiser le capital d’attention.
 
 Ce triage sera parfois imparfait. C’est acceptable. Il est généralement préférable de mal juger certaines observations plutôt que d’inonder la personne de milliers de commentaires de revue à faible valeur. Le système optimise la qualité du rapport, pas d’être exhaustif.
 

docs/fr/explanation/web-bundles.md

@@ -0,0 +1,90 @@
+---
+title: 'Web Bundles'
+description: Skills BMad empaquetés pour Google Gemini Gems et ChatGPT Custom GPTs
+---
+
+Exécutez la partie planification de BMad dans votre abonnement LLM web, puis ramenez les artefacts dans votre IDE.
+
+## Qu’est-ce qu’un Web Bundle ?
+
+Un web bundle est un skill BMad reconditionné pour être installé comme **Google Gemini Gem** ou **ChatGPT Custom GPT**. Chaque bundle inclut un protocole `SKILL.md` que vous téléversez comme fichier de connaissance, un bloc `INSTRUCTIONS.md` que vous collez dans les instructions du Gem ou du GPT, et les fichiers de données dont le skill a besoin (CSV, modèles, listes de contrôle de validation, contenu dévoilé progressivement). Le persona vit dans les instructions collées ; le protocole vit dans le fichier de connaissance. Changez de persona sans toucher au protocole.
+
+L’installation ne se fait pas en un clic, mais les étapes sont guidées. **Installez depuis [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**. Le site liste chaque bundle dans une grille, vous montre les étapes d’installation Gemini et ChatGPT directement sur la page, et met le ZIP à disposition. C’est le type d’installation pris en charge ; le schéma est le même dans toute la bibliothèque, donc une fois que vous en avez installé un, le suivant va de soi.
+
+La V4 de BMad a introduit les web bundles. La V6 les réintègre, réécrits pour les plateformes Gem et Custom GPT actuelles et conçus pour Canvas, Deep Research et la génération d’images.
+
+## Pourquoi les utiliser
+
+Le travail de planification et le travail d’implémentation nécessitent des outils différents. Les web bundles permettent à chacun d’utiliser le bon.
+
+| Aspect               | LLM web (Gem ou GPT)                        | IDE (Claude Code, Cursor)                  |
+|----------------------|---------------------------------------------|--------------------------------------------|
+| Modèle de coût       | Abonnement forfaitaire                      | Tokens facturés à l’usage                  |
+| Plus performant pour | Conversation, Canvas, Deep Research, images | Fichiers, terminal, contexte du codebase   |
+| Idéal pour           | Brainstorming, briefs, PRD, recherche       | Implémentation, refactoring, revue de code |
+
+Lancer une conversation complète de PRD ou d’étude de marché dans un IDE consomme des tokens qu’un Gem ou un Custom GPT gère pour le prix de votre abonnement existant. L’artefact finalisé est ensuite déposé dans votre dépôt et Claude Code ou Cursor prend le relais.
+
+:::tip[Planifiez sur le web, construisez dans l’IDE]
+Les économies se cumulent sur les engagements de longue durée. Un passage de PRFAQ et trois cycles de recherche dans un Gem représentent un coût marginal nul ; le même travail dans un IDE représente une dépense réelle.
+:::
+
+## Ce que contient la bibliothèque
+
+Les bundles actuellement disponibles couvrent les phases d’analyse et de planification :
+
+| Bundle                                                         | Phase         | Origine du persona                        |
+|----------------------------------------------------------------|---------------|-------------------------------------------|
+| Coach Brainstorming[^1]                                        | Analyse       | Osborn (par défaut), Minto (substitution) |
+| Coach Product Brief[^2]                                        | Analyse       | Mary (analyste BMad)                      |
+| Coach [PRFAQ](./analysis-phase.md#prfaq-working-backwards)[^3] | Analyse       | Working Backwards (Bezos)                 |
+| Coach PRD[^4]                                                  | Planification | Cagan                                     |
+| Coach UX[^5]                                                   | Planification | Norman                                    |
+| Étude de marché et analyse sectorielle                         | Analyse       | Porter et Christensen                     |
+
+Chaque bundle intègre un persona par défaut hérité de son agent BMad d’origine (lorsqu’il existe) et un exemple de persona alternatif pour illustrer le changement de voix.
+
+## Comment se déroule une session
+
+1. **Ouvrez le Gem ou le Custom GPT.** Le persona vous salue en restant dans son rôle et ouvre une phase de découverte conversationnelle.
+2. **Découvrir le périmètre.** Le persona vous demande ce que vous essayez d’accomplir, ce que vous avez sous la main, quelles contraintes s’appliquent. Pas de formulaire à remplir.
+3. **Travailler dans Canvas.** Le protocole ouvre Canvas au démarrage de la session et le met à jour en continu. Les diagrammes Mermaid et les tableaux HTML viennent s’ajouter au texte.
+4. **Transmettre.** Quand vous avez terminé, vous avez un document Canvas que vous pouvez exporter, coller dans votre dépôt, ou transmettre à un skill BMad dans votre IDE pour la phase suivante.
+
+Pour les bundles qui intègrent Deep Research (actuellement Market & Industry Research), le persona rédige un brief Deep Research en milieu de session que vous collez dans le mode Deep Research de Gemini ou ChatGPT, puis il intègre le rapport obtenu.
+
+## Quand utiliser un web bundle
+
+- Vous êtes en phase de réflexion amont sur un projet et vous voulez un outil ciblé avec persona, Canvas et Deep Research.
+- Vous voulez réserver les tokens de l’IDE au développement réel.
+- Vous partagez l’artefact de planification avec des collaborateurs qui n’ont pas votre configuration IDE.
+
+## Quand rester dans l’IDE
+
+- Le travail nécessite de lire ou modifier du code dans votre dépôt.
+- Vous êtes déjà en pleine implémentation et voulez conserver le contexte.
+- Vous n’avez pas d’abonnement Gemini Advanced ou ChatGPT Plus.
+
+## Mettre à jour et personnaliser
+
+Les bundles évoluent. Quand vous récupérez une version plus récente d’un bundle, la mise à jour typique concerne ses fichiers de connaissance (le protocole `SKILL.md` et les modèles, CSV ou listes de contrôle de validation attachés). Téléversez-les à nouveau dans votre Gem ou Custom GPT pour appliquer la mise à jour. Le bloc d’instructions ne change généralement pas.
+
+Si vous souhaitez personnaliser un bundle pour votre équipe ou votre voix, faites-le dans le **bloc d’instructions** que vous avez collé dans le Gem ou le GPT, pas dans les fichiers de connaissance. Le bloc d’instructions est l’endroit où se trouvent le persona, les préférences et les personnalisations locales ; les fichiers de connaissance sont le protocole livré avec le bundle. Garder la personnalisation dans le bloc d’instructions signifie que les futures mises à jour se résument à remplacer les pièces jointes, pas à fusionner vos modifications.
+
+:::tip[Personnalisez les instructions, joignez-y les connaissances]
+Substitutions de persona, nom d’utilisateur par défaut, garde-fous spécifiques à l’équipe, formulations préférées : tout cela appartient au bloc d’instructions collé. Les fichiers de connaissance restent standards pour que vous puissiez les rafraîchir sans perdre vos modifications.
+:::
+
+## Créer le vôtre
+
+Les web bundles sont générés à partir de skills BMad en utilisant le skill utilitaire `bmad-os-skill-to-bundle`. Pointez-le vers n’importe quel dossier de skill BMad et il produit les fichiers du bundle en reprenant le persona hérité de l’agent d’origine.
+
+Installez n’importe quel bundle depuis [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/).
+
+## Glossaire
+
+[^1]: Brainstorming : session de créativité facilitée visant à produire et explorer un large éventail d’idées sur un sujet donné, en s’appuyant sur des techniques d’idéation éprouvées.
+[^2]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.
+[^3]: PRFAQ (Press Release and Frequently Asked Questions) : méthodologie Working Backwards d’Amazon consistant à rédiger le communiqué de presse d’un produit fini avant son développement, suivie des questions difficiles que clients et parties prenantes poseraient, afin d’éprouver la clarté et la viabilité du concept.
+[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
+[^5]: UX (User Experience) : discipline qui conçoit et optimise l’ensemble des interactions entre un utilisateur et un produit — organisation, parcours, accessibilité, ergonomie — pour garantir une expérience efficace, satisfaisante et cohérente.

docs/fr/explanation/why-solutioning-matters.md

@@ -2,10 +2,10 @@
 title: "Pourquoi le Solutioning est Important"
 description: Comprendre pourquoi la phase de solutioning est critique pour les projets multi-epics
 sidebar:
-  order: 4
+  order: 5
 ---
 
-La Phase 3 (Solutioning) traduit le **quoi** construire (issu de la Planification) en **comment** le construire (conception technique). Cette phase évite les conflits entre agents dans les projets multi-epics en documentant les décisions architecturales avant le début de l'implémentation.
+La Phase 3 (Solutioning) traduit le **quoi** construire (issu de la Planification) en **comment** le construire (conception technique). Cette phase évite les conflits entre agents dans les projets multi-epics en documentant les décisions architecturales avant le début de l’implémentation.
 
 ## Le Problème Sans Solutioning
 
@@ -15,7 +15,7 @@ Agent 2 implémente l'Epic 2 avec GraphQL
 Résultat : Conception d'API incohérente, cauchemar d'intégration
 ```
 
-Lorsque plusieurs agents implémentent différentes parties d'un système sans orientation architecturale partagée, ils prennent des décisions techniques indépendantes qui peuvent entrer en conflit.
+Lorsque plusieurs agents implémentent différentes parties d’un système sans orientation architecturale partagée, ils prennent des décisions techniques indépendantes qui peuvent entrer en conflit.
 
 ## La Solution Avec le Solutioning
 
@@ -25,13 +25,13 @@ Tous les agents suivent les décisions d'architecture
 Résultat : Implémentation cohérente, pas de conflits
 ```
 
-En documentant les décisions techniques de manière explicite, tous les agents implémentent de façon cohérente et l'intégration devient simple.
+En documentant les décisions techniques de manière explicite, tous les agents implémentent de façon cohérente et l’intégration devient simple.
 
 ## Solutioning vs Planification
 
 | Aspect   | Planification (Phase 2)  | Solutioning (Phase 3)                           |
 |----------|--------------------------|-------------------------------------------------|
-| Question | Quoi et Pourquoi ?       | Comment ? Puis Quelles unités de travail ?      |
+| Question | Quoi et Pourquoi ?       | Comment ? Puis Quelles unités de travail ?      |
 | Sortie   | FRs/NFRs (Exigences)[^1] | Architecture + Epics[^2]/Stories[^3]            |
 | Agent    | PM                       | Architect → PM                                  |
 | Audience | Parties prenantes        | Développeurs                                    |
@@ -43,15 +43,15 @@ En documentant les décisions techniques de manière explicite, tous les agents
 **Rendre les décisions techniques explicites et documentées** pour que tous les agents implémentent de manière cohérente.
 
 Cela évite :
-- Les conflits de style d'API (REST vs GraphQL)
+- Les conflits de style d’API (REST vs GraphQL)
 - Les incohérences de conception de base de données
 - Les désaccords sur la gestion du state
 - Les inadéquations de conventions de nommage
-- Les variations d'approche de sécurité
+- Les variations d’approche de sécurité
 
 ## Quand le Solutioning est Requis
 
-| Parcours              | Solutioning Requis ?        |
+| Parcours              | Solutioning Requis ?        |
 |-----------------------|-----------------------------|
 | Quick Dev             | Non - l’ignore complètement |
 | Méthode BMad Simple   | Optionnel                   |
@@ -66,20 +66,20 @@ Si vous avez plusieurs epics qui pourraient être implémentés par différents
 
 Sauter le solutioning sur des projets complexes entraîne :
 
-- **Des problèmes d'intégration** découverts en milieu de sprint[^5]
+- **Des problèmes d’intégration** découverts en milieu de sprint[^5]
 - **Du travail répété** dû à des implémentations conflictuelles
 - **Un temps de développement plus long** globalement
 - **De la dette technique**[^6] due à des patterns incohérents
 
 :::caution[Coût Multiplié]
-Détecter les problèmes d'alignement lors du solutioning est 10× plus rapide que de les découvrir pendant l'implémentation.
+Détecter les problèmes d’alignement lors du solutioning est 10× plus rapide que de les découvrir pendant l’implémentation.
 :::
 
 ## Glossaire
 
 [^1]: FR / NFR (Functional / Non-Functional Requirement) : exigences décrivant respectivement **ce que le système doit faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité, fiabilité, ergonomie, etc.).
 [^2]: Epic : dans les méthodologies agiles, une unité de travail importante qui peut être décomposée en plusieurs stories plus petites. Un epic représente généralement une fonctionnalité majeure ou un objectif métier.
-[^3]: Story (User Story) : description courte et simple d'une fonctionnalité du point de vue de l'utilisateur, utilisée dans les méthodologies agiles pour planifier et prioriser le travail.
-[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
-[^5]: Sprint : période de temps fixe (généralement 1 à 4 semaines) dans les méthodologies agiles durant laquelle l'équipe complète un ensemble prédéfini de tâches.
+[^3]: Story (User Story) : description courte et simple d’une fonctionnalité du point de vue de l’utilisateur, utilisée dans les méthodologies agiles pour planifier et prioriser le travail.
+[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
+[^5]: Sprint : période de temps fixe (généralement 1 à 4 semaines) dans les méthodologies agiles durant laquelle l’équipe complète un ensemble prédéfini de tâches.
 [^6]: Dette technique : coût futur supplémentaire de travail résultant de choix de facilité ou de raccourcis pris lors du développement initial, nécessitant souvent une refonte ultérieure.

docs/fr/how-to/customize-bmad.md

@@ -1,174 +1,395 @@
 ---
 title: "Comment personnaliser BMad"
-description: Personnalisez les agents, les workflows et les modules tout en préservant la compatibilité avec les mises à jour
+description: Personnalisez les agents et les workflows tout en préservant la compatibilité avec les mises à jour
 sidebar:
-  order: 7
+  order: 8
 ---
 
-Utilisez les fichiers `.customize.yaml` pour adapter le comportement, les personas[^1] et les menus des agents tout en préservant vos modifications lors des mises à jour.
+Adaptez les personas d’agents, injectez du contexte métier, ajoutez des capacités et configurez le comportement des workflows — le tout sans modifier les fichiers installés. Vos personnalisations sont préservées à chaque mise à jour.
+
+:::tip[Vous ne voulez pas rédiger du TOML à la main ? Utilisez `bmad-customize`]
+Le skill `bmad-customize` est un assistant de rédaction guidée pour les **options de personnalisation par skill (agent/workflow)** décrite dans ce document. Il scanne ce qui est personnalisable dans votre installation, vous aide à choisir la bonne surface (agent ou workflow) pour votre intention, écrit le fichier d’override pour vous et vérifie que la fusion a fonctionné. Les overrides de la configuration centrale (`_bmad/custom/config.toml`) ne sont pas couverts par la v1 du skill — rédigez-les manuellement en vous référant à la section Configuration centrale ci-dessous. Exécutez le skill chaque fois que vous souhaitez modifier un skill spécifique ; ce document est la référence sur *ce que* chaque surface expose et comment fonctionne la fusion.
+:::
 
 ## Quand utiliser cette fonctionnalité
 
-- Vous souhaitez modifier le nom, la personnalité ou le style de communication d'un agent
-- Vous avez besoin que les agents se souviennent du contexte spécifique au projet
-- Vous souhaitez ajouter des éléments de menu personnalisés qui déclenchent vos propres workflows ou prompts
-- Vous voulez que les agents effectuent des actions spécifiques à chaque démarrage
+- Vous souhaitez changer la personnalité ou le style de communication d’un agent
+- Vous devez fournir à un agent des faits persistants qu’il devra retenir (ex. « notre org est 100 % AWS »)
+- Vous souhaitez ajouter des étapes procédurales de démarrage que l’agent doit exécuter à chaque session
+- Vous souhaitez ajouter des éléments de menu personnalisés qui déclenchent vos propres skills ou prompts
+- Votre équipe a besoin de personnalisations partagées versionnées dans git, avec des préférences personnelles ajoutées par-dessus
 
 :::note[Prérequis]
+
 - BMad installé dans votre projet (voir [Comment installer BMad](./install-bmad.md))
-- Un éditeur de texte pour les fichiers YAML
+- Python 3.11+ sur votre PATH (pour le script de résolution — utilise `tomllib` de la bibliothèque standard, pas de `pip install`, pas de `uv`, pas de virtualenv)
+- Un éditeur de texte pour les fichiers TOML
 :::
 
-:::caution[Protégez vos personnalisations]
-Utilisez toujours les fichiers `.customize.yaml` décrits ici plutôt que de modifier directement les fichiers d'agents. L'installateur écrase les fichiers d'agents lors des mises à jour, mais préserve vos modifications dans les fichiers `.customize.yaml`.
-:::
+## Comment ça marche
+
+Chaque skill personnalisable embarque un fichier `customize.toml` avec ses valeurs par défaut. Ce fichier définit la surface de personnalisation complète du skill — lisez-le pour voir ce qui est personnalisable. Ne modifiez jamais ce fichier. À la place, créez des fichiers d’override allégés contenant uniquement les champs que vous souhaitez changer.
+
+### Modèle d’override à trois couches
+
+```text
+Priorité 1 (gagne) : _bmad/custom/{skill-name}.user.toml  (personnel, ignoré par git)
+Priorité 2         : _bmad/custom/{skill-name}.toml       (équipe/org, versionné dans git)
+Priorité 3 (base)  : customize.toml du skill              (valeurs par défaut)
+```
+
+Le dossier `_bmad/custom/` est initialement vide. Les fichiers n’apparaissent que lorsqu’un utilisateur commence à personnaliser.
+
+### Règles de fusion (par forme, pas par nom de champ)
+
+Le résolveur applique quatre règles structurelles. Les noms de champ n’ont pas de traitement particulier — le comportement est déterminé uniquement par la forme de la valeur :
+
+| Forme                                                                                                                         | Règle                                                                                                          |
+|-------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|
+| Scalaire (chaîne, entier, booléen, flottant)                                                                                  | L’override prévaut                                                                                             |
+| Table                                                                                                                         | Fusion profonde (application récursive des mêmes règles)                                                       |
+| Tableau de tables où chaque élément partage le **même** champ identifiant (chaque élément a `code`, ou chaque élément a `id`) | Fusionner par cette clé — les clés correspondantes **remplacent sur place**, les nouvelles clés **s’ajoutent** |
+| Tout autre tableau (scalaires ; tables sans identifiant ; tableaux qui mélangent `code` et `id` entre les éléments)           | **Ajouter** — éléments de base en premier, puis éléments d’équipe, puis éléments utilisateur                   |
+
+**Pas de mécanisme de suppression.** Les overrides ne peuvent pas effacer les éléments de base. Si vous devez supprimer un élément de menu par défaut, surchargez-le via son `code` avec une description ou un prompt sans effet. Si vous devez restructurer un tableau plus en profondeur, forkez le skill.
+
+**La convention `code` / `id`.** BMad utilise `code` (code court comme `"BP"` ou `"R1"`) et `id` (identifiant stable plus long) comme clés de fusion dans les tableaux de tables. Si vous rédigez un tableau de tables personnalisé destiné à être fusionné par clé plutôt que par simple ajout, choisissez **une** convention (soit `code` sur chaque élément, soit `id` sur chaque élément) et respectez-la dans tout le tableau. Mélanger `code` sur certains éléments et `id` sur d’autres revient à un simple ajout — le résolveur ne devinera pas quelle clé utiliser pour la fusion.
+
+### Certains champs d’agent sont en lecture seule
+
+`agent.name` et `agent.title` sont présents dans `customize.toml` comme source de vérité, mais le SKILL.md de l’agent ne les lit pas à l’exécution — leur identité est codée en dur. Mettre `name = "Bob"` dans un fichier d’override n’a aucun effet. Si vous avez vraiment besoin d’un agent avec un nom différent, copiez le dossier du skill, renommez-le et distribuez-le comme skill personnalisé.
 
 ## Étapes
 
-### 1. Localiser les fichiers de personnalisation
+### 1. Trouver la surface de personnalisation du skill
 
-Après l'installation, vous trouverez un fichier `.customize.yaml` par agent dans :
+Consultez le `customize.toml` du skill dans son répertoire d’installation. Par exemple, l’agent PM :
 
 ```text
-_bmad/_config/agents/
-├── bmm-analyst.customize.yaml
-├── bmm-architect.customize.yaml
-└── ... (un fichier par agent installé)
+.claude/skills/bmad-agent-pm/customize.toml
 ```
 
-### 2. Modifier le fichier de personnalisation
+(Le chemin varie selon l’IDE — Cursor utilise `.cursor/skills/`, Cline utilise `.cline/skills/`, etc.)
 
-Ouvrez le fichier `.customize.yaml` de l'agent que vous souhaitez modifier. Chaque section est facultative — personnalisez uniquement ce dont vous avez besoin.
+Ce fichier est le schéma canonique. Chaque champ que vous voyez est personnalisable (à l’exception des champs d’identité en lecture seule mentionnés ci-dessus).
 
-| Section            | Comportement | Objectif                                         |
-| ------------------ | ------------ | ------------------------------------------------ |
-| `agent.metadata`   | Remplace     | Remplacer le nom d'affichage de l'agent          |
-| `persona`          | Remplace     | Définir le rôle, l'identité, le style et les principes |
-| `memories`         | Ajoute       | Ajouter un contexte persistant que l'agent se rappelle toujours |
-| `menu`             | Ajoute       | Ajouter des éléments de menu personnalisés pour les workflows ou prompts |
-| `critical_actions` | Ajoute       | Définir les instructions de démarrage de l'agent |
-| `prompts`          | Ajoute       | Créer des prompts réutilisables pour les actions du menu |
+### 2. Créer votre fichier d’override
 
-Les sections marquées **Remplace** écrasent entièrement les valeurs par défaut de l'agent. Les sections marquées **Ajoute** s'ajoutent à la configuration existante.
+Créez le répertoire `_bmad/custom/` à la racine de votre projet s’il n’existe pas. Puis créez un fichier portant le même nom que le skill :
 
-**Nom de l'agent**
-
-Modifier la façon dont l'agent se présente :
-
-```yaml
-agent:
-  metadata:
-    name: 'Bob l’éponge' # Par défaut : "Amelia"
+```text
+_bmad/custom/
+  bmad-agent-pm.toml        # overrides d'équipe (versionnés dans git)
+  bmad-agent-pm.user.toml   # préférences personnelles (ignoré par git)
 ```
 
-**Persona**
+:::caution[Ne copiez PAS le `customize.toml` complet]
+Les fichiers d’override sont **allégés**. Incluez uniquement les champs que vous modifiez — rien d’autre. Chaque champ omis est hérité automatiquement de la couche inférieure (l’équipe hérite des valeurs par défaut, l’utilisateur de l’équipe ou des valeurs par défaut).
 
-Remplacer la personnalité, le rôle et le style de communication de l'agent :
+Copier le `customize.toml` complet dans un override est contre-productif : la prochaine mise à jour livrera de nouvelles valeurs par défaut, mais votre fichier d’override figera les anciennes valeurs. Votre configuration s’éloignera silencieusement des valeurs par défaut à chaque mise à jour.
+:::
 
-```yaml
-persona:
-  role: 'Ingénieur Full-Stack Senior'
-  identity: 'Habite dans un ananas (au fond de la mer)'
-  communication_style: 'Style agaçant de Bob l’Éponge'
-  principles:
-    - 'Jamais de nidification, les devs Bob l’Éponge détestent plus de 2 niveaux d’imbrication'
-    - 'Privilégier la composition à l’héritage'
+**Exemple — changer l’icône et ajouter un principe :**
+
+```toml
+# _bmad/custom/bmad-agent-pm.toml
+# Uniquement les champs que je modifie. Tout le reste est hérité.
+
+[agent]
+icon = "🏥"
+principles = [
+  "Ne rien livrer qui ne puisse passer un audit FDA.",
+]
 ```
 
-La section `persona`[^1] remplace entièrement le persona par défaut, donc incluez les quatre champs si vous la définissez.
+Ceci ajoute le nouveau principe aux valeurs par défaut (en laissant les principes existants intacts) et remplace l’icône. Tous les autres champs restent inchangés.
 
-**Souvenirs**
+### 3. Personnaliser selon vos besoins
 
-Ajouter un contexte persistant que l'agent gardera toujours en mémoire :
+Tous les exemples ci-dessous supposent le schéma d’agent plat de BMad. Les champs se trouvent directement sous `[agent]` — pas de sous-tables `metadata` ou `persona` imbriquées.
 
-```yaml
-memories:
-  - 'Travaille au Krusty Krab'
-  - 'Célébrité préférée : David Hasselhoff'
-  - 'Appris dans l’Epic 1 que ce n’est pas cool de faire semblant que les tests ont passé'
+**Scalaires (icon, role, identity, communication_style).** Les overrides scalaires prévalent. Vous n’avez besoin de définir que les champs que vous modifiez :
+
+```toml
+# _bmad/custom/bmad-agent-pm.toml
+
+[agent]
+icon = "🏥"
+role = "Pilote la découverte produit pour un domaine de santé réglementé."
+communication_style = "Précis, sensible à la réglementation, pose des questions orientées conformité tôt."
 ```
 
-**Éléments de menu**
+**Faits persistants, principes, hooks d’activation (tableaux en mode ajout).** Les quatre tableaux ci-dessous sont en ajout uniquement. Les éléments d’équipe s’exécutent après les valeurs par défaut, les éléments utilisateur s’exécutent en dernier.
 
-Ajouter des entrées personnalisées au menu d'affichage de l'agent. Chaque élément nécessite un `trigger`, une cible (chemin `workflow` ou référence `action`), et une `description` :
+```toml
+[agent]
+# Faits statiques que l'agent garde en tête pendant toute la session — règles d'org,
+# constantes de domaine, préférences utilisateur. Distinct du sidecar de mémoire runtime.
+#
+# Chaque entrée est soit une phrase littérale, soit une référence `file:` dont le
+# contenu est chargé comme des faits (patterns glob supportés).
+persistent_facts = [
+  "Notre org est 100 % AWS — ne pas proposer GCP ni Azure.",
+  "Tous les PRD nécessitent une validation légale avant le démarrage de l'ingénierie.",
+  "Les utilisateurs cibles sont des cliniciens, pas des patients — formuler les exemples en conséquence.",
+  "file:{project-root}/docs/compliance/hipaa-overview.md",
+  "file:{project-root}/_bmad/custom/company-glossary.md",
+]
 
-```yaml
-menu:
-  - trigger: my-workflow
-    workflow: 'my-custom/workflows/my-workflow.yaml'
-    description: Mon workflow personnalisé
-  - trigger: deploy
-    action: '#deploy-prompt'
-    description: Déployer en production
+# S'ajoute au système de valeurs de l'agent
+principles = [
+  "Ne rien livrer qui ne puisse passer un audit FDA.",
+  "Valeur utilisateur d'abord, conformité toujours.",
+]
+
+# S'exécute AVANT l'activation standard (persona, persistent_facts, config, salutation).
+# À utiliser pour les préchargements, vérifications de conformité, tout ce qui doit être
+# en contexte avant que l'agent ne se présente.
+activation_steps_prepend = [
+  "Scanner {project-root}/docs/compliance/ et charger tout document lié à HIPAA comme contexte.",
+]
+
+# S'exécute APRÈS la salutation, AVANT le menu. Utiliser pour le chargement de contexte
+# qui doit intervenir après le message d'accueil.
+activation_steps_append = [
+  "Lire {project-root}/_bmad/custom/company-glossary.md s'il existe.",
+]
 ```
 
-**Actions critiques**
+**Pourquoi deux hooks ?** Le préfixe s’exécute avant la salutation pour que l’agent puisse charger le contexte dont il a besoin pour personnaliser la salutation elle-même. Le suffixe s’exécute après la salutation pour que l’utilisateur ne reste pas devant un terminal vide pendant les scans lourds.
 
-Définir des instructions qui s'exécutent au démarrage de l'agent :
+**Personnalisation du menu (fusion par `code`).** Le menu est un tableau de tables. Chaque élément possède un champ `code` (convention BMad). Le résolveur fusionne donc par code : les codes correspondants remplacent sur place, les nouveaux codes s’ajoutent.
 
-```yaml
-critical_actions:
-  - 'Vérifier les pipelines CI avec le Skill XYZ et alerter l’utilisateur au réveil si quelque chose nécessite une attention urgente'
+La syntaxe TOML pour les tableaux de tables utilise `[[agent.menu]]` pour chaque élément :
+
+```toml
+# Remplacer l'élément CE existant par un skill personnalisé
+[[agent.menu]]
+code = "CE"
+description = "Créer des Epics avec notre framework de livraison"
+skill = "custom-create-epics"
+
+# Ajouter un nouvel élément (le code RC n'existe pas dans les valeurs par défaut)
+[[agent.menu]]
+code = "RC"
+description = "Exécuter une pré-vérification de conformité"
+prompt = """
+Lire {project-root}/_bmad/custom/compliance-checklist.md
+et scanner tous les documents dans {planning_artifacts} en les comparant à celui-ci.
+Signaler tout écart et citer la section réglementaire pertinente.
+"""
 ```
 
-**Prompts personnalisés**
+Chaque élément de menu possède exactement un `skill` (invoque un skill enregistré) ou `prompt` (exécute le texte directement). Les éléments non listés dans votre override conservent leurs valeurs par défaut.
 
-Créer des prompts réutilisables que les éléments de menu peuvent référencer avec `action="#id"` :
+**Référencer des fichiers.** Quand le texte d’un champ doit pointer vers un fichier (dans `persistent_facts`, `activation_steps_prepend`/`activation_steps_append`, ou le `prompt` d’un élément de menu), utilisez un chemin complet partant de `{project-root}`. Même si le fichier se trouve à côté de votre override dans `_bmad/custom/`, écrivez le chemin complet : `{project-root}/_bmad/custom/info.md`. L’agent résout `{project-root}` à l’exécution.
 
-```yaml
-prompts:
-  - id: deploy-prompt
-    content: |
-      Déployer la branche actuelle en production :
-      1. Exécuter tous les tests
-      2. Build le projet
-      3. Exécuter le script de déploiement
+### 4. Personnel vs Équipe
+
+**Fichier d’équipe** (`bmad-agent-pm.toml`) : Versionné dans git. Partagé au sein de l’organisation. À utiliser pour les règles de conformité, le persona de l’entreprise, les capacités personnalisées.
+
+**Fichier personnel** (`bmad-agent-pm.user.toml`) : Automatiquement ignoré par git. À utiliser pour les ajustements de ton, les préférences de workflow personnelles et les faits privés que l’agent doit garder en tête.
+
+```toml
+# _bmad/custom/bmad-agent-pm.user.toml
+
+[agent]
+persistent_facts = [
+  "Toujours inclure une estimation approximative de complexité (faible/moyenne/élevée) en présentant les options.",
+]
 ```
 
-### 3. Appliquer vos modifications
+## Comment fonctionne la résolution
 
-Après modification, réinstallez pour appliquer les changements :
+À l’activation, le SKILL.md de l’agent exécute un script Python partagé qui effectue la fusion à trois couches et renvoie le bloc résolu en JSON. Le script utilise le module `tomllib` de la bibliothèque standard Python (aucune dépendance externe), donc `python3` suffit :
 
 ```bash
-npx bmad-method install
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill {skill-root} \
+  --key agent
 ```
 
-L'installateur détecte l'installation existante et propose ces options :
+**Prérequis** : Python 3.11+ (les versions antérieures n’incluent pas `tomllib`). Pas de `pip install`, pas de `uv`, pas de virtualenv. Vérifiez avec `python3 --version`. Certaines plateformes (macOS sans Homebrew, Ubuntu 22.04) ont `python3` par défaut en 3.10 ou antérieur, vous devrez peut-être installer 3.11+ séparément.
 
-| Option                              | Ce qu'elle fait                                                        |
-| ----------------------------------- | ---------------------------------------------------------------------- |
-| **Quick Update**                    | Met à jour tous les modules vers la dernière version et applique les personnalisations |
-| **Modify BMad Installation**        | Flux d'installation complet pour ajouter ou supprimer des modules     |
+`--skill` pointe vers le répertoire installé du skill (où se trouve `customize.toml`). Le nom du skill est déduit du basename du répertoire, et le script cherche automatiquement `_bmad/custom/{skill-name}.toml` et `{skill-name}.user.toml`.
 
-Pour des modifications de personnalisation uniquement, **Quick Update** est l'option la plus rapide.
+Exemples d’utilisation :
 
-## Résolution des problèmes
+```bash
+# Résoudre le bloc agent complet
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /chemin/absolu/vers/bmad-agent-pm \
+  --key agent
 
-**Les modifications n'apparaissent pas ?**
+# Résoudre un seul champ
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /chemin/absolu/vers/bmad-agent-pm \
+  --key agent.icon
 
-- Exécutez `npx bmad-method install` et sélectionnez **Quick Update** pour appliquer les modifications
-- Vérifiez que votre syntaxe YAML est valide (l'indentation compte)
-- Assurez-vous d'avoir modifié le bon fichier `.customize.yaml` pour l'agent
+# Dump complet
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /chemin/absolu/vers/bmad-agent-pm
+```
 
-**L'agent ne se charge pas ?**
-
-- Vérifiez les erreurs de syntaxe YAML à l'aide d'un validateur YAML en ligne
-- Assurez-vous de ne pas avoir laissé de champs vides après les avoir décommentés
-- Essayez de revenir au modèle d'origine et de reconstruire
-
-**Besoin de réinitialiser un agent ?**
-
-- Effacez ou supprimez le fichier `.customize.yaml` de l'agent
-- Exécutez `npx bmad-method install` et sélectionnez **Quick Update** pour restaurer les valeurs par défaut
+La sortie est toujours en JSON. Si le script n’est pas disponible sur une plateforme donnée, le SKILL.md demande à l’agent de lire les trois fichiers TOML directement et d’appliquer les mêmes règles de fusion.
 
 ## Personnalisation des workflows
 
-La personnalisation des workflows et skills existants de la méthode BMad arrive bientôt.
+Les workflows (skills qui pilotent des processus multi-étapes comme `bmad-product-brief`) partagent le même mécanisme d’override que les agents. Leur surface personnalisable se trouve sous `[workflow]` au lieu de `[agent]` :
 
-## Personnalisation des modules
+```toml
+# _bmad/custom/bmad-product-brief.toml
 
-Les conseils sur la création de modules d'extension et la personnalisation des modules existants arrivent bientôt.
+[workflow]
+# Même sémantique préfixe/suffixe que les agents — s'exécute avant et après les étapes
+# d'activation propres au workflow. Les overrides s'ajoutent aux valeurs par défaut.
+activation_steps_prepend = [
+  "Charger {project-root}/docs/product/north-star-principles.md comme contexte.",
+]
 
-## Glossaire
+activation_steps_append = []
 
-[^1]: Persona : définition de la personnalité, du rôle et du style de communication d'un agent IA. Permet d'adapter le comportement et les réponses de l'agent selon les besoins du projet.
+# Même sémantique littéral ou fichier que pour la variante agent. Chargé comme contexte
+# fondamental pour la durée de l'exécution du workflow.
+persistent_facts = [
+  "Tous les briefs doivent inclure une section explicite de risque réglementaire.",
+  "file:{project-root}/docs/compliance/product-brief-checklist.md",
+]
+
+# Scalaire : s'exécute une fois que le workflow a terminé son livrable principal. L'override prévaut.
+on_complete = "Résumer le brief en trois points et proposer de l'envoyer par email via le skill gws-gmail-send."
+```
+
+Les mêmes conventions de champs s’appliquent indifféremment aux agents et aux workflows : `activation_steps_prepend`/`activation_steps_append`, `persistent_facts` (avec refs `file:`) et les tables `[[…]]` de style menu avec `code`/`id` pour la fusion par clé. Le résolveur applique les mêmes quatre règles structurelles quelle que soit la clé de premier niveau. Les références dans SKILL.md suivent l’espace de noms : `{workflow.activation_steps_prepend}`, `{workflow.persistent_facts}`, `{workflow.on_complete}`. Tout champ supplémentaire qu’un workflow expose (chemins de sortie, bascules, paramètres de revue, drapeaux d’étape) suit les mêmes règles de fusion basées sur la forme. Lisez le `customize.toml` du workflow pour voir ce qui est personnalisable.
+
+### Ordre d’activation
+
+Les workflows personnalisables exécutent leur activation dans une séquence fixe pour que vous sachiez exactement quand vos hooks se déclenchent :
+
+1. Résoudre le bloc `[workflow]` (fusion base → équipe → utilisateur)
+2. Exécuter `activation_steps_prepend` dans l’ordre
+3. Charger `persistent_facts` comme contexte fondamental pour l’exécution
+4. Charger la configuration (`_bmad/bmm/config.yaml`) et résoudre les variables standard (nom du projet, langues, chemins, date)
+5. Saluer l’utilisateur
+6. Exécuter `activation_steps_append` dans l’ordre
+
+Après l’étape 6, le corps du workflow commence. Utilisez `activation_steps_prepend` quand vous avez besoin de contexte chargé avant que la salutation puisse être personnalisée ; utilisez `activation_steps_append` quand le chargement est lourd et que vous préférez que l’utilisateur voie la salutation d’abord.
+
+### Périmètre de cette première passe
+
+La personnalisation est déployée de manière incrémentale. Les champs documentés ci-dessus — `activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete` — sont la **surface de base** que chaque workflow personnalisable expose, et ils resteront stables d’une version à l’autre. Ils vous donnent un contrôle à grands traits dès aujourd’hui : injecter des étapes pré/post, épingler du contexte fondamental, déclencher des actions de suivi.
+
+Au fil du temps, les workflows individuels exposeront des **points de personnalisation plus ciblés** adaptés à ce que le workflow fait réellement — par exemple des bascules par étape, des drapeaux d’étape, des chemins de templates de sortie ou des jalons de revue. Quand ils arriveront, ils viendront s’ajouter aux champs de base plutôt que de les remplacer, pour que les personnalisations que vous rédigez aujourd’hui continuent de fonctionner.
+
+Si vous avez besoin d’un réglage précis qui n’est pas encore exposé, utilisez `activation_steps_*` et `persistent_facts` pour orienter le comportement, ou ouvrez une issue décrivant le point de personnalisation spécifique que vous souhaitez — ces demandes déterminent quels champs ciblés seront ajoutés ensuite.
+
+## Configuration centrale
+
+Le `customize.toml` par skill couvre le **comportement profond** (hooks, menus, persistent_facts, overrides de persona pour un seul agent ou workflow). Une surface séparée couvre l'**état transversal** — les réponses d’installation et le registre des agents que les skills externes comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation` consomment. Cette surface se trouve dans quatre fichiers TOML à la racine du projet :
+
+```text
+_bmad/config.toml               (géré par l'installateur)  périmètre équipe : réponses d'installation + registre des agents
+_bmad/config.user.toml          (géré par l'installateur)  périmètre utilisateur : user_name, langue, niveau de skill
+_bmad/custom/config.toml        (rédigé manuellement)      overrides d'équipe (versionnés dans git)
+_bmad/custom/config.user.toml   (rédigé manuellement)      overrides personnels (ignoré par git)
+```
+
+### Fusion à quatre couches
+
+```text
+Priorité 1 (gagne) : _bmad/custom/config.user.toml
+Priorité 2         : _bmad/custom/config.toml
+Priorité 3         : _bmad/config.user.toml
+Priorité 4 (base)  : _bmad/config.toml
+```
+
+Mêmes règles structurelles que la personnalisation par skill (scalaires prévalent, tables fusionnent en profondeur, tableaux à clé `code`/`id` fusionnent par clé, autres tableaux s’ajoutent).
+
+### Répartition du contenu
+
+L’installateur répartit les réponses selon le `scope:` déclaré sur chaque prompt dans `module.yaml` :
+
+- Les sections `[core]` et `[modules.<code>]` — réponses d’installation. Le scope `team` figure dans `_bmad/config.toml` ; le scope `user` figure dans `_bmad/config.user.toml`.
+- `[agents.<code>]` — descripteur de l’agent (code, name, title, icon, description, team) extrait du bloc `agents:` de chaque `module.yaml`. Toujours de scope équipe.
+
+### Règles de modification
+
+- `_bmad/config.toml` et `_bmad/config.user.toml` sont **régénérés à chaque installation** à partir des réponses collectées pendant le processus d’installation. Traitez-les comme des sorties en lecture seule — les modifications directes seront écrasées à la prochaine installation. Pour changer une réponse d’installation de manière durable, relancez l’installateur (il se souvient de vos réponses précédentes comme valeurs par défaut) ou surchargez la valeur dans `_bmad/custom/config.toml`.
+- `_bmad/custom/config.toml` et `_bmad/custom/config.user.toml` ne sont **jamais modifiés** par l’installateur. C’est l’espace approprié pour les agents personnalisés, les overrides de descripteur d’agent, les paramètres imposés par l’équipe et toute valeur que vous souhaitez figer indépendamment des réponses d’installation.
+
+### Exemple — Renommer un agent
+
+```toml
+# _bmad/custom/config.toml (versionné dans git, s'applique à tous les développeurs)
+
+[agents.bmad-agent-pm]
+description = "PM Santé — sensible à la réglementation, orienté parties prenantes, questions orientées FDA en premier."
+icon = "🏥"
+```
+
+Le résolveur fusionne par-dessus le `[agents.bmad-agent-pm]` écrit par l’installateur. `bmad-party-mode` et tout autre utilisateur du registre récupèrent automatiquement la nouvelle description.
+
+### Exemple — Ajouter un agent fictif
+
+```toml
+# _bmad/custom/config.user.toml (personnel, ignoré par git)
+
+[agents.kirk]
+team = "startrek"
+name = "Captain James T. Kirk"
+title = "Starship Captain"
+icon = "🖖"
+description = "Commandant audacieux, enfreignant les règles. Parle en pauses dramatiques. Pense à voix haute sur le poids du commandement."
+```
+
+Pas de dossier de skill requis — le descripteur seul suffit pour que party-mode instancie Kirk comme voix. Filtrez par le champ `team` pour inviter uniquement l’équipage de l’Enterprise à une table ronde.
+
+### Exemple — Override des paramètres d’installation du module
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "/shared/org-planning-artifacts"
+```
+
+L’override prévaut sur ce que chaque développeur a répondu lors de son installation locale. Utile pour figer les conventions d’équipe.
+
+### Quelle surface utiliser pour quel besoin
+
+| Besoin                                                   | Utiliser                                                                      |
+|----------------------------------------------------------|-------------------------------------------------------------------------------|
+| Ajouter des appels d’outils MCP à chaque workflow de dev | Par skill : `_bmad/custom/bmad-agent-dev.toml` `persistent_facts`             |
+| Ajouter un élément de menu à un agent                    | Par skill : `_bmad/custom/bmad-agent-{role}.toml` `[[agent.menu]]`            |
+| Remplacer le template de sortie d’un workflow            | Par skill : `_bmad/custom/{workflow}.toml` override scalaire                  |
+| Renommer le descripteur public d’un agent                | **Centrale** : `_bmad/custom/config.toml` `[agents.<code>]`                   |
+| Ajouter un agent personnalisé ou fictif au registre      | **Centrale** : `_bmad/custom/config.*.toml` nouvelle entrée `[agents.<code>]` |
+| Figer les paramètres d’installation pour l’équipe        | **Centrale** : `_bmad/custom/config.toml` `[modules.<code>]` ou `[core]`      |
+
+Utilisez les deux espaces dans le même projet selon vos besoins.
+
+## Exemples concrets
+
+Pour des recettes orientées entreprise (façonner un agent à travers tous les workflows qu’il gère, imposer les conventions d’organisation, publier les livrables vers Confluence et Jira, personnaliser le registre des agents et remplacer vos propres templates de sortie), consultez [Comment étendre BMad pour votre organisation](./expand-bmad-for-your-org.md).
+
+## Dépannage
+
+**La personnalisation n’apparaît pas ?**
+
+- Vérifiez que votre fichier se trouve dans `_bmad/custom/` avec le nom de skill correct
+- Vérifiez la syntaxe TOML : les chaînes doivent être entre guillemets, les en-têtes de table utilisent `[section]`, les tableaux de tables utilisent `[[section]]`, et toute clé scalaire ou de tableau pour une table doit apparaître *avant* toute `[[sous-table]]` de cette table dans le fichier
+- Pour les agents, la personnalisation se trouve sous `[agent]` — les champs écrits sous cet en-tête appartiennent à `agent` jusqu’à ce qu’un autre en-tête de table commence
+- Rappelez-vous que `agent.name` et `agent.title` sont en lecture seule ; les overrides n’ont aucun effet
+
+**Les mises à jour ont cassé votre personnalisation ?**
+
+- Avez-vous copié le `customize.toml` complet dans votre fichier d’override ? **Ne le faites pas.** Les fichiers d’override ne doivent contenir que les champs que vous modifiez. Une copie complète fige les anciennes valeurs par défaut et dérive silencieusement à chaque version. Réduisez votre override aux seuls deltas.
+
+**Besoin de voir ce qui est personnalisable ?**
+
+- Exécutez le skill `bmad-customize` — il énumère chaque skill personnalisable installé dans votre projet, montre lesquels ont déjà des overrides et vous guide pour en ajouter ou en modifier.
+- Ou lisez directement le `customize.toml` du skill — chaque champ listé est personnalisable (sauf `name` et `title`)
+
+**Besoin de réinitialiser ?**
+
+- Supprimez votre fichier d’override de `_bmad/custom/` — le skill revient à ses valeurs par défaut intégrées.

docs/fr/how-to/established-projects.md

@@ -2,12 +2,12 @@
 title: "Projets existants"
 description: Comment utiliser la méthode BMad sur des bases de code existantes
 sidebar:
-  order: 6
+  order: 7
 ---
 
 Utilisez la méthode BMad efficacement lorsque vous travaillez sur des projets existants et des bases de code legacy.
 
-Ce guide couvre le flux de travail essentiel pour l'intégration à des projets existants avec la méthode BMad.
+Ce guide couvre le flux de travail essentiel pour l’intégration à des projets existants avec la méthode BMad.
 
 :::note[Prérequis]
 - méthode BMad installée (`npx bmad-method install`)
@@ -15,18 +15,18 @@ Ce guide couvre le flux de travail essentiel pour l'intégration à des projets
 - Accès à un IDE IA (Claude Code ou Cursor)
 :::
 
-## Étape 1 : Nettoyer les artefacts de planification terminés
+## Étape 1 : Nettoyer les artefacts de planification terminés
 
-Si vous avez terminé tous les epics et stories du PRD[^1] via le processus BMad, nettoyez ces fichiers. Archivez-les, supprimez-les, ou appuyez-vous sur l'historique des versions si nécessaire. Ne conservez pas ces fichiers dans :
+Si vous avez terminé tous les epics et stories du PRD[^1] via le processus BMad, nettoyez ces fichiers. Archivez-les, supprimez-les, ou appuyez-vous sur l’historique des versions si nécessaire. Ne conservez pas ces fichiers dans :
 
 - `docs/`
 - `_bmad-output/planning-artifacts/`
 - `_bmad-output/implementation-artifacts/`
 
-## Étape 2 : Créer le contexte du projet
+## Étape 2 : Créer le contexte du projet
 
 :::tip[Recommandé pour les projets existants]
-Générez `project-context.md` pour capturer les patterns et conventions de votre base de code existante. Cela garantit que les agents IA suivent vos pratiques établies lors de l'implémentation des modifications.
+Générez `project-context.md` pour capturer les patterns et conventions de votre base de code existante. Cela garantit que les agents IA suivent vos pratiques établies lors de l’implémentation des modifications.
 :::
 
 Exécutez le workflow de génération de contexte du projet :
@@ -37,7 +37,7 @@ bmad-generate-project-context
 
 Cela analyse votre base de code pour identifier :
 - La pile technologique et les versions
-- Les patterns d'organisation du code
+- Les patterns d’organisation du code
 - Les conventions de nommage
 - Les approches de test
 - Les patterns spécifiques aux frameworks
@@ -46,22 +46,22 @@ Vous pouvez examiner et affiner le fichier généré, ou le créer manuellement
 
 [En savoir plus sur le contexte du projet](../explanation/project-context.md)
 
-## Étape 3 : Maintenir une documentation de projet de qualité
+## Étape 3 : Maintenir une documentation de projet de qualité
 
 Votre dossier `docs/` doit contenir une documentation succincte et bien organisée qui représente fidèlement votre projet :
 
-- L'intention et la justification métier
+- L’intention et la justification métier
 - Les règles métier
-- L'architecture
+- L’architecture
 - Toute autre information pertinente sur le projet
 
-Pour les projets complexes, envisagez d'utiliser le workflow `bmad-document-project`. Il offre des variantes d'exécution qui analyseront l'ensemble de votre projet et documenteront son état actuel réel.
+Pour les projets complexes, envisagez d’utiliser le workflow `bmad-document-project`. Il offre des variantes d’exécution qui analyseront l’ensemble de votre projet et documenteront son état actuel réel.
 
-## Étape 4 : Obtenir de l'aide
+## Étape 4 : Obtenir de l’aide
 
-### BMad-Help : Votre point de départ
+### BMad-Help : Votre point de départ
 
-**Exécutez `bmad-help` chaque fois que vous n'êtes pas sûr de la prochaine étape.** Ce guide intelligent :
+**Exécutez `bmad-help` chaque fois que vous n’êtes pas sûr de la prochaine étape.** Ce guide intelligent :
 
 - Inspecte votre projet pour voir ce qui a déjà été fait
 - Affiche les options basées sur vos modules installés
@@ -73,25 +73,25 @@ bmad-help Quelle est la différence entre quick-dev et la méthode complète ?
 bmad-help Montre-moi quels workflows sont disponibles
 ```
 
-BMad-Help s'exécute également **automatiquement à la fin de chaque workflow**, fournissant des conseils clairs sur exactement quoi faire ensuite.
+BMad-Help s’exécute également **automatiquement à la fin de chaque workflow**, fournissant des conseils clairs sur exactement quoi faire ensuite.
 
 ### Choisir votre approche
 
-Vous avez deux options principales selon l'ampleur des modifications :
+Vous avez deux options principales selon l’ampleur des modifications :
 
-| Portée                                    | Approche recommandée                                                                                                                    |
-| ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
-| **Petites mises à jour ou ajouts**        | Exécutez `bmad-quick-dev` pour clarifier l'intention, planifier, implémenter et réviser dans un seul workflow. La méthode BMad complète en quatre phases est probablement excessive. |
-| **Modifications ou ajouts majeurs**       | Commencez avec la méthode BMad, en appliquant autant ou aussi peu de rigueur que nécessaire.                                            |
+| Portée                              | Approche recommandée                                                                                                                                                                 |
+|-------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Petites mises à jour ou ajouts**  | Exécutez `bmad-quick-dev` pour clarifier l’intention, planifier, implémenter et réviser dans un seul workflow. La méthode BMad complète en quatre phases est probablement excessive. |
+| **Modifications ou ajouts majeurs** | Commencez avec la méthode BMad, en appliquant autant ou aussi peu de rigueur que nécessaire.                                                                                         |
 
 ### Pendant la création du PRD
 
-Lors de la création d'un brief ou en passant directement au PRD[^1], assurez-vous que l'agent :
+Lors de la création d’un brief ou en passant directement au PRD[^1], assurez-vous que l’agent :
 
 - Trouve et analyse votre documentation de projet existante
 - Lit le contexte approprié sur votre système actuel
 
-Vous pouvez guider l'agent explicitement, mais l'objectif est de garantir que la nouvelle fonctionnalité s'intègre bien à votre système existant.
+Vous pouvez guider l’agent explicitement, mais l’objectif est de garantir que la nouvelle fonctionnalité s’intègre bien à votre système existant.
 
 ### Considérations UX
 
@@ -100,23 +100,23 @@ Le travail UX[^2] est optionnel. La décision dépend non pas de savoir si votre
 - Si vous allez travailler sur des modifications UX
 - Si des conceptions ou patterns UX significatifs sont nécessaires
 
-Si vos modifications se résument à de simples mises à jour d'écrans existants qui vous satisfont, un processus UX complet n'est pas nécessaire.
+Si vos modifications se résument à de simples mises à jour d’écrans existants qui vous satisfont, un processus UX complet n’est pas nécessaire.
 
-### Considérations d'architecture
+### Considérations d’architecture
 
-Lors de la création de l'architecture, assurez-vous que l'architecte :
+Lors de la création de l’architecture, assurez-vous que l’architecte :
 
 - Utilise les fichiers documentés appropriés
 - Analyse la base de code existante
 
-Soyez particulièrement attentif ici pour éviter de réinventer la roue ou de prendre des décisions qui ne s'alignent pas avec votre architecture existante.
+Soyez particulièrement attentif ici pour éviter de réinventer la roue ou de prendre des décisions qui ne s’alignent pas avec votre architecture existante.
 
-## Plus d'informations
+## Plus d’informations
 
 - **[Corrections rapides](./quick-fixes.md)** - Corrections de bugs et modifications ad-hoc
 - **[FAQ Projets existants](../explanation/established-projects-faq.md)** - Questions courantes sur le travail sur des projets établis
 
 ## Glossaire
 
-[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
-[^2]: UX (User Experience) : expérience utilisateur, englobant l'ensemble des interactions et perceptions d'un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d'utilisation.
+[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
+[^2]: UX (User Experience) : expérience utilisateur, englobant l’ensemble des interactions et perceptions d’un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d’utilisation.

docs/fr/how-to/expand-bmad-for-your-org.md

@@ -0,0 +1,328 @@
+---
+title: 'Comment étendre BMad pour votre organisation'
+description: Six patterns de personnalisation qui remodèlent BMad sans créer de fork — règles applicables aux agents, conventions de workflow, publication externe, remplacements de templates, modifications du registre des agents et patterns d’intégration avancés
+sidebar:
+  order: 11
+---
+
+Le système de personnalisation de BMad permet à une organisation d’adapter les comportements sans modifier les fichiers installés ni forker les skills. Ce guide présente six recettes qui couvrent la plupart des besoins en entreprise.
+
+:::note[Prérequis]
+
+- BMad installé dans votre projet (voir [Comment installer BMad](./install-bmad.md))
+- Connaissance du modèle de personnalisation (voir [Comment personnaliser BMad](./customize-bmad.md))
+- Python 3.11+ sur le PATH (pour le résolveur — bibliothèque standard uniquement, pas de `pip install`)
+:::
+
+:::tip[Appliquer ces recettes]
+Les **recettes par skill** ci-dessous (Recettes 1–4) peuvent être appliquées en exécutant le skill `bmad-customize` et en décrivant l’intention — il sélectionnera le bon point de personnalisation, générera le fichier d’override et vérifiera la fusion. La Recette 5 (overrides de la configuration centrale du registre des agents) n’est pas couverte par la v1 du skill et reste rédigée manuellement. Les recettes ici constituent la source de vérité sur *quoi* personnaliser ; `bmad-customize` gère le *comment* pour la surface agent/workflow.
+:::
+
+## Le modèle mental à trois couches
+
+Avant de choisir une recette, comprenez où votre override se situe :
+
+| Couche                                       | Où vivent les overrides                                               | Périmètre                                                                                                                                       |
+|----------------------------------------------|-----------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Agent** (ex. Amelia, Mary, John)           | Section `[agent]` de `_bmad/custom/bmad-agent-{role}.toml`            | Se propage avec le persona dans **chaque workflow que l’agent dispatche**                                                                       |
+| **Workflow** (ex. product-brief, create-prd) | Section `[workflow]` de `_bmad/custom/{workflow-name}.toml`           | S’applique uniquement à l’exécution de ce workflow                                                                                              |
+| **Configuration centrale**                   | `[agents.*]`, `[core]`, `[modules.*]` dans `_bmad/custom/config.toml` | Registre des agents (qui est disponible pour party-mode, retrospective, elicitation), paramètres d’installation figés pour toute l’organisation |
+
+En règle générale : si la règle doit s’appliquer partout où un ingénieur travaille sur le développement, personnalisez l'**agent dev**. Si elle s’applique uniquement quand quelqu’un rédige un product brief, personnalisez le **workflow product-brief**. Si elle change *qui participe* (renommer un agent, ajouter une voix personnalisée, imposer un chemin d’artefact partagé), modifiez la **configuration centrale**.
+
+## Recette 1 : Façonner un agent à travers tous les workflows qu’il dispatche
+
+**Cas d’usage :** Standardiser l’utilisation des outils et les intégrations avec les systèmes externes pour que chaque workflow dispatché par un agent hérite du comportement. C’est le pattern le plus impactant.
+
+**Exemple : Amelia (agent dev) utilise toujours Context7 pour la documentation des bibliothèques, et se rabat sur Linear quand une story n’est pas trouvée dans la liste des epics.**
+
+```toml
+# _bmad/custom/bmad-agent-dev.toml
+
+[agent]
+
+# Appliqué à chaque activation. Se propage dans dev-story, quick-dev,
+# create-story, code-review, qa-generate — chaque skill qu'Amelia dispatche.
+persistent_facts = [
+  "Pour toute recherche de documentation sur une bibliothèque (React, TypeScript, Zod, Prisma, etc.), appeler l'outil MCP context7 (`mcp__context7__resolve_library_id` puis `mcp__context7__get_library_docs`) avant de s'appuyer sur les connaissances des données d'entraînement. Les docs à jour priment sur les API mémorisées.",
+  "Quand une référence de story n'est pas trouvée dans {planning_artifacts}/epics-and-stories.md, chercher dans Linear via `mcp__linear__search_issues` en utilisant l'ID ou le titre de la story avant de demander à l'utilisateur de clarifier. Si Linear renvoie un résultat, le considérer comme la source de référence pour la story.",
+]
+```
+
+**Pourquoi ça marche :** Deux phrases suffisent à reconfigurer tous les workflows de dev de l’organisation, sans duplication par workflow ni modification du code source. Chaque nouvel ingénieur qui clone le dépôt hérite automatiquement des conventions.
+
+**Fichier d’équipe vs fichier personnel :**
+- `bmad-agent-dev.toml` : versionné dans git ; s’applique à toute l’équipe
+- `bmad-agent-dev.user.toml` : ignoré par git ; préférences personnelles ajoutées par-dessus
+
+## Recette 2 : Imposer les conventions de l’organisation dans un workflow spécifique
+
+**Cas d’usage :** Façonner le *contenu* de la sortie d’un workflow pour qu’il réponde aux exigences de conformité, d’audit ou des consommateurs en aval.
+
+**Exemple : chaque product brief doit inclure des champs de conformité, et l’agent connaît les conventions de publication de l’organisation.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+persistent_facts = [
+  "Chaque brief doit inclure un champ 'Propriétaire', un champ 'Release cible' et un champ 'Statut de la revue de sécurité'.",
+  "Les briefs non commerciaux (outils internes, projets de recherche) doivent toujours inclure une section 'valeur utilisateur', mais peuvent omettre la différenciation concurrentielle.",
+  "file:{project-root}/docs/enterprise/brief-publishing-conventions.md",
+]
+```
+
+**Ce qui se passe :** Les faits sont chargés durant l’étape 3 de l’activation du workflow. Quand l’agent rédige le brief, il connaît les champs requis et le document de conventions enterprise. La valeur par défaut livrée (`file:{project-root}/**/project-context.md`) se charge toujours, car il s’agit d’un ajout.
+
+## Recette 3 : Publier les livrables finis vers des systèmes externes
+
+**Cas d’usage :** Une fois le livrable produit, le publier automatiquement vers les systèmes de référence de l’entreprise (Confluence, Notion, SharePoint) et créer des tickets de suivi (Jira, Linear, Asana).
+
+**Exemple : les briefs sont automatiquement publiés vers Confluence et proposent la création facultative d’un epic Jira.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+# Hook terminal. L'override scalaire remplace intégralement la valeur par défaut vide.
+on_complete = """
+Publier et proposer le suivi :
+
+1. Lire le chemin du fichier brief finalisé depuis l'étape précédente.
+2. Appeler `mcp__atlassian__confluence_create_page` avec :
+   - space : "PRODUCT"
+   - parent : "Product Briefs"
+   - title : le titre du brief
+   - body : le contenu markdown du brief
+   Capturer l'URL de la page renvoyée.
+3. Informer l'utilisateur : "Brief publié sur Confluence : <url>".
+4. Demander : "Voulez-vous que j'ouvre un epic Jira pour ce brief maintenant ?"
+5. Si oui, appeler `mcp__atlassian__jira_create_issue` avec :
+   - type : "Epic"
+   - project : "PROD"
+   - summary : le titre du brief
+   - description : un résumé court accompagné d'un lien vers la page Confluence.
+   Signaler la clé et l'URL de l'epic.
+6. Si non, se terminer proprement.
+
+Si l'un des outils MCP échoue, signaler l'échec, afficher le chemin du brief,
+et demander à l'utilisateur de publier manuellement.
+"""
+```
+
+**Pourquoi `on_complete` et pas `activation_steps_append` :** `on_complete` s’exécute exactement une fois, au stade terminal, après que le workflow a écrit sa sortie principale. C’est le bon moment pour publier des artefacts. `activation_steps_append` s’exécute à chaque activation, avant que le workflow ne fasse son travail.
+
+**Arbitrages :**
+- **La publication Confluence est non-destructive** et s’exécute toujours à la fin
+- **La création d’epic Jira est visible par toute l’équipe** et déclenche un processus de planification de sprint, conditionnez-la donc à la confirmation de l’utilisateur
+- **Dégradation gracieuse :** si les outils MCP échouent, passer la main à l’utilisateur plutôt que de silencieusement abandonner le livrable
+
+## Recette 4 : Remplacer le template de sortie par le vôtre
+
+**Cas d’usage :** La structure de sortie par défaut ne correspond pas au format attendu par votre organisation, ou différentes organisations dans le même dépôt ont besoin de templates différents.
+
+**Exemple : pointer le workflow product-brief vers un template appartenant à l’entreprise.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+```
+
+**Comment ça marche :** Le `customize.toml` du workflow est fourni avec `brief_template = "resources/brief-template.md"` (chemin relatif, résolu depuis la racine du skill). Votre override pointe vers un fichier sous `{project-root}`, donc l’agent lit votre template à l’étape 4 au lieu de celui livré par défaut.
+
+**Conseils pour la rédaction de templates :**
+- Gardez les templates dans `{project-root}/docs/` ou `{project-root}/_bmad/custom/templates/` pour qu’ils soient versionnés avec le fichier d’override
+- Utilisez les mêmes conventions structurelles que le template livré (titres de sections, frontmatter) ; l’agent s’adapte à ce qu’il trouve
+- Pour les dépôts multi-organisations, utilisez `.user.toml` pour permettre à chaque équipe de pointer vers ses propres templates sans toucher au fichier d’équipe versionné dans git
+
+## Recette 5 : Personnaliser le registre des agents
+
+**Cas d’usage :** Changer *qui sera présent dans la pièce* pour les skills basés sur le registre comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation`, sans modifier le code source ni forker. Voici trois variantes courantes.
+
+### 5a. Renommer un agent BMad pour toute l’organisation
+
+Chaque agent réel possède un descripteur que l’installateur synthétise à partir de `module.yaml`. Surchargez-le pour changer la voix et le cadrage pour tous les consommateurs du registre :
+
+```toml
+# _bmad/custom/config.toml (versionné dans git — s'applique à tous les développeurs)
+
+[agents.bmad-agent-analyst]
+description = "Mary l'Analyste d'Affaires sensible à la réglementation — s'inspire de Porter et Minto, mais vit et respire les pistes d'audit FDA. Parle comme un expert en criminalistique présentant un dossier."
+```
+
+Party-mode génère Mary avec la nouvelle description. L’activation de l’analyste elle-même fonctionne toujours normalement car le comportement de Mary se trouve dans son `customize.toml` par skill. Cet override change la façon dont **les skills externes la perçoivent et la présentent**, pas la façon dont elle travaille en interne.
+
+### 5b. Ajouter un agent fictif ou personnalisé
+
+Un descripteur complet suffit pour les fonctionnalités basées sur le registre, sans dossier de skill nécessaire. Utile pour varier les personnalités en mode party ou en session de brainstorming :
+
+```toml
+# _bmad/custom/config.user.toml (personnel — ignoré par git)
+
+[agents.spock]
+team = "startrek"
+name = "Commander Spock"
+title = "Science Officer"
+icon = "🖖"
+description = "Logique d'abord, émotion réprimée. Commence ses observations par 'Fascinant.' Ne force jamais le trait. Fait contrepoids à tout argument reposant sur l'intuition."
+
+[agents.mccoy]
+team = "startrek"
+name = "Dr. Leonard McCoy"
+title = "Chief Medical Officer"
+icon = "⚕️"
+description = "Chaleur du médecin de campagne, caractère explosif. 'Bon sang Jim, je suis un docteur pas un ___.' Contrepoids éthique à Spock."
+```
+
+Demandez à party-mode d'« inviter l’équipage de l’Enterprise ». Il filtre par `team = "startrek"` et génère Spock et McCoy avec ces descripteurs. Les agents BMad réels (Mary, Amelia) peuvent se retrouver à la même table si vous les invitez.
+
+### 5c. Figer les paramètres d’installation de l’équipe
+
+L’installateur demande à chaque développeur des valeurs comme le chemin `planning_artifacts`. Quand l’organisation a besoin d’une réponse partagée, figez-la dans la configuration centrale — la réponse locale de chaque développeur est surchargée au moment de la résolution :
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "{project-root}/shared/planning"
+implementation_artifacts = "{project-root}/shared/implementation"
+
+[core]
+document_output_language = "English"
+```
+
+Les paramètres personnels comme `user_name`, `communication_language` ou `user_skill_level` restent dans leur propre fichier `_bmad/config.user.toml` de chaque développeur. Le fichier d’équipe ne doit pas les modifier.
+
+**Pourquoi la configuration centrale vs le customize.toml par agent :** Les fichiers par agent façonnent la façon dont *un seul* agent se comporte quand il s’active. La configuration centrale façonne ce que les consommateurs du registre *voient* : quels agents existent, comment ils s’appellent, à quelle équipe ils appartiennent, et les paramètres d’installation partagés sur lesquels tout le dépôt s’accorde. Deux surfaces, des rôles différents.
+
+## Renforcer les règles globales dans le fichier de session de votre IDE
+
+Les personnalisations BMad se chargent quand un skill est activé. Beaucoup d’outils IDE chargent aussi un fichier d’instructions global au **début de chaque session**, avant tout skill (`CLAUDE.md`, `AGENTS.md`, `.cursor/rules/`, `.github/copilot-instructions.md`, etc.). Pour les règles qui doivent s’appliquer même en dehors des skills BMad, reproduisez-y les plus critiques.
+
+**Quand les utiliser ensemble :**
+- Une règle est suffisamment importante pour qu’une conversation simple (sans skill actif) doive la respecter
+- Vous voulez une double sécurisation parce que les défauts des données d’entraînement pourraient autrement détourner le modèle
+- La règle est assez concise pour être répétée sans alourdir le fichier de session
+
+**Exemple : une ligne dans le `CLAUDE.md` du dépôt renforçant la règle de l’agent dev de la Recette 1.**
+
+```markdown
+<!-- Toute lecture de documentation de bibliothèque passe par l'outil MCP context7
+(`mcp__context7__resolve_library_id` puis `mcp__context7__get_library_docs`)
+avant de s'appuyer sur les connaissances des données d'entraînement. -->
+```
+
+Une phrase, chargée à chaque session. Elle s’associe à la personnalisation `bmad-agent-dev.toml` pour que la règle s’applique à la fois dans les workflows d’Amelia et lors des chats ad hoc avec l’assistant. Chaque couche possède son propre périmètre :
+
+| Couche                                             | Périmètre                                                | Utilisée pour                                                           |
+|----------------------------------------------------|----------------------------------------------------------|-------------------------------------------------------------------------|
+| Fichier de session IDE (`CLAUDE.md` / `AGENTS.md`) | Chaque session, avant toute activation de skill          | Règles courtes et universelles qui doivent survivre hors de BMad        |
+| Personnalisation d’agent BMad                      | Chaque workflow que l’agent dispatche                    | Comportement spécifique au persona de l’agent                           |
+| Personnalisation de workflow BMad                  | Une exécution de workflow                                | Forme de sortie spécifique au workflow, hooks de publication, templates |
+| Configuration centrale BMad                        | Registre des agents + paramètres d’installation partagés | Qui est dans la pièce et quels chemins partagés l’équipe utilise        |
+
+Gardez le fichier IDE **concis**. Une douzaine de lignes bien choisies sont plus efficaces qu’une liste étendue. Les modèles le lisent à chaque tour, et le superflu noie l’information utile.
+
+## Recette 6 : Patterns d’intégration avancés
+
+Plusieurs workflows BMad exposent une surface de configuration plus riche au-delà des bases couvertes dans les Recettes 1–5. Ces patterns — sources de connaissance à la demande, publication automatique des livrables, standards de documentation à la finalisation et templates interchangeables — apparaissent dans plusieurs workflows. Consultez le `customize.toml` d’un workflow pour voir quels champs il expose ; les exemples ci-dessous utilisent `bmad-prd` car il les expose tous, mais les mêmes patterns s’appliquent partout où le champ apparaît.
+
+### Sources de connaissance à la demande (`external_sources`)
+
+Connectez le workflow à des bases de connaissances internes, des bases de données concurrentielles ou des référentiels de conformité. L’agent les consulte à la demande quand la conversation révèle un besoin correspondant — jamais par anticipation.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (même pattern pour tout workflow exposant external_sources)
+
+[workflow]
+external_sources = [
+  "Quand l'utilisateur mentionne un concurrent ou un segment de marché, interroger corp:competitive_db (category={project_name}) avant de rédiger la section différenciation.",
+  "Pour les domaines réglementés (santé, fintech, éducation), consulter corp:compliance_reference avant de rédiger les sections spécifiques au domaine.",
+]
+```
+
+Chaque entrée est une directive en langage naturel nommant l’outil MCP, la condition de déclenchement et les champs nécessaires. Si l’outil n’est pas disponible à l’exécution, le workflow se rabat sur le comportement standard et signale l’écart.
+
+### Publication automatique des livrables (`external_handoffs`)
+
+Acheminez les artefacts terminés vers les systèmes de référence externes après la finalisation du workflow. Contrairement à `on_complete` (Recette 3), `external_handoffs` est un tableau d’ajout dédié — les entrées d’équipe s’accumulent et chaque handoff se déclenche indépendamment avec dégradation progressive si un outil est indisponible.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (même pattern pour tout workflow exposant external_handoffs)
+
+[workflow]
+external_handoffs = [
+  "Après la finalisation, uploader prd.md et addendum.md vers Confluence via corp:confluence_upload (space_key='PROD', parent_page='PRDs', label='prd', author={user_name}). Capturer et afficher l'URL de la page renvoyée.",
+  "Répliquer vers Notion via notion:create_page (database_id='abc123', title='PRD: ' + {project_name}).",
+]
+```
+
+Si un outil nommé est indisponible, le handoff est ignoré et signalé — les fichiers locaux existent toujours indépendamment.
+
+### Standards de documentation à la finalisation (`doc_standards`)
+
+Appliquez les standards rédactionnels de l’organisation aux documents à destination des utilisateurs à la finalisation, après que le contenu est complet mais avant que l’utilisateur ne voie le livrable. Chaque entrée est une directive `skill:`, `file:` ou en texte brut ; les passes s’exécutent comme des sous-agents parallèles.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (même pattern pour tout workflow exposant doc_standards)
+
+[workflow]
+doc_standards = [
+  "file:{project-root}/docs/enterprise/voice-and-tone.md",
+  "Toutes les dates doivent utiliser le format ISO 8601 (AAAA-MM-JJ).",
+  "Remplacer toute utilisation de 'tirer parti de' par 'utiliser'.",
+]
+```
+
+`doc_standards` est un tableau d’ajout — les entrées d’équipe s’ajoutent aux valeurs par défaut livrées par le workflow. Les passes structurelles larges doivent venir avant les passes rédactionnelles plus ciblées.
+
+### Templates et checklists interchangeables
+
+Les workflows qui produisent des documents structurés exposent généralement des chemins de templates et de checklists comme scalaires surchargeables. Pointez-les vers des fichiers appartenant à l’organisation sous `{project-root}` pour imposer une structure différente sans modifier le code source.
+
+```toml
+# _bmad/custom/bmad-prd.toml
+
+[workflow]
+# Structure de PRD pour secteur réglementé
+prd_template = "{project-root}/docs/enterprise/prd-template-hipaa.md"
+
+# Critères de validation spécifiques à l'organisation
+validation_checklist = "{project-root}/docs/enterprise/prd-checklist-regulated.md"
+```
+
+L’agent s’adapte à la structure définie par le template. Gardez les templates sous `{project-root}/docs/` ou `{project-root}/_bmad/custom/templates/` pour qu’ils soient versionnés avec le fichier d’override. Pour les dépôts multi-organisations, utilisez `.user.toml` pour permettre aux équipes de pointer vers leurs propres templates sans toucher au fichier d’équipe versionné dans git.
+
+## Combiner les recettes
+
+Les six recettes se combinent librement. Un override entreprise réaliste pour `bmad-product-brief` pourrait définir `persistent_facts` (Recette 2), `on_complete` (Recette 3) et `brief_template` (Recette 4) dans un seul fichier. La règle au niveau agent (Recette 1) se trouve dans un fichier séparé sous le nom de l’agent, la configuration centrale (Recette 5) fige le registre partagé et les paramètres d’équipe, les patterns d’intégration avancés (Recette 6) configurent les sources externes et les handoffs, et toutes les couches s’appliquent en parallèle.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml (niveau workflow)
+
+[workflow]
+persistent_facts = ["..."]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+on_complete = """ ... """
+```
+
+```toml
+# _bmad/custom/bmad-agent-analyst.toml (niveau agent — Mary dispatche product-brief)
+
+[agent]
+persistent_facts = ["Toujours inclure une section 'Revue réglementaire' quand le domaine implique la santé, la finance ou les données d'enfants."]
+```
+
+Résultat : Mary charge la règle de revue réglementaire à l’activation de son persona. Quand l’utilisateur choisit le product brief dans le menu, le workflow charge ses propres conventions par-dessus, écrit avec le template enterprise et publie vers Confluence à la fin. Chaque couche contribue, et aucune n’a nécessité de modifier le code source de BMad.
+
+## Dépannage
+
+**L’override ne prend pas effet ?** Vérifiez que le fichier se trouve sous `_bmad/custom/` avec le nom exact du répertoire du skill (ex. `bmad-agent-dev.toml`, pas `bmad-dev.toml`). Voir [Comment personnaliser BMad](./customize-bmad.md#dépannage).
+
+**Nom d’outil MCP inconnu ?** Utilisez le nom exact que le serveur MCP expose dans la session en cours. Demandez à Claude Code de lister les outils MCP disponibles en cas de doute. Les noms codés en dur dans `persistent_facts` ou `on_complete` ne fonctionneront pas si le serveur MCP n’est pas connecté.
+
+**Le pattern ne s’applique pas à ma configuration ?** Les recettes ci-dessus sont illustratives. L’infrastructure sous-jacente (fusion à trois couches, règles structurelles, agent traversant les workflows) supporte de nombreux patterns supplémentaires ; composez-les selon vos besoins.

docs/fr/how-to/get-answers-about-bmad.md

@@ -2,14 +2,14 @@
 title: "Comment obtenir des réponses à propos de BMad"
 description: Utiliser un LLM pour répondre rapidement à vos questions sur BMad
 sidebar:
-  order: 4
+  order: 5
 ---
 
-Utilisez l'aide intégrée de BMad, la documentation source ou la communauté pour obtenir des réponses — du plus rapide au plus approfondi.
+Utilisez l’aide intégrée de BMad, la documentation source ou la communauté pour obtenir des réponses — du plus rapide au plus approfondi.
 
 ## 1. Demandez à BMad-Help
 
-Le moyen le plus rapide d'obtenir des réponses. Le skill `bmad-help` est disponible directement dans votre session IA et répond à plus de 80 % des questions — il inspecte votre projet, voit ce que vous avez accompli et vous dit quoi faire ensuite.
+Le moyen le plus rapide d’obtenir des réponses. Le skill `bmad-help` est disponible directement dans votre session IA et répond à plus de 80 % des questions — il inspecte votre projet, voit ce que vous avez accompli et vous dit quoi faire ensuite.
 
 ```
 bmad-help J'ai une idée de SaaS et je connais toutes les fonctionnalités. Par où commencer ?
@@ -23,58 +23,58 @@ Vous pouvez également utiliser `/bmad-help` ou `$bmad-help` selon votre platefo
 
 ## 2. Approfondissez avec les sources
 
-BMad-Help s'appuie sur votre configuration installée. Pour les questions sur les éléments internes de BMad, son historique ou son architecture — ou si vous faites des recherches sur BMad avant de l'installer — pointez votre IA directement vers les sources.
+BMad-Help s’appuie sur votre configuration installée. Pour les questions sur les éléments internes de BMad, son historique ou son architecture — ou si vous faites des recherches sur BMad avant de l’installer — pointez votre IA directement vers les sources.
 
-Clonez ou ouvrez le [dépôt BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) et posez vos questions à votre IA. Tout outil capable d'utiliser des agents (Claude Code, Cursor, Windsurf, etc.) peut lire les sources et répondre directement à vos questions.
+Clonez ou ouvrez le [dépôt BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) et posez vos questions à votre IA. Tout outil capable d’utiliser des agents (Claude Code, Cursor, Windsurf, etc.) peut lire les sources et répondre directement à vos questions.
 
 :::note[Exemple]
-**Q :** "Quel est le moyen le plus rapide de construire quelque chose avec BMad ?"
+**Q :** « Quel est le moyen le plus rapide de construire quelque chose avec BMad ? »
 
-**R :** Utilisez le flux rapide : Lancez `bmad-quick-dev` — il clarifie votre intention, planifie, implémente, révise et présente les résultats dans un seul workflow, en sautant les phases de planification complètes.
+**R :** Utilisez le flux rapide : Lancez `bmad-quick-dev` — il clarifie votre intention, planifie, implémente, révise et présente les résultats dans un seul workflow, en sautant les phases de planification complètes.
 :::
 
-**Conseils pour de meilleures réponses :**
+**Conseils pour de meilleures réponses :**
 
-- **Soyez précis** — "Que fait l'étape 3 du workflow PRD ?" est mieux que "Comment fonctionne le PRD ?"
+- **Soyez précis** — « Que fait l’étape 3 du workflow PRD ? » est mieux que « Comment fonctionne le PRD ? »
 - **Vérifiez les affirmations surprenantes** — Les LLM font parfois des erreurs. Consultez le fichier source ou posez la question sur Discord.
 
-### Vous n'utilisez pas d'agent ? Utilisez le site de documentation
+### Vous n’utilisez pas d’agent ? Utilisez le site de documentation
 
-Si votre IA ne peut pas lire des fichiers locaux (ChatGPT, Claude.ai, etc.), importez [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) dans votre session — c'est un instantané en un seul fichier de la documentation BMad.
+Si votre IA ne peut pas lire des fichiers locaux (ChatGPT, Claude.ai, etc.), importez [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) dans votre session — c’est un instantané en un seul fichier de la documentation BMad.
 
-## 3. Demandez à quelqu'un
+## 3. Demandez à quelqu’un
 
-Si ni BMad-Help ni la source n'ont répondu à votre question, vous avez maintenant une bien meilleure question à poser.
+Si ni BMad-Help ni la source n’ont répondu à votre question, vous avez maintenant une bien meilleure question à poser.
 
-| Canal                   | Utilisé pour                                     |
-| ------------------------- | ------------------------------------------- |
-| Forum `help-requests`     | Questions                                   |
-| `#suggestions-feedback`   | Idées et demandes de fonctionnalités                  |
+| Canal                   | Utilisé pour                         |
+|-------------------------|--------------------------------------|
+| Forum `help-requests`   | Questions                            |
+| `#suggestions-feedback` | Idées et demandes de fonctionnalités |
 
-**Discord :** [discord.gg/gk8jAdXWmj](https://discord.gg/gk8jAdXWmj)
+**Discord :** [discord.gg/gk8jAdXWmj](https://discord.gg/gk8jAdXWmj)
 
-**GitHub Issues :** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
-*Toi !*
-        *Bloqué*
-             *dans la file d'attente—*
-                      *qui*
-                              *attends-tu ?*
+**GitHub Issues :** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
+*Toi !*
+*Bloqué*
+*dans la file d’attente—*
+*qui*
+*attends-tu ?*
 
 *La source*
-        *est là,*
-                *facile à voir !*
+*est là,*
+*facile à voir !*
 
 *Pointez*
-     *votre machine.*
-              *Libérez-la.*
+*votre machine.*
+*Libérez-la.*
 
 *Elle lit.*
-        *Elle parle.*
-                *Demandez—*
+*Elle parle.*
+*Demandez—*
 
 *Pourquoi attendre*
-        *demain*
-                *quand tu as déjà*
-                        *cette journée ?*
+*demain*
+*quand tu as déjà*
+*cette journée ?*
 
 *—Claude*

docs/fr/how-to/install-bmad.md

@@ -1,116 +1,266 @@
 ---
 title: "Comment installer BMad"
-description: Guide étape par étape pour installer BMad dans votre projet
+description: Installer, mettre à jour et épingler BMad pour le développement local, les équipes et CI
 sidebar:
   order: 1
 ---
 
-Utilisez la commande `npx bmad-method install` pour configurer BMad dans votre projet avec votre choix de modules et d'outils d'IA.
+Utilisez `npx bmad-method install` pour configurer BMad dans votre projet. Une seule commande gère les premières installations, les mises à niveau, le changement de canal et les exécutions CI scriptées. Cette page couvre tout cela.
 
-Si vous souhaitez utiliser un installateur non interactif et fournir toutes les options d'installation en ligne de commande, consultez [ce guide](./non-interactive-installation.md).
-
-## Quand l'utiliser
+## Quand l’utiliser
 
 - Démarrer un nouveau projet avec BMad
-- Ajouter BMad à une base de code existante
-- Mettre à jour une installation BMad existante
+- Ajouter ou retirer des modules sur une installation existante
+- Basculer un module sur main-HEAD ou l’épingler à une version spécifique
+- Scripter des installations pour des pipelines CI, des Dockerfiles ou des déploiements en entreprise
 
 :::note[Prérequis]
-- **Node.js** 20.12+ (requis pour l'installateur)
-- **Git** (recommandé)
-- **Outil d'IA** (Claude Code, Cursor, ou similaire)
+
+- **Node.js** 20.12+ (requis pour l’installateur)
+- **Git** (pour cloner les modules externes)
+- **Un outil d’IA** tel que Claude Code ou Cursor (exécutez `npx bmad-method install --list-tools` pour voir tous les outils supportés)
+
 :::
 
-## Étapes
-
-### 1. Lancer l'installateur
+## Première installation (méthode rapide)
 
 ```bash
 npx bmad-method install
 ```
 
-:::tip[Vous voulez la dernière version préliminaire ?]
-Utilisez le dist-tag `next` :
+L’assistant interactif vous pose cinq questions :
+
+1. Le répertoire d’installation (par défaut le répertoire de travail courant)
+2. Quels modules installer (cases à cocher pour core, bmm, bmb, cis, gds, tea)
+3. **« Ready to install (all stable)? »** — Oui accepte le dernier tag publié pour chaque module externe
+4. Quels outils/IDE d’IA intégrer (claude-code, cursor et d’autres)
+5. La configuration par module (nom, langue, dossier de sortie)
+
+En acceptant les valeurs par défaut, vous obtenez la dernière version stable de chaque module, configurée pour votre outil choisi.
+
+:::tip[Vous voulez juste la dernière préversion ?]
+
 ```bash
 npx bmad-method@next install
 ```
 
-Cela vous permet d'obtenir les nouvelles modifications plus tôt, avec un risque plus élevé de changements que l'installation par défaut.
+Exécute l’installateur de préversion, qui fournit un snapshot plus récent de core et bmm. Davantage de changements, avec un délai réduit entre le développement et la publication.
 :::
 
-:::tip[Version de développement]
-Pour installer la dernière version depuis la branche main (peut être instable) :
+## Choisir une version spécifique
+
+Deux axes indépendants contrôlent ce qui se retrouve sur le disque.
+
+### Axe 1 : canaux des modules externes
+
+Chaque module externe — bmb, cis, gds, tea, et tout module communautaire — s’installe via l’un des trois canaux suivants :
+
+| Canal             | Ce qui est installé                                                                  | Pour qui                                      |
+|-------------------|--------------------------------------------------------------------------------------|-----------------------------------------------|
+| `stable` (défaut) | Le plus haut tag semver publié. Les préversions comme `v2.0.0-alpha.1` sont exclues. | La plupart des utilisateurs                   |
+| `next`            | Le HEAD de la branche main au moment de l’installation                               | Contributeurs, early adopters                 |
+| `pinned`          | Un tag spécifique de votre choix                                                     | Installations entreprise, reproductibilité CI |
+
+Les canaux sont définis module par module. Vous pouvez exécuter bmb sur `next` tout en laissant cis sur `stable` — les options ci-dessous permettent de les combiner librement.
+
+### Axe 2 : version du binaire de l’installateur
+
+Le paquet npm `bmad-method` lui-même a deux dist-tags :
+
+| Commande                              | Ce que vous obtenez                                                                   |
+|---------------------------------------|---------------------------------------------------------------------------------------|
+| `npx bmad-method install` (`@latest`) | Dernière version stable de l’installateur                                             |
+| `npx bmad-method@next install`        | Dernière préversion de l’installateur, publiée automatiquement à chaque push sur main |
+
+**Le binaire de l’installateur détermine vos versions de core et bmm.** Ces deux modules sont embarqués dans le paquet de l’installateur plutôt que clonés depuis des dépôts séparés.
+
+### Pourquoi core et bmm n’ont pas leur propre canal
+
+Ils sont liés au binaire de l’installateur que vous avez exécuté :
+
+- `npx bmad-method install` → core et bmm stables les plus récents
+- `npx bmad-method@next install` → core et bmm en préversion
+- `node /chemin/vers/checkout-local/tools/installer/bmad-cli.js install` → ce que votre checkout local contient
+
+`--pin bmm=v6.3.0` et `--next=bmm` n’ont aucun effet sur les modules intégrés (l’installateur vous avertit si vous tentez de les utiliser). Une prochaine version détachera bmm du paquet de l’installateur ; une fois publiée, bmm disposera d’un sélecteur de canal dédié, comme c’est le cas pour bmb aujourd’hui.
+
+## Mettre à jour une installation existante
+
+Exécuter `npx bmad-method install` dans un répertoire contenant déjà `_bmad/` affiche un menu :
+
+| Choix              | Ce qu’il fait                                                                                                                                                                                                        |
+|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Quick Update**   | Réexécute l’installation avec vos paramètres existants. Rafraîchit les fichiers, applique les correctifs et les mises à niveau mineures du canal stable, refuse les mises à niveau majeures. Rapide, non interactif. |
+| **Modify Install** | Flux interactif complet. Ajoutez ou retirez des modules, reconfigurez les paramètres, examinez et, si besoin, modifiez les canaux des modules existants.                                                             |
+
+### Invites de mise à niveau
+
+Quand Modify détecte un tag stable plus récent pour un module que vous avez installé sur `stable`, il classe le diff et vous invite en conséquence :
+
+| Type de mise à niveau | Exemple         | Défaut |
+| --------------------- | --------------- | ------ |
+| Patch                 | v1.7.0 → v1.7.1 | O      |
+| Mineure               | v1.7.0 → v1.8.0 | O      |
+| Majeure               | v1.7.0 → v2.0.0 | **N**  |
+
+Les mises à niveau majeures sont refusées par défaut (N) car les changements cassants se manifestent souvent comme une « instabilité » quand ils ne sont pas attendus. L’invite inclut une URL vers les notes de version GitHub pour que vous puissiez lire ce qui a changé avant d’accepter.
+
+Avec `--yes`, les mises à niveau patch et mineure s’appliquent automatiquement. Les majeures restent bloquées — utilisez `--pin <code>=<nouveau-tag>` pour les accepter de manière non interactive.
+
+### Changer le canal d’un module
+
+**En mode interactif :** choisissez Modify → répondez **Oui** à « Review channel assignments? » → chaque module externe offre Conserver, Basculer vers stable, Basculer vers next, ou Épingler à un tag.
+
+**En ligne de commande :** les recettes dans la section suivante couvrent les cas courants.
+
+## Installations CI non interactives
+
+### Référence des options
+
+| Option                                                                                     | Objectif                                                                                                                                                                    |
+|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `--yes`, `-y`                                                                              | Ignorer toutes les invites ; accepter les valeurs des options + les défauts                                                                                                 |
+| `--directory <chemin>`                                                                     | Installer dans ce répertoire (défaut : répertoire de travail courant)                                                                                                       |
+| `--modules <a,b,c>`                                                                        | Ensemble exact de modules. Core est ajouté automatiquement. Ce n’est pas un delta — listez tout ce que vous voulez conserver.                                               |
+| `--tools <a,b>`                                                                            | Sélection d’IDE/outil. Requis pour les nouvelles installations `--yes`. Exécutez `--list-tools` pour les IDs valides.                                                       |
+| `--list-tools`                                                                             | Afficher tous les IDs d’outils/IDE supportés (avec les répertoires cibles) et quitter.                                                                                      |
+| `--action <type>`                                                                          | `install`, `update` ou `quick-update`. La valeur par défaut dépend de l’état de l’installation.                                                                             |
+| `--custom-source <urls>`                                                                   | Installer des modules personnalisés depuis des URLs Git ou des chemins locaux                                                                                               |
+| `--channel <stable\|next>`                                                                 | Appliquer à tous les externes (alias `--all-stable` / `--all-next`)                                                                                                         |
+| `--all-stable`                                                                             | Alias pour `--channel=stable`                                                                                                                                               |
+| `--all-next`                                                                               | Alias pour `--channel=next`                                                                                                                                                 |
+| `--next=<code>`                                                                            | Mettre un module sur next. Répétable.                                                                                                                                       |
+| `--pin <code>=<tag>`                                                                       | Épingler un module à un tag spécifique. Répétable.                                                                                                                          |
+| `--set <module>.<clé>=<valeur>`                                                            | Définir toute option de config de module de manière non interactive (recommandé — voir [Substitutions de config de module](#substitutions-de-config-de-module)). Répétable. |
+| `--list-options [module]`                                                                  | Afficher chaque clé `--set` pour les modules intégrés et officiels en cache local, puis quitter. Passez un code de module pour limiter à un seul module.                    |
+| `--user-name`, `--communication-language`, `--document-output-language`, `--output-folder` | Raccourcis historiques équivalents à `--set core.<clé>=<valeur>` (toujours supportés)                                                                                       |
+
+Priorité en cas de chevauchement des options : `--pin` bat `--next=` bat `--channel` / `--all-*` bat le défaut du registre (`stable`).
+
+:::note[Exemple de résolution]
+`--all-next --pin cis=v0.2.0` met bmb, gds et tea sur next tout en épinglant cis à v0.2.0.
+:::
+
+### Recettes
+
+**Installation par défaut — dernière version stable pour tout :**
+
 ```bash
-npx github:bmad-code-org/BMAD-METHOD install
+npx bmad-method install --yes --modules bmm,bmb,cis --tools claude-code
 ```
+
+**Installation entreprise verrouillée — reproductible à l’octet près :**
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm,bmb,cis \
+  --pin bmb=v1.7.0 --pin cis=v0.2.0 \
+  --tools claude-code
+```
+
+**Bleeding edge — externes sur le HEAD de main :**
+
+```bash
+npx bmad-method install --yes --modules bmm,bmb --all-next --tools claude-code
+```
+
+**Ajouter un module à une installation existante** (conserver tout le reste) :
+
+```bash
+npx bmad-method install --yes --action update \
+  --modules bmm,bmb,gds
+```
+
+`--tools` est omis intentionnellement — `--action update` réutilise les outils configurés lors de la première installation.
+
+**Mixer les canaux — bmb sur next, gds sur stable :**
+
+```bash
+npx bmad-method install --yes --action update \
+  --modules bmm,bmb,cis,gds \
+  --next=bmb
+```
+
+### Substitutions de config de module
+
+`--set <module>.<clé>=<valeur>` vous permet de définir toute option de config de module de manière non interactive. Cette option est répétable et s’adapte à chaque module — présent et futur. L’option est appliquée comme un correctif post-installation : l’installateur exécute d’abord son flux normal, puis `--set` insère ou met à jour chaque valeur dans `_bmad/config.toml` (portée équipe) ou `_bmad/config.user.toml` (portée utilisateur), et dans `_bmad/<module>/config.yaml` pour que les valeurs déclarées soient conservées à la prochaine installation.
+
+**Exemple — installer bmm avec des connaissances projet et un niveau de compétence explicites :**
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm \
+  --tools claude-code \
+  --set bmm.project_knowledge=research \
+  --set bmm.user_skill_level=expert
+```
+
+**Découvrir les clés disponibles pour un module :**
+
+```bash
+npx bmad-method install --list-options bmm
+```
+
+`--list-options` (sans argument) liste chaque clé que l’installateur peut trouver localement — modules intégrés (`core`, `bmm`) plus tous les modules officiels actuellement en cache. Le cache est par machine et peut être vidé, donc les modules officiels précédemment installés n’apparaîtront pas sur un nouveau checkout ou un worker CI éphémère tant qu’ils ne sont pas réinstallés. Les modules communautaires et personnalisés ne sont pas énumérés ici ; lisez directement le `module.yaml` du module pour voir les clés qu’il déclare.
+
+**Comment ça fonctionne :**
+
+- **Routage.** L’étape de correctif cherche `[modules.<module>] <clé>` (ou `[core] <clé>`) dans `config.user.toml` en premier ; si elle y est trouvée, elle met à jour ce fichier. Sinon elle écrit dans le `config.toml` de portée équipe. Ainsi, les clés de portée utilisateur (ex. `core.user_name`, `bmm.user_skill_level`) finissent dans `config.user.toml` et les clés de portée équipe dans `config.toml`, correspondant à la partition utilisée par l’installateur.
+- **Valeurs littérales.** La valeur est écrite exactement comme vous l’avez fournie — aucun rendu de template `result:`. Pour obtenir la valeur résolue (ex. `{project-root}/research`), passez-la explicitement : `--set bmm.project_knowledge='{project-root}/research'`.
+- **Persistance, clés déclarées.** Les valeurs pour les clés déclarées dans `module.yaml` sont conservées entre les installations car elles sont aussi écrites dans `_bmad/<module>/config.yaml`, que l’installateur lit comme valeur par défaut de l’invite lors de la prochaine exécution.
+- **Persistance, clés non déclarées.** Une valeur pour une clé que le schéma du module ne déclare pas est enregistrée dans `config.toml` pour l’installation courante mais ne sera pas réécrite à la prochaine installation (le partitionneur strict au schéma du manifeste ignore les clés inconnues). Repassez `--set` pour qu’elle soit persistante, ou éditez `_bmad/config.toml` directement.
+- **Pas de validation.** Les valeurs `single-select` ne sont pas vérifiées contre les choix autorisés, et les clés inconnues ne sont pas rejetées — la valeur fournie est écrite telle quelle.
+- **Modules non présents dans `--modules`.** Définir une valeur pour un module que vous n’avez pas inclus affiche un avertissement et la valeur est ignorée (aucun fichier n’est créé pour un module non installé).
+
+Les raccourcis historiques de core (`--user-name`, `--output-folder`, etc.) fonctionnent toujours et restent documentés pour la rétrocompatibilité, mais `--set core.user_name=...` est équivalent.
+
+:::note[Fonctionne avec quick-update]
+`--set` est un correctif post-installation, il s’applique donc de la même manière quel que soit le type d’action. Avec `bmad install --action quick-update` (ou `--yes` sur une installation existante, où quick-update est le défaut), `--set` met à jour les fichiers de configuration centraux à la fin comme une installation normale.
 :::
 
-### 2. Choisir l'emplacement d'installation
+:::caution[Limitation de débit sur les IPs partagées]
+Les appels anonymes à l’API GitHub sont limités à 60/heure par IP. Une seule installation fait un appel API par module externe pour résoudre le tag stable. Les bureaux derrière NAT, les pools de runners CI et les VPN peuvent collectivement épuiser cette limite.
 
-L'installateur vous demandera où installer les fichiers BMad :
-
-- Répertoire courant (recommandé pour les nouveaux projets si vous avez créé le répertoire vous-même et l'exécutez depuis ce répertoire)
-- Chemin personnalisé
-
-### 3. Sélectionner vos outils d'IA
-
-Choisissez les outils d'IA que vous utilisez :
-
-- Claude Code
-- Cursor
-- Autres
-
-Chaque outil a sa propre façon d'intégrer les skills. L'installateur crée de petits fichiers de prompt pour activer les workflows et les agents — il les place simplement là où votre outil s'attend à les trouver.
-
-:::note[Activer les skills]
-Certaines plateformes nécessitent que les skills soient explicitement activés dans les paramètres avant d'apparaître. Si vous installez BMad et ne voyez pas les skills, vérifiez les paramètres de votre plateforme ou demandez à votre assistant IA comment activer les skills.
+Définissez `GITHUB_TOKEN=<personal access token>` dans l’environnement pour augmenter la limite à 5 000/heure par compte. Tout PAT avec accès en lecture aux dépôts publics fonctionne ; aucune portée spécifique n’est requise.
 :::
 
-### 4. Choisir les modules
+## Ce qui a été installé
 
-L'installateur affiche les modules disponibles. Sélectionnez ceux dont vous avez besoin — la plupart des utilisateurs veulent simplement **méthode BMad** (le module de développement logiciel).
+Après toute installation, `_bmad/_config/manifest.yaml` enregistre exactement ce qui est sur le disque :
 
-### 5. Suivre les instructions
-
-L'installateur vous guide pour le reste — paramètres, intégrations d'outils, etc.
-
-## Ce que vous obtenez
-
-```text
-votre-projet/
-├── _bmad/
-│   ├── bmm/            # Vos modules sélectionnés
-│   │   └── config.yaml # Paramètres du module (si vous devez les modifier)
-│   ├── core/           # Module core requis
-│   └── ...
-├── _bmad-output/       # Artefacts générés
-├── .claude/            # Skills Claude Code (si vous utilisez Claude Code)
-│   └── skills/
-│       ├── bmad-help/
-│       ├── bmad-persona/
-│       └── ...
-└── .cursor/            # Skills Cursor (si vous utilisez Cursor)
-    └── skills/
-        └── ...
+```yaml
+modules:
+  - name: bmb
+    version: v1.7.0 # le tag, ou "main" pour next
+    channel: stable # stable | next | pinned
+    sha: 86033fc9aeae2ca6d52c7cdb675c1f4bf17fc1c1
+    source: external
+    repoUrl: https://github.com/bmad-code-org/bmad-builder
 ```
 
-## Vérifier l'installation
+Le champ `sha` est écrit pour les modules basés sur git (externes, communautaires et personnalisés par URL). Les modules intégrés (core, bmm) et les modules personnalisés par chemin local n’en ont pas — leur code voyage avec le binaire de l’installateur ou votre système de fichiers, pas un ref clonable.
 
-Exécutez `bmad-help` pour vérifier que tout fonctionne et voir quoi faire ensuite.
+Pour la reproductibilité inter-machines, ne comptez pas sur la réexécution de la même commande `--modules`. Les installations sur canal stable résolvent vers le plus haut tag publié **au moment de l’installation**, donc une réexécution ultérieure obtiendra les versions publiées entre-temps. Convertissez les tags enregistrés de `manifest.yaml` en options `--pin` explicites sur la machine cible, par ex. :
 
-**BMad-Help est votre guide intelligent** qui va :
-- Confirmer que votre installation fonctionne
-- Afficher ce qui est disponible en fonction de vos modules installés
-- Recommander votre première étape
-
-Vous pouvez aussi lui poser des questions :
-```
-bmad-help Je viens d'installer, que dois-je faire en premier ?
-bmad-help Quelles sont mes options pour un projet SaaS ?
+```bash
+npx bmad-method install --yes --modules bmb,cis \
+  --pin bmb=v1.7.0 --pin cis=v0.4.2 --tools claude-code
 ```
 
 ## Résolution de problèmes
 
-**L'installateur affiche une erreur** — Copiez-collez la sortie dans votre assistant IA et laissez-le résoudre le problème.
+### « Could not resolve stable tag » ou « API rate limit exceeded »
 
-**L'installateur a fonctionné mais quelque chose ne fonctionne pas plus tard** — Votre IA a besoin du contexte BMad pour vous aider. Consultez [Comment obtenir des réponses à propos de BMad](./get-answers-about-bmad.md) pour savoir comment diriger votre IA vers les bonnes sources.
+Vous avez atteint la limite anonyme de 60/heure de GitHub. Définissez `GITHUB_TOKEN` et réessayez. Si vous avez déjà un token défini, il peut être expiré ou limité sur son propre budget — essayez un token différent ou attendez la réinitialisation horaire.
+
+### « Tag ’vX.Y.Z' not found »
+
+Le tag que vous avez passé à `--pin` n’existe pas dans le dépôt du module. Consultez la page des releases du dépôt sur GitHub pour les tags valides.
+
+### Une installation épinglée continue de se mettre à niveau
+
+Les installations épinglées ne se mettent pas à niveau. Quick-update applique les correctifs et les mises à niveau mineures uniquement sur le canal stable ; il ne touche pas `pinned` ou `next`. Si une installation épinglée a changé, ouvrez `_bmad/_config/manifest.yaml` — `channel: pinned` plus un `version` et `sha` fixes doivent rester stables d’une exécution à l’autre, sauf écrasement explicite via les options.
+
+### `--pin bmm=X` n’a rien fait
+
+bmm est un module intégré — `--pin` et `--next=` ne s’appliquent pas. Utilisez `npx bmad-method@next install` pour un core/bmm en préversion, ou clonez le dépôt bmad-bmm et exécutez l’installateur localement pour obtenir les modifications non publiées.

docs/fr/how-to/install-custom-modules.md

@@ -0,0 +1,181 @@
+---
+title: "Installer des modules personnalisés et communautaires"
+description: Installer des modules tiers depuis le registre communautaire, des dépôts Git ou des chemins locaux
+sidebar:
+  order: 3
+---
+
+Utilisez l’installateur BMad pour ajouter des modules depuis le registre communautaire, des dépôts Git tiers ou des chemins locaux.
+
+## Quand l’utiliser
+
+- Installer un module contribué par la communauté depuis le registre BMad
+- Installer un module depuis un dépôt Git tiers (GitHub, GitLab, Bitbucket, auto-hébergé)
+- Tester un module que vous développez localement avec BMad Builder
+- Installer des modules depuis un serveur Git privé ou auto-hébergé
+
+:::note[Prérequis]
+Nécessite [Node.js](https://nodejs.org) v20.12+ et `npx` (inclus avec npm). Les modules personnalisés et communautaires peuvent être sélectionnés lors d’une nouvelle installation ou ajoutés à une installation existante.
+:::
+
+## Modules communautaires
+
+Les modules communautaires sont regroupés dans le [marketplace de plugins BMad](https://github.com/bmad-code-org/bmad-plugins-marketplace). Ils sont organisés par catégorie et épinglés à un commit approuvé pour des raisons de sécurité.
+
+### 1. Lancer l’installateur
+
+```bash
+npx bmad-method install
+```
+
+### 2. Parcourir le catalogue communautaire
+
+Après avoir sélectionné les modules officiels, l’installateur demande :
+
+```
+Would you like to browse community modules?
+```
+
+Sélectionnez **Yes** pour accéder au navigateur de catalogue. Vous pouvez :
+
+- Parcourir par catégorie
+- Voir les modules phares
+- Voir tous les modules disponibles
+- Rechercher par mot-clé
+
+### 3. Sélectionner des modules
+
+Choisissez des modules dans n’importe quelle catégorie. L’installateur affiche les descriptions, versions et niveaux de confiance. Les modules déjà installés sont pré-sélectionnés pour la mise à jour.
+
+### 4. Poursuivre l’installation
+
+Après avoir sélectionné les modules communautaires, l’installateur passe aux sources personnalisées, puis à la configuration des outils/IDE et au reste du flux d’installation.
+
+## Sources personnalisées (URL Git et chemins locaux)
+
+Les modules personnalisés peuvent provenir de n’importe quel dépôt Git ou d’un répertoire local sur votre machine. L’installateur résout la source, analyse la structure du module et l’installe aux côtés de vos autres modules.
+
+### Installation interactive
+
+Durant l’installation, après l’étape des modules communautaires, l’installateur demande :
+
+```
+Would you like to install from a custom source (Git URL or local path)?
+```
+
+Sélectionnez **Yes**, puis indiquez une source :
+
+| Type d’entrée             | Exemple                                           |
+| ------------------------- | ------------------------------------------------- |
+| URL HTTPS (tout hôte)     | `https://github.com/org/repo`                     |
+| URL HTTP (tout hôte)      | `http://host/org/repo`                            |
+| URL HTTPS avec sous-rép.  | `https://github.com/org/repo/tree/main/my-module` |
+| URL SSH                   | `git@github.com:org/repo.git`                     |
+| Chemin local              | `/Users/me/projects/my-module`                    |
+| Chemin local avec tilde   | `~/projects/my-module`                            |
+
+L’installateur clone le dépôt (pour les URL) ou lit directement depuis le disque (pour les chemins locaux), puis présente les modules découverts pour la sélection.
+
+### Installation non interactive
+
+Utilisez l’option `--custom-source` pour installer des modules personnalisés depuis la ligne de commande :
+
+```bash
+npx bmad-method install \
+  --directory . \
+  --custom-source /path/to/my-module \
+  --tools claude-code \
+  --yes
+```
+
+Quand `--custom-source` est fourni sans `--modules`, seuls le cœur et les modules personnalisés sont installés. Pour inclure également les modules officiels, ajoutez `--modules` :
+
+```bash
+npx bmad-method install \
+  --directory . \
+  --modules bmm \
+  --custom-source https://gitlab.com/myorg/my-module \
+  --tools claude-code \
+  --yes
+```
+
+Plusieurs sources peuvent être séparées par des virgules :
+
+```bash
+--custom-source /path/one,https://github.com/org/repo,/path/two
+```
+
+## Fonctionnement de la découverte de modules
+
+L’installateur utilise deux modes pour trouver les modules installables dans une source :
+
+| Mode       | Déclencheur                                          | Comportement                                                                                                     |
+|------------|------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|
+| Découverte | La source contient `.claude-plugin/marketplace.json` | Liste tous les plugins du manifeste ; vous choisissez lesquels installer                                         |
+| Direct     | Aucun `marketplace.json` trouvé                      | Analyse le répertoire pour trouver des skills (sous-répertoires avec `SKILL.md`), les résout en un module unique |
+
+Le mode découverte est typique des modules publiés. Le mode direct est pratique pour pointer vers un répertoire de skills pendant le développement local.
+
+:::note[À propos de `.claude-plugin/`]
+Le chemin `.claude-plugin/marketplace.json` est une convention standard adoptée par plusieurs installateurs d’outils IA pour la découvabilité des plugins. Il ne nécessite pas Claude, n’utilise pas les API Claude et n’a aucun impact sur l’outil d’IA que vous utilisez. Tout module contenant ce fichier peut être découvert par tout installateur suivant cette convention.
+:::
+
+## Flux de travail en développement local
+
+Si vous construisez un module avec [BMad Builder](https://github.com/bmad-code-org/bmad-builder), vous pouvez l’installer directement depuis votre répertoire de travail :
+
+```bash
+npx bmad-method install \
+  --directory ~/my-project \
+  --custom-source ~/my-module-repo/skills \
+  --tools claude-code \
+  --yes
+```
+
+Les sources locales sont référencées par leur chemin, non copiées dans un cache. Lorsque vous mettez à jour la source de votre module et réinstallez, l’installateur récupère les dernières modifications.
+
+:::caution[Suppression de la source]
+Si vous supprimez le répertoire source local après l’installation, les fichiers du module installé dans `_bmad/` sont préservés. Le module sera ignoré lors des mises à jour tant que le chemin source n’est pas restauré.
+:::
+
+## Ce que vous obtenez
+
+Après l’installation, les modules personnalisés apparaissent dans `_bmad/` aux côtés des modules officiels :
+
+```
+your-project/
+├── _bmad/
+│   ├── core/              # Module cœur intégré
+│   ├── bmm/               # Module officiel (si sélectionné)
+│   ├── my-module/         # Votre module personnalisé
+│   │   ├── my-skill/
+│   │   │   └── SKILL.md
+│   │   └── module-help.csv
+│   └── _config/
+│       └── manifest.yaml  # Suit tous les modules, versions et sources
+└── ...
+```
+
+Le manifeste enregistre la source de chaque module personnalisé (`repoUrl` pour les sources Git, `localPath` pour les sources locales) afin que les mises à jour rapides puissent localiser la source à nouveau.
+
+## Mettre à jour les modules personnalisés
+
+Les modules personnalisés participent au flux de mise à jour normal :
+
+- **Mise à jour rapide** (`--action quick-update`) : Rafraîchit tous les modules depuis leurs sources d’origine. Les modules Git sont re-téléchargés ; les modules locaux sont relus depuis leur chemin source.
+- **Mise à jour complète** : Relance la sélection de modules pour que vous puissiez ajouter ou retirer des modules personnalisés.
+
+## Créer vos propres modules
+
+Utilisez [BMad Builder](https://github.com/bmad-code-org/bmad-builder) pour créer des modules que d’autres pourront installer :
+
+1. Exécutez `bmad-module-builder` pour générer la structure de votre module
+2. Ajoutez des skills, agents et workflows avec les divers outils BMad Builder
+3. Publiez dans un dépôt Git ou partagez le dossier
+4. D’autres installent avec `--custom-source <url-de-votre-dépôt>`
+
+Pour que les modules supportent le mode découverte, incluez un fichier `.claude-plugin/marketplace.json` à la racine de votre dépôt (c’est une convention multi-outils, pas spécifique à Claude). Consultez la [documentation BMad Builder](https://github.com/bmad-code-org/bmad-builder) pour le format du fichier `marketplace.json`.
+
+:::tip[Tester localement d’abord]
+Pendant le développement, installez votre module avec un chemin local pour itérer rapidement avant de publier dans un dépôt Git.
+:::

docs/fr/how-to/non-interactive-installation.md

@@ -1,165 +1,10 @@
 ---
 title: Installation non-interactive
-description: Installer BMad en utilisant des options de ligne de commande pour les pipelines CI/CD et les déploiements automatisés
+description: La documentation sur les installations headless / CI a été déplacée
 sidebar:
   order: 2
 ---
 
-Utilisez les options de ligne de commande pour installer BMad de manière non-interactive. Cela est utile pour :
-
-## Quand utiliser cette méthode
-
-- Déploiements automatisés et pipelines CI/CD
-- Installations scriptées
-- Installations par lots sur plusieurs projets
-- Installations rapides avec des configurations connues
-
-:::note[Prérequis]
-Nécessite [Node.js](https://nodejs.org) v20.12+ et `npx` (inclus avec npm).
-:::
-
-## Options disponibles
-
-### Options d'installation
-
-| Option | Description | Exemple |
-|------|-------------|---------|
-| `--directory <chemin>` | Répertoire d'installation | `--directory ~/projects/myapp` |
-| `--modules <modules>` | IDs de modules séparés par des virgules | `--modules bmm,bmb` |
-| `--tools <outils>` | IDs d'outils/IDE séparés par des virgules (utilisez `none` pour ignorer) | `--tools claude-code,cursor` ou `--tools none` |
-| `--action <type>` | Action pour les installations existantes : `install` (par défaut), `update`, ou `quick-update` | `--action quick-update` |
-
-### Configuration principale
-
-| Option | Description | Par défaut |
-|------|-------------|---------|
-| `--user-name <nom>` | Nom à utiliser par les agents | Nom d'utilisateur système |
-| `--communication-language <langue>` | Langue de communication des agents | Anglais |
-| `--document-output-language <langue>` | Langue de sortie des documents | Anglais |
-| `--output-folder <chemin>` | Chemin du dossier de sortie (voir les règles de résolution ci-dessous) | `_bmad-output` |
-
-#### Résolution du chemin du dossier de sortie
-
-La valeur passée à `--output-folder` (ou saisie de manière interactive) est résolue selon ces règles :
-
-| Type d'entrée                 | Exemple                    | Résolu comme                                                 |
-|-------------------------------|----------------------------|--------------------------------------------------------------|
-| Chemin relatif (par défaut)   | `_bmad-output`             | `<racine-du-projet>/_bmad-output`                            |
-| Chemin relatif avec traversée | `../../shared-outputs`     | Chemin absolu normalisé — ex. `/Users/me/shared-outputs`     |
-| Chemin absolu                 | `/Users/me/shared-outputs` | Utilisé tel quel — la racine du projet n'est **pas** ajoutée |
-
-Le chemin résolu est ce que les agents et les workflows vont utiliser lors de l'écriture des fichiers de sortie. L'utilisation d'un chemin absolu ou d'un chemin relatif avec traversée vous permet de diriger tous les artefacts générés vers un répertoire en dehors de l'arborescence de votre projet — utile pour les configurations partagées ou les monorepos.
-
-### Autres options
-
-| Option | Description |
-|------|-------------|
-| `-y, --yes` | Accepter tous les paramètres par défaut et ignorer les invites |
-| `-d, --debug` | Activer la sortie de débogage pour la génération du manifeste |
-
-## IDs de modules
-
-IDs de modules disponibles pour l’option `--modules` :
-
-- `bmm` — méthode BMad Master
-- `bmb` — BMad Builder
-
-Consultez le [registre BMad](https://github.com/bmad-code-org) pour les modules externes disponibles.
-
-## IDs d'outils/IDE
-
-IDs d'outils disponibles pour l’option `--tools` :
-
-**Recommandés :** `claude-code`, `cursor`
-
-Exécutez `npx bmad-method install` de manière interactive une fois pour voir la liste complète actuelle des outils pris en charge, ou consultez la [configuration des codes de la plateforme](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml).
-
-## Modes d'installation
-
-| Mode | Description | Exemple |
-|------|-------------|---------|
-| Entièrement non-interactif | Fournir toutes les options pour ignorer toutes les invites | `npx bmad-method install --directory . --modules bmm --tools claude-code --yes` |
-| Semi-interactif | Fournir certains options ; BMad demande les autres | `npx bmad-method install --directory . --modules bmm` |
-| Paramètres par défaut uniquement | Accepter tous les paramètres par défaut avec `-y` | `npx bmad-method install --yes` |
-| Sans outils | Ignorer la configuration des outils/IDE | `npx bmad-method install --modules bmm --tools none` |
-
-## Exemples
-
-### Installation dans un pipeline CI/CD
-
-```bash
-#!/bin/bash
-# install-bmad.sh
-
-npx bmad-method install \
-  --directory "${GITHUB_WORKSPACE}" \
-  --modules bmm \
-  --tools claude-code \
-  --user-name "CI Bot" \
-  --communication-language Français \
-  --document-output-language Français \
-  --output-folder _bmad-output \
-  --yes
-```
-
-### Mettre à jour une installation existante
-
-```bash
-npx bmad-method install \
-  --directory ~/projects/myapp \
-  --action update \
-  --modules bmm,bmb,custom-module
-```
-
-### Mise à jour rapide (conserver les paramètres)
-
-```bash
-npx bmad-method install \
-  --directory ~/projects/myapp \
-  --action quick-update
-```
-
-## Ce que vous obtenez
-
-- Un répertoire `_bmad/` entièrement configuré dans votre projet
-- Des agents et des flux de travail configurés pour vos modules et outils sélectionnés
-- Un dossier `_bmad-output/` pour les artefacts générés
-
-## Validation et gestion des erreurs
-
-BMad valide toutes les options fournis :
-
-- **Directory** — Doit être un chemin valide avec des permissions d'écriture
-- **Modules** — Avertit des IDs de modules invalides (mais n'échoue pas)
-- **Tools** — Avertit des IDs d'outils invalides (mais n'échoue pas)
-- **Action** — Doit être l'une des suivantes : `install`, `update`, `quick-update`
-
-Les valeurs invalides entraîneront soit :
-1. L’affichage d’un message d'erreur suivi d’un exit (pour les options critiques comme le répertoire)
-2. Un avertissement puis la continuation de l’installation (pour les éléments optionnels)
-3. Un retour aux invites interactives (pour les valeurs requises manquantes)
-
-:::tip[Bonnes pratiques]
-- Utilisez des chemins absolus pour `--directory` pour éviter toute ambiguïté
-- Utilisez un chemin absolu pour `--output-folder` lorsque vous souhaitez que les artefacts soient écrits en dehors de l'arborescence du projet (ex. un répertoire de sorties partagé dans un monorepo)
-- Testez les options localement avant de les utiliser dans des pipelines CI/CD
-- Combinez avec `-y` pour des installations vraiment sans surveillance
-- Utilisez `--debug` si vous rencontrez des problèmes lors de l'installation
-:::
-
-## Résolution des problèmes
-
-### L'installation échoue avec "Invalid directory"
-
-- Le chemin du répertoire doit exister (ou son parent doit exister)
-- Vous avez besoin des permissions d'écriture
-- Le chemin doit être absolu ou correctement relatif au répertoire actuel
-
-### Module non trouvé
-
-- Vérifiez que l'ID du module est correct
-- Les modules externes doivent être disponibles dans le registre
-
-:::note[Toujours bloqué ?]
-Exécutez avec `--debug` pour une sortie détaillée, essayez le mode interactif pour isoler le problème, ou signalez-le à <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
+:::note[Cette page a été déplacée]
+Les flags d’installation headless et CI, la sélection de canal et l’épinglage de version se trouvent désormais dans le guide unifié [Comment installer BMad](./install-bmad.md). Consultez la section [Installations CI non interactives](./install-bmad.md#installations-ci-non-interactives) pour la référence des flags et les exemples prêts à copier-coller.
 :::

docs/fr/how-to/project-context.md

@@ -2,10 +2,10 @@
 title: "Gérer le contexte du projet"
 description: Créer et maintenir project-context.md pour guider les agents IA
 sidebar:
-  order: 8
+  order: 9
 ---
 
-Utilisez le fichier `project-context.md` pour garantir que les agents IA respectent les préférences techniques et les règles d'implémentation de votre projet tout au long des workflows. Pour vous assurer qu'il est toujours disponible, vous pouvez également ajouter la ligne `Le contexte et les conventions importantes du projet se trouvent dans [chemin vers le contexte du projet]/project-context.md` à votre fichier de contexte ou de règles permanentes (comme `AGENTS.md`).
+Utilisez le fichier `project-context.md` pour garantir que les agents IA respectent les préférences techniques et les règles d’implémentation de votre projet tout au long des workflows. Pour vous assurer qu’il est toujours disponible, vous pouvez également ajouter la ligne `Le contexte et les conventions importantes du projet se trouvent dans [chemin vers le contexte du projet]/project-context.md` à votre fichier de contexte ou de règles permanentes (comme `AGENTS.md`).
 
 :::note[Prérequis]
 - Méthode BMad installée
@@ -14,31 +14,31 @@ Utilisez le fichier `project-context.md` pour garantir que les agents IA respect
 
 ## Quand utiliser cette fonctionnalité
 
-- Vous avez des préférences techniques fortes avant de commencer l'architecture
-- Vous avez terminé l'architecture et souhaitez consigner les décisions pour l'implémentation
+- Vous avez des préférences techniques fortes avant de commencer l’architecture
+- Vous avez terminé l’architecture et souhaitez consigner les décisions pour l’implémentation
 - Vous travaillez sur une base de code existante avec des patterns établis
 - Vous remarquez que les agents prennent des décisions incohérentes entre les stories
 
-## Étape 1 : Choisissez votre approche
+## Étape 1 : Choisissez votre approche
 
 **Création manuelle** — Idéal lorsque vous savez exactement quelles règles vous souhaitez documenter
 
-**Génération après l'architecture** — Idéal pour capturer les décisions prises lors du solutioning
+**Génération après l’architecture** — Idéal pour capturer les décisions prises lors du solutioning
 
 **Génération pour les projets existants** — Idéal pour découvrir les patterns dans les bases de code existantes
 
-## Étape 2 : Créez le fichier
+## Étape 2 : Créez le fichier
 
-### Option A : Création manuelle
+### Option A : Création manuelle
 
-Créez le fichier à l'emplacement `_bmad-output/project-context.md` :
+Créez le fichier à l’emplacement `_bmad-output/project-context.md` :
 
 ```bash
 mkdir -p _bmad-output
 touch _bmad-output/project-context.md
 ```
 
-Ajoutez votre pile technologique et vos règles d'implémentation :
+Ajoutez votre pile technologique et vos règles d’implémentation :
 
 ```markdown
 ---
@@ -72,7 +72,7 @@ sections_completed: ['technology_stack', 'critical_rules']
 - Tests d'intégration utilisent MSW pour le mock API
 ```
 
-### Option B : Génération après l'architecture
+### Option B : Génération après l’architecture
 
 Exécutez le workflow dans une nouvelle conversation :
 
@@ -80,9 +80,9 @@ Exécutez le workflow dans une nouvelle conversation :
 bmad-generate-project-context
 ```
 
-Le workflow analyse votre document d'architecture et vos fichiers projet pour générer un fichier de contexte qui capture les décisions prises.
+Le workflow analyse votre document d’architecture et vos fichiers projet pour générer un fichier de contexte qui capture les décisions prises.
 
-### Option C : Génération pour les projets existants
+### Option C : Génération pour les projets existants
 
 Pour les projets existants, exécutez :
 
@@ -92,9 +92,9 @@ bmad-generate-project-context
 
 Le workflow analyse votre base de code pour identifier les conventions, puis génère un fichier de contexte que vous pouvez réviser et affiner.
 
-## Étape 3 : Vérifiez le contenu
+## Étape 3 : Vérifiez le contenu
 
-Révisez le fichier généré et assurez-vous qu'il capture :
+Révisez le fichier généré et assurez-vous qu’il capture :
 
 - Les versions correctes des technologies
 - Vos conventions réelles (pas les bonnes pratiques génériques)
@@ -109,15 +109,15 @@ Un fichier `project-context.md` qui :
 
 - Garantit que tous les agents suivent les mêmes conventions
 - Évite les décisions incohérentes entre les stories
-- Capture les décisions d'architecture pour l'implémentation
+- Capture les décisions d’architecture pour l’implémentation
 - Sert de référence pour les patterns et règles de votre projet
 
 ## Conseils
 
 :::tip[Bonnes pratiques]
-- **Concentrez-vous sur ce qui n'est pas évident** — Documentez les patterns que les agents pourraient manquer (par ex. « Utiliser JSDoc sur chaque classe publique »), et non les pratiques universelles comme « utiliser des noms de variables significatifs ».
-- **Gardez-le concis** — Ce fichier est chargé par chaque workflow d'implémentation. Les fichiers longs gaspillent le contexte. Excluez le contenu qui ne s'applique qu'à un périmètre restreint ou à des stories spécifiques.
-- **Mettez à jour si nécessaire** — Modifiez manuellement lorsque les patterns changent, ou régénérez après des changements d'architecture significatifs.
+- **Concentrez-vous sur ce qui n’est pas évident** — Documentez les patterns que les agents pourraient manquer (par ex. « Utiliser JSDoc sur chaque classe publique »), et non les pratiques universelles comme « utiliser des noms de variables significatifs ».
+- **Gardez-le concis** — Ce fichier est chargé par chaque workflow d’implémentation. Les fichiers longs gaspillent le contexte. Excluez le contenu qui ne s’applique qu’à un périmètre restreint ou à des stories spécifiques.
+- **Mettez à jour si nécessaire** — Modifiez manuellement lorsque les patterns changent, ou régénérez après des changements d’architecture significatifs.
 - Fonctionne aussi bien pour Quick Dev que pour les projets complets méthode BMad.
 :::
 

docs/fr/how-to/quick-fixes.md

@@ -2,7 +2,7 @@
 title: "Corrections Rapides"
 description: Comment effectuer des corrections rapides et des modifications ciblées
 sidebar:
-  order: 5
+  order: 6
 ---
 
 Utilisez **Quick Dev** pour les corrections de bugs, les refactorisations ou les petites modifications ciblées qui ne nécessitent pas la méthode BMad complète.
@@ -23,11 +23,11 @@ Utilisez **Quick Dev** pour les corrections de bugs, les refactorisations ou les
 
 ### 1. Démarrer une Nouvelle Conversation
 
-Ouvrez une **nouvelle conversation** dans votre IDE IA. Réutiliser une session d'un workflow précédent peut causer des conflits de contexte.
+Ouvrez une **nouvelle conversation** dans votre IDE IA. Réutiliser une session d’un workflow précédent peut causer des conflits de contexte.
 
 ### 2. Spécifiez Votre Intention
 
-Quick Dev accepte l'intention en forme libre — avant, avec, ou après l'invocation. Exemples :
+Quick Dev accepte l’intention en forme libre — avant, avec, ou après l’invocation. Exemples :
 
 ```text
 quick-dev — Corrige le bug de validation de connexion qui permet les mots de passe vides.
@@ -52,18 +52,18 @@ quick-dev
 Refactoriser UserService pour utiliser async/await au lieu des callbacks.
 ```
 
-Texte brut, chemins de fichiers, URLs d'issues GitHub, liens de trackers de bugs — tout ce que le LLM peut résoudre en une intention concrète.
+Texte brut, chemins de fichiers, URLs d’issues GitHub, liens de trackers de bugs — tout ce que le LLM peut résoudre en une intention concrète.
 
 ### 3. Répondre aux Questions et Approuver
 
-Quick Dev peut poser des questions de clarification ou présenter une courte spécification demandant votre approbation avant l'implémentation. Répondez à ses questions et approuvez lorsque vous êtes satisfait du plan.
+Quick Dev peut poser des questions de clarification ou présenter une courte spécification demandant votre approbation avant l’implémentation. Répondez à ses questions et approuvez lorsque vous êtes satisfait du plan.
 
 ### 4. Réviser et Pousser
 
-Quick Dev implémente la modification, révise son propre travail, corrige les problèmes et effectue un commit local. Lorsqu'il a terminé, il ouvre les fichiers affectés dans votre éditeur.
+Quick Dev implémente la modification, révise son propre travail, corrige les problèmes et effectue un commit local. Lorsqu’il a terminé, il ouvre les fichiers affectés dans votre éditeur.
 
 - Parcourez le diff pour confirmer que la modification correspond à votre intention
-- Si quelque chose semble incorrect, dites à l'agent ce qu'il faut corriger — il peut itérer dans la même session
+- Si quelque chose semble incorrect, dites à l’agent ce qu’il faut corriger — il peut itérer dans la même session
 
 Une fois satisfait, poussez le commit. Quick Dev vous proposera de pousser et de créer une PR pour vous.
 
@@ -79,20 +79,20 @@ Si une modification poussée cause des problèmes inattendus, utilisez `git reve
 
 ## Travail Différé
 
-Quick Dev garde chaque exécution concentrée sur un seul objectif. Si votre demande contient plusieurs objectifs indépendants, ou si la revue remonte des problèmes préexistants non liés à votre modification, Quick Dev les diffère vers un fichier (`deferred-work.md` dans votre répertoire d'artefacts d'implémentation) plutôt que d'essayer de tout régler en même temps.
+Quick Dev garde chaque exécution concentrée sur un seul objectif. Si votre demande contient plusieurs objectifs indépendants, ou si la revue remonte des problèmes préexistants non liés à votre modification, Quick Dev les diffère vers un fichier (`deferred-work.md` dans votre répertoire d’artefacts d’implémentation) plutôt que d’essayer de tout régler en même temps.
 
-Consultez ce fichier après une exécution — c'est votre backlog[^1] de choses sur lesquelles revenir. Chaque élément différé peut être introduit dans une nouvelle exécution Quick Dev ultérieurement.
+Consultez ce fichier après une exécution — c’est votre backlog[^1] de choses sur lesquelles revenir. Chaque élément différé peut être introduit dans une nouvelle exécution Quick Dev ultérieurement.
 
 ## Quand Passer à une Planification Formelle
 
-Envisagez d'utiliser la méthode BMad complète lorsque :
+Envisagez d’utiliser la méthode BMad complète lorsque :
 
 - La modification affecte plusieurs systèmes ou nécessite des mises à jour coordonnées dans de nombreux fichiers
-- Vous n'êtes pas sûr de la portée et avez besoin d'une découverte des exigences d'abord
-- Vous avez besoin de documentation ou de décisions architecturales enregistrées pour l'équipe
+- Vous n’êtes pas sûr de la portée et avez besoin d’une découverte des exigences d’abord
+- Vous avez besoin de documentation ou de décisions architecturales enregistrées pour l’équipe
 
-Voir [Quick Dev](../explanation/quick-dev.md) pour plus d'informations sur la façon dont Quick Dev s'intègre dans la méthode BMad.
+Voir [Quick Dev](../explanation/quick-dev.md) pour plus d’informations sur la façon dont Quick Dev s’intègre dans la méthode BMad.
 
 ## Glossaire
 
-[^1]: Backlog : liste priorisée de tâches ou d'éléments de travail à traiter ultérieurement, issue des méthodologies agiles.
+[^1]: Backlog : liste priorisée de tâches ou d’éléments de travail à traiter ultérieurement, issue des méthodologies agiles.

docs/fr/how-to/shard-large-documents.md

@@ -2,20 +2,20 @@
 title: "Guide de Division de Documents"
 description: Diviser les fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte
 sidebar:
-  order: 9
+  order: 10
 ---
 
-Utilisez l'outil `bmad-shard-doc` si vous avez besoin de diviser des fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte.
+Utilisez l’outil `bmad-shard-doc` si vous avez besoin de diviser des fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte.
 
 :::caution[Déprécié]
-Ceci n'est plus recommandé, et bientôt avec les workflows mis à jour et la plupart des LLM et outils majeurs supportant les sous-processus, cela deviendra inutile.
+Ceci n’est plus recommandé, et bientôt avec les workflows mis à jour et la plupart des LLM et outils majeurs supportant les sous-processus, cela deviendra inutile.
 :::
 
 ## Quand l’Utiliser
 
-Utilisez ceci uniquement si vous remarquez que votre combinaison outil / modèle ne parvient pas à charger et lire tous les documents en entrée lorsque c'est nécessaire.
+Utilisez ceci uniquement si vous remarquez que votre combinaison outil / modèle ne parvient pas à charger et lire tous les documents en entrée lorsque c’est nécessaire.
 
-## Qu'est-ce que la Division de Documents ?
+## Qu’est-ce que la Division de Documents ?
 
 La division de documents divise les fichiers markdown volumineux en fichiers plus petits et organisés basés sur les titres de niveau 2 (`## Titre`).
 
@@ -38,7 +38,7 @@ _bmad-output/planning-artifacts/
 
 ## Étapes
 
-### 1. Exécuter l'Outil Shard-Doc
+### 1. Exécuter l’Outil Shard-Doc
 
 ```bash
 /bmad-shard-doc
@@ -64,7 +64,7 @@ Agent : Division de PRD.md...
 
 Les workflows BMad utilisent un **système de découverte double** :
 
-1. **Essaye d'abord le document entier** - Rechercher `document-name.md`
+1. **Essaye d’abord le document entier** - Rechercher `document-name.md`
 2. **Vérifie la version divisée** - Rechercher `document-name/index.md`
 3. **Règle de priorité** - Le document entier a la priorité si les deux existent - supprimez le document entier si vous souhaitez que la version divisée soit utilisée à la place
 
@@ -75,4 +75,4 @@ Tous les workflows BMM prennent en charge les deux formats :
 - Documents entiers
 - Documents divisés
 - Détection automatique
-- Transparent pour l'utilisateur
+- Transparent pour l’utilisateur

docs/fr/how-to/upgrade-to-v6.md

@@ -2,10 +2,10 @@
 title: "Comment passer à la v6"
 description: Migrer de BMad v4 vers v6
 sidebar:
-  order: 3
+  order: 4
 ---
 
-Utilisez l'installateur BMad pour passer de la v4 à la v6, qui inclut une détection automatique des installations existantes et une assistance à la migration.
+Utilisez l’installateur BMad pour passer de la v4 à la v6, qui inclut une détection automatique des installations existantes et une assistance à la migration.
 
 ## Quand utiliser ce guide
 
@@ -20,22 +20,22 @@ Utilisez l'installateur BMad pour passer de la v4 à la v6, qui inclut une déte
 
 ## Étapes
 
-### 1. Lancer l'installateur
+### 1. Lancer l’installateur
 
-Suivez les [Instructions d'installation](./install-bmad.md).
+Suivez les [Instructions d’installation](./install-bmad.md).
 
-### 2. Gérer l'installation existante
+### 2. Gérer l’installation existante
 
 Quand v4 est détecté, vous pouvez :
 
-- Autoriser l'installateur à sauvegarder et supprimer `.bmad-method`
+- Autoriser l’installateur à sauvegarder et supprimer `.bmad-method`
 - Quitter et gérer le nettoyage manuellement
 
-Si vous avez nommé votre dossier de méthode bmad autrement, vous devrez supprimer le dossier vous-même manuellement.
+Si votre dossier de méthode BMad porte un nom différent, vous devrez le supprimer manuellement.
 
 ### 3. Nettoyer les skills IDE
 
-Supprimez manuellement les commandes/skills IDE v4 existants - par exemple si vous avez Claude Code, recherchez tous les dossiers imbriqués qui commencent par bmad et supprimez-les :
+Supprimez manuellement les commandes/skills IDE v4 existants - par exemple si vous utilisez Claude Code, recherchez tous les dossiers imbriqués qui commencent par bmad et supprimez-les :
 
 - `.claude/commands/`
 
@@ -45,28 +45,28 @@ Les nouveaux skills v6 sont installés dans :
 
 ### 4. Migrer les artefacts de planification
 
-**Si vous avez des documents de planification (Brief/PRD/UX/Architecture) :**
+**Si vous avez des documents de planification (Brief/PRD/UX/Architecture) :**
 
 Déplacez-les dans `_bmad-output/planning-artifacts/` avec des noms descriptifs :
 
 - Incluez `PRD` dans le nom de fichier pour les documents PRD[^1]
 - Incluez `brief`, `architecture`, ou `ux-design` selon le cas
-- Les documents divisés peuvent être dans des sous-dossiers nommés
+- Les documents divisés peuvent être dans des sous-dossiers au nom descriptif
 
-**Si vous êtes en cours de planification :** Envisagez de redémarrer avec les workflows v6. Utilisez vos documents existants comme entrées - les nouveaux workflows de découverte progressive avec recherche web et mode plan IDE produisent de meilleurs résultats.
+**Si vous êtes en cours de planification :** Envisagez de recommencer avec les workflows v6. Utilisez vos documents existants comme entrées — les nouveaux workflows de découverte progressive avec recherche web et le mode plan de l’IDE produisent de meilleurs résultats.
 
 ### 5. Migrer le développement en cours
 
 Si vous avez des stories[^3] créées ou implémentées :
 
-1. Terminez l'installation v6
+1. Terminez l’installation v6
 2. Placez `epics.md` ou `epics/epic*.md`[^2] dans `_bmad-output/planning-artifacts/`
 3. Lancez le workflow Développeur `bmad-sprint-planning`[^4]
 4. Indiquez à l’agent quels epics/stories sont déjà terminés
 
-## Ce que vous obtenez
+## Résultat de la migration
 
-**Structure unifiée v6 :**
+**Structure unifiée v6 :**
 
 ```text
 votre-projet/
@@ -77,30 +77,31 @@ votre-projet/
 │   ├── bmm/             # Module BMad Method
 │   ├── bmb/             # BMad Builder
 │   └── cis/             # Creative Intelligence Suite
-└── _bmad-output/        # Dossier de sortie (était le dossier doc en v4)
+└── _bmad-output/        # Dossier de sortie (remplace le dossier doc de la v4)
 ```
 
 ## Migration des modules
 
-| Module v4                     | Statut v6                                 |
-| ----------------------------- | ----------------------------------------- |
-| `.bmad-2d-phaser-game-dev`    | Intégré dans le Module BMGD               |
-| `.bmad-2d-unity-game-dev`     | Intégré dans le Module BMGD               |
-| `.bmad-godot-game-dev`        | Intégré dans le Module BMGD               |
-| `.bmad-infrastructure-devops` | Déprécié - nouvel agent DevOps bientôt disponible |
-| `.bmad-creative-writing`      | Non adapté - nouveau module v6 bientôt disponible   |
+| Module v4                     | Statut v6                                         |
+|-------------------------------|---------------------------------------------------|
+| `.bmad-2d-phaser-game-dev`    | Intégré dans le Module BMGD                       |
+| `.bmad-2d-unity-game-dev`     | Intégré dans le Module BMGD                       |
+| `.bmad-godot-game-dev`        | Intégré dans le Module BMGD                       |
+| `.bmad-infrastructure-devops` | Obsolète — nouvel agent DevOps bientôt disponible |
+| `.bmad-creative-writing`      | Non migré — nouveau module v6 bientôt disponible  |
 
 ## Changements clés
 
-| Concept       | v4                                    | v6                                   |
-| ------------- | ------------------------------------- | ------------------------------------ |
-| **Core**      | `_bmad-core` était en fait la méthode BMad | `_bmad/core/` est le framework universel |
-| **Method**    | `_bmad-method`                        | `_bmad/bmm/`                         |
-| **Config**    | Fichiers modifiés directement         | `config.yaml` par module             |
-| **Documents** | Division ou non division requise | Entièrement flexible, scan automatique         |
+| Concept       | v4                                                      | v6                                       |
+|---------------|---------------------------------------------------------|------------------------------------------|
+| **Core**      | `_bmad-core` correspondait en réalité à la méthode BMad | `_bmad/core/` est le framework universel |
+| **Method**    | `_bmad-method`                                          | `_bmad/bmm/`                             |
+| **Config**    | Fichiers modifiés directement                           | `config.yaml` par module                 |
+| **Documents** | Division en fragments obligatoire ou optionnelle        | Totalement flexible, analyse automatique |
+
 
 ## Glossaire
-[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
+[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
 [^2]: Epic : dans les méthodologies agiles, une grande unité de travail qui peut être décomposée en plusieurs stories. Un epic représente généralement une fonctionnalité majeure ou un ensemble de capacités livrable sur plusieurs sprints.
-[^3]: Story (User Story) : une description courte et simple d'une fonctionnalité du point de vue de l'utilisateur. Les stories sont des unités de travail suffisamment petites pour être complétées en un sprint.
-[^4]: Sprint : dans Scrum, une période de temps fixe (généralement 1 à 4 semaines) pendant laquelle l'équipe travaille à livrer un incrément de produit potentiellement libérable.
+[^3]: Story (User Story) : une description courte et simple d’une fonctionnalité du point de vue de l’utilisateur. Les stories sont des unités de travail suffisamment petites pour être complétées en un sprint.
+[^4]: Sprint : dans Scrum, une période de temps fixe (généralement 1 à 4 semaines) pendant laquelle l’équipe travaille à livrer un incrément de produit potentiellement libérable.

docs/fr/how-to/use-web-bundles.md

@@ -0,0 +1,41 @@
+---
+title: 'Utiliser les Web Bundles'
+description: Installer un web bundle BMad comme Google Gemini Gem ou ChatGPT Custom GPT
+---
+
+Les web bundles s’installent depuis **[bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**.
+
+## Pourquoi une seule porte d’entrée
+
+Le site est le seul chemin d’installation pris en charge pour la bibliothèque. Il maintient les étapes à jour au fil de l’évolution de Gemini et ChatGPT, pointe toujours vers la dernière version taguée, et une seule inscription suffit pour être notifié des nouveaux bundles dès leur parution.
+
+## Ce que vous ferez sur le site
+
+1. Choisissez un bundle dans la grille de cartes.
+2. Ouvrez la modale d’installation. Basculez entre les onglets **Gemini Gem** et **ChatGPT GPT** pour les étapes spécifiques à chaque plateforme.
+3. Téléchargez le ZIP du bundle (un clic ; inscription gratuite en une étape pour les membres email uniquement).
+4. Suivez les étapes indiquées sur la page : créez le Gem ou le Custom GPT, téléversez les fichiers de connaissance, collez le bloc d’instructions, sauvegardez.
+
+## Prérequis
+
+- **Pour les Gemini Gems** : abonnement Gemini Advanced.
+- **Pour les ChatGPT Custom GPTs** : plan Plus, Pro, Business ou Enterprise.
+- Pour les bundles qui utilisent **Deep Research** (actuellement Étude de marché et analyse sectorielle), activez-le depuis la barre de prompt (Outils → Deep Research). Deep Research a ses propres limites de plan.
+
+## Personnaliser le persona
+
+Le fichier `INSTRUCTIONS.md` de chaque bundle (dans le ZIP) inclut un **exemple de substitution de persona** au-dessus du séparateur de la zone à coller. Remplacez le bloc `[persona]` dans vos instructions installées par l’exemple de substitution pour changer le persona sans modifier le protocole. Vous pouvez aussi créer votre propre persona de zéro ; le protocole reste le même.
+
+## Ce que vous obtenez
+
+- Un Gem ou Custom GPT réutilisable dédié à une capacité de planification BMad.
+- Des artefacts finalisés (briefs, PRD, rapports de recherche, spécifications UX) prêts à déposer dans votre IDE pour l’implémentation.
+- Les conversations de planification se déroulent sur votre abonnement LLM web existant au lieu de consommer des tokens IDE facturés.
+
+:::caution[Dérive du persona]
+Les LLM web abandonnent parfois le persona au cours de longues sessions. Si le modèle commence à parler hors personnage, rappelez-lui son persona ou démarrez une nouvelle session.
+:::
+
+## Créer le vôtre
+
+Pour transformer un skill BMad existant en web bundle, utilisez le skill utilitaire `bmad-os-skill-to-bundle` disponible sur [bmad-utility-skills](https://github.com/bmad-code-org/bmad-utility-skills). Il produit les fichiers du bundle en reprenant le persona hérité de l’agent d’origine et un exemple de persona alternatif. Soumettez votre bundle à la bibliothèque en ouvrant une PR sur [BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) qui ajoute le répertoire du bundle et une entrée dans `web-bundles/bundles.json`.

docs/fr/index.md

@@ -1,63 +1,63 @@
 ---
 title: Bienvenue dans la méthode BMad
-description: Framework de développement propulsé par l'IA avec des agents spécialisés, des workflows guidés et une planification intelligente
+description: Framework de développement alimenté par l’IA avec des agents spécialisés, des workflows guidés et une planification intelligente
 ---
 
-La méthode BMad (**B**uild **M**ore **A**rchitect **D**reams) est un module[^1] de développement assisté par l'IA au sein de l'écosystème BMad, conçu pour vous faciliter la création de logiciels par un processus complet, de l'idéation et de la planification jusqu'à l'implémentation agentique. Elle fournit des agents[^2] IA spécialisés, des workflows guidés et une planification intelligente qui s'adapte à la complexité de votre projet, que vous corrigiez un bug ou construisiez une plateforme d'entreprise.
+La méthode BMad (**B**uild **M**ore **A**rchitect **D**reams) est un module[^1] de développement assisté par l’IA au sein de l’écosystème BMad. Elle couvre l’intégralité du processus de création logicielle — de l’idéation et de la planification jusqu’à la mise en œuvre par des agents. BMad met à votre disposition des agents IA spécialisés[^2], des workflows guidés et une planification intelligente qui s’adapte à la complexité de votre projet, qu’il s’agisse de corriger un bug ou de bâtir une plateforme d’entreprise.
 
-Si vous êtes à l'aise avec les assistants de codage IA comme Claude, Cursor ou GitHub Copilot, vous êtes prêt à commencer.
+Si vous êtes à l’aise avec les assistants de codage IA comme Claude, Cursor ou GitHub Copilot, vous êtes prêt à commencer.
 
-:::note[🚀 La V6 est là et ce n'est que le début !]
-Architecture par Skills, BMad Builder v1, automatisation Dev Loop, et bien plus encore en préparation. **[Consultez la Feuille de route →](./roadmap)**
+:::note[🚀 La V6 est là et ce n’est que le début !]
+Architecture de Skills, BMad Builder v1, automatisation Dev Loop, et bien plus encore à venir. **[Consultez la Feuille de route →](./roadmap)**
 :::
 
-## Première visite ? Commencez par un tutoriel
+## Vous découvrez BMad ? Commencez par un tutoriel
 
-La façon la plus rapide de comprendre BMad est de l'essayer.
+La façon la plus rapide de comprendre BMad est de l’essayer.
 
-- **[Premiers pas avec BMad](./tutorials/getting-started.md)** — Installez et comprenez comment fonctionne BMad
-- **[Carte des workflows](./reference/workflow-map.md)** — Vue d'ensemble visuelle des phases BMM, des workflows et de la gestion du contexte
+- **[Premiers pas avec BMad](./tutorials/getting-started.md)** — Installez BMad et découvrez son fonctionnement
+- **[Carte des workflows](./reference/workflow-map.md)** — Vue d’ensemble visuelle des phases BMM, des workflows et de la gestion du contexte
 
-:::tip[Envie de plonger directement ?]
-Installez BMad et utilisez le skill[^3] `bmad-help` — il vous guidera entièrement en fonction de votre projet et de vos modules installés.
+:::tip[Envie de passer à la pratique ?]
+Installez BMad et utilisez le skill[^3] `bmad-help` — il vous guidera pas à pas, en fonction de votre projet et des modules installés.
 :::
 
 ## Comment utiliser cette documentation
 
-Cette documentation est organisée en quatre sections selon ce que vous essayez de faire :
+Cette documentation est organisée en quatre sections, selon votre objectif :
 
-| Section           | Objectif                                                                                                    |
-| ----------------- | ----------------------------------------------------------------------------------------------------------- |
-| **Tutoriels**     | Orientés apprentissage. Guides étape par étape qui vous accompagnent dans la construction de quelque chose. Commencez ici si vous êtes nouveau. |
-| **Guides pratiques** | Orientés tâches. Guides pratiques pour résoudre des problèmes spécifiques. « Comment personnaliser un agent ? » se trouve ici.  |
-| **Explication**   | Orientés compréhension. Explications en profondeur des concepts et de l'architecture. À lire quand vous voulez savoir *pourquoi*.       |
-| **Référence**     | Orientés information. Spécifications techniques pour les agents, workflows et configuration.                   |
+| Section              | Objectif                                                                                                                                     |
+|----------------------|----------------------------------------------------------------------------------------------------------------------------------------------|
+| **Tutoriels**        | Orientés apprentissage. Guides pas à pas pour vous accompagner dans la réalisation d’un projet. Le point de départ idéal si vous débutez.    |
+| **Guides pratiques** | Orientés tâches. Guides concrets pour résoudre des problèmes spécifiques. Vous y trouverez par exemple « Comment personnaliser un agent ? ». |
+| **Explications**     | Orientés compréhension. Plongées dans les concepts et l’architecture. À consulter pour comprendre le *pourquoi*.                             |
+| **Référence**        | Orientés information. Spécifications techniques des agents, workflows et configuration.                                                      |
 
 ## Étendre et personnaliser
 
-Vous souhaitez étendre BMad avec vos propres agents, workflows ou modules ? Le **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** fournit le framework et les outils pour créer des extensions personnalisées, que vous ajoutiez de nouvelles capacités à BMad ou que vous construisiez des modules entièrement nouveaux à partir de zéro.
+Vous souhaitez étendre BMad avec vos propres agents, workflows ou modules ? Le **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** met à votre disposition le framework et les outils nécessaires pour créer des extensions personnalisées — que ce soit pour ajouter de nouvelles capacités à BMad ou pour concevoir des modules entièrement nouveaux de zéro.
 
 ## Ce dont vous aurez besoin
 
-BMad fonctionne avec tout assistant de codage IA qui prend en charge les prompts système personnalisés ou le contexte de projet. Les options populaires incluent :
+BMad fonctionne avec tout assistant de codage IA qui prend en charge les prompts système personnalisés ou le contexte de projet. Parmi les options les plus populaires :
 
-- **[Claude Code](https://code.claude.com)** — Outil CLI d'Anthropic (recommandé)
-- **[Cursor](https://cursor.sh)** — Éditeur de code propulsé par l'IA
-- **[Codex CLI](https://github.com/openai/codex)** — Agent de codage terminal d'OpenAI
+- **[Claude Code](https://code.claude.com)** — Outil CLI d’Anthropic (recommandé)
+- **[Cursor](https://cursor.sh)** — Éditeur de code propulsé par l’IA
+- **[Codex CLI](https://github.com/openai/codex)** — Agent de codage en ligne de commande d’OpenAI
 
-Vous devriez être à l'aise avec les concepts de base du développement logiciel comme le contrôle de version, la structure de projet et les workflows agiles. Aucune expérience préalable avec les systèmes d'agent de type BMad n'est requise — c'est justement le but de cette documentation.
+Vous devriez être à l’aise avec les concepts de base du développement logiciel : gestion de versions, structure de projet et méthodologies agiles. Aucune expérience préalable des systèmes d’agents de type BMad n’est requise — c’est précisément l’objet de cette documentation.
 
 ## Rejoindre la communauté
 
-Obtenez de l'aide, partagez ce que vous construisez ou contribuez à BMad :
+Trouvez de l’aide, partagez vos projets ou contribuez à BMad :
 
-- **[Discord](https://discord.gg/gk8jAdXWmj)** — Discutez avec d'autres utilisateurs de BMad, posez des questions, partagez des idées
-- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Code source, issues et contributions
+- **[Discord](https://discord.gg/gk8jAdXWmj)** — Discutez avec d’autres utilisateurs de BMad, posez des questions, partagez des idées
+- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Code source, tickets et contributions
 - **[YouTube](https://www.youtube.com/@BMadCode)** — Tutoriels vidéo et démonstrations
 
 ## Prochaine étape
 
-Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)** et construisez votre premier projet.
+Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)** et réalisez votre premier projet.
 
 ---
 ## Glossaire
@@ -66,4 +66,4 @@ Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)**
 
 [^2]: **Agent** : assistant IA spécialisé avec une expertise spécifique qui guide les utilisateurs dans les workflows.
 
-[^3]: **Skill** : capacité ou fonctionnalité invoquable d'un agent pour effectuer une tâche spécifique.
+[^3]: **Skill** : capacité ou fonctionnalité invoquable d’un agent pour effectuer une tâche spécifique.

docs/fr/reference/agents.md

@@ -11,42 +11,41 @@ Cette page liste les agents BMM (suite Agile) par défaut installés avec la mé
 
 ## Notes
 
-- Chaque agent est disponible en tant que skill, généré par l’installateur. L’identifiant de skill (par exemple, `bmad-dev`) est utilisé pour invoquer l’agent.
-- Les déclencheurs sont les codes courts de menu (par exemple, `BP`) et les correspondances approximatives affichés dans chaque menu d’agent.
-- La génération de tests QA est gérée par le skill de workflow `bmad-qa-generate-e2e-tests`, disponible par l’agent Développeur. L’architecte de tests complet (TEA) se trouve dans son propre module.
+- Chaque agent est disponible en tant que skill, généré par l’installateur. L’identifiant de skill (par exemple, `bmad-agent-dev`) est utilisé pour invoquer l’agent.
+- Les déclencheurs sont les codes courts affichés dans le menu de chaque agent (par exemple, `PRD`) et les correspondances approximatives présentées dans chaque menu.
+- La génération de tests QA est gérée par le skill de workflow `bmad-qa-generate-e2e-tests`, disponible via l’agent Développeur. L’architecte de tests complet (TEA) se trouve dans son propre module.
 
-| Agent                       | Identifiant de skill | Déclencheurs                             | Workflows principaux                                                                                                                                           |
-|-----------------------------|----------------------|------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Analyste (Mary)             | `bmad-analyst`       | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorming du projet, Recherche marché/domaine/technique, Création du brief[^1], Défi PRFAQ, Documentation du projet                                        |
-| Product Manager (John)      | `bmad-pm`            | `CP`, `VP`, `EP`, `CE`, `IR`, `CC`       | Créer/Valider/Éditer un PRD, Créer des Epics et Stories, vérifier l’état de préparation à l’Implémentation, Corriger le Cours                                 |
-| Architecte (Winston)        | `bmad-architect`     | `CA`, `IR`                               | Créer l’architecture, Préparation à l’implémentation                                                                                                           |
-| Développeur (Amelia)        | `bmad-agent-dev`     | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | Dev Story, Quick Dev, Génération de Tests QA, Code Review, Sprint Planning, Créer Story, Rétrospective d’Epic                                                  |
-| Designer UX (Sally)         | `bmad-ux-designer`   | `CU`                                     | Création du design UX[^2]                                                                                                                                      |
-| Rédacteur Technique (Paige) | `bmad-tech-writer`   | `DP`, `WD`, `US`, `MG`, `VD`, `EC`       | Documentation du projet, Rédaction de documents, Mise à jour des standards, Génération de diagrammes Mermaid, Validation de documents, Explication de concepts |
+| Agent                       | Identifiant de skill     | Déclencheurs                                   | Workflows principaux                                                                                                                                                       |
+|-----------------------------|--------------------------|------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Analyste (Mary)             | `bmad-agent-analyst`     | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP`       | Brainstorming, Recherche marché, Recherche domaine, Recherche technique, Création du brief[^1], Défi PRFAQ, Documentation du projet                                        |
+| Product Manager (John)      | `bmad-agent-pm`          | `PRD`, `CE`, `IR`, `CC`                        | Créer, mettre à jour ou valider un PRD, Créer des Epics et Stories, vérifier l’état de préparation à l’Implémentation, Corriger le Cours                                   |
+| Architecte (Winston)        | `bmad-agent-architect`   | `CA`, `IR`                                     | Créer l’architecture, Préparation à l’implémentation                                                                                                                       |
+| Développeur (Amelia)        | `bmad-agent-dev`         | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER`, `IN` | Dev Story, Quick Dev, Génération de Tests QA, Code Review, Sprint Planning, Créer Story, Rétrospective d’Epic, [Enquête de code](../explanation/forensic-investigation.md) |
+| Designer UX (Sally)         | `bmad-agent-ux-designer` | `CU`                                           | Création du design UX[^2]                                                                                                                                                  |
+| Rédacteur Technique (Paige) | `bmad-agent-tech-writer` | `DP`, `WD`, `MG`, `VD`, `EC`                   | Documentation du projet, Rédaction de documents, Génération de diagrammes Mermaid, Validation de documents, Explication de concepts                                        |
 
 ## Types de déclencheurs
 
-Les déclencheurs de menu d'agent utilisent deux types d'invocation différents. Connaître le type utilisé par un déclencheur vous aide à fournir la bonne entrée.
+Les déclencheurs de menu d’agent utilisent deux types d’invocation différents. Connaître le type utilisé par un déclencheur vous aide à fournir la bonne entrée.
 
 ### Déclencheurs de workflow (aucun argument nécessaire)
 
-La plupart des déclencheurs chargent un fichier de workflow structuré. Tapez le code du déclencheur et l'agent démarre le workflow, vous demandant de saisir les informations à chaque étape.
+La plupart des déclencheurs chargent un fichier de workflow structuré. Tapez le code du déclencheur et l’agent démarre le workflow, vous demandant de saisir les informations à chaque étape.
 
-Exemples : `CP` (Create PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
+Exemples : `PRD` (Créer, mettre à jour ou valider un PRD), `DS` (Dev Story), `CA` (Créer l’architecture), `QD` (Quick Dev)
 
 ### Déclencheurs conversationnels (arguments requis)
 
-Certains déclencheurs lancent une conversation libre au lieu d'un workflow structuré. Ils s'attendent à ce que vous décriviez ce dont vous avez besoin à côté du code du déclencheur.
+Certains déclencheurs lancent une conversation libre au lieu d’un workflow structuré. Ils s’attendent à ce que vous décriviez ce dont vous avez besoin à côté du code du déclencheur.
 
-| Agent | Déclencheur | Ce qu'il faut fournir |
-| --- | --- | --- |
-| Rédacteur Technique (Paige) | `WD` | Description du document à rédiger |
-| Rédacteur Technique (Paige) | `US` | Préférences ou conventions à ajouter aux standards |
-| Rédacteur Technique (Paige) | `MG` | Description et type de diagramme (séquence, organigramme, etc.) |
-| Rédacteur Technique (Paige) | `VD` | Document à valider et domaines à examiner |
-| Rédacteur Technique (Paige) | `EC` | Nom du concept à expliquer |
+| Agent                       | Déclencheur | Ce qu’il faut fournir                                           |
+|-----------------------------|-------------|-----------------------------------------------------------------|
+| Rédacteur Technique (Paige) | `WD`        | Description du document à rédiger                               |
+| Rédacteur Technique (Paige) | `MG`        | Description et type de diagramme (séquence, organigramme, etc.) |
+| Rédacteur Technique (Paige) | `VD`        | Document à valider et domaines à examiner                       |
+| Rédacteur Technique (Paige) | `EC`        | Nom du concept à expliquer                                      |
 
-**Exemple :**
+**Exemple :**
 
 ```text
 WD Rédige un guide de déploiement pour notre configuration Docker

docs/fr/reference/commands.md

@@ -1,50 +1,50 @@
 ---
 title: Skills
-description: Référence des skills BMad — ce qu'ils sont, comment ils fonctionnent et où les trouver.
+description: Référence des skills BMad — ce qu’ils sont, comment ils fonctionnent et où les trouver.
 sidebar:
   order: 4
 ---
 
-Les skills sont des prompts pré-construits qui chargent des agents, exécutent des workflows ou lancent des tâches dans votre IDE. L'installateur BMad les génère à partir de vos modules installés au moment de l'installation. Si vous ajoutez, supprimez ou modifiez des modules ultérieurement, relancez l'installateur pour garder les skills synchronisés (voir [Dépannage](#dépannage)).
+Les skills sont des prompts pré-construits qui chargent des agents, exécutent des workflows ou lancent des tâches dans votre IDE. L’installateur BMad les génère à partir de vos modules installés au moment de l’installation. Si vous ajoutez, supprimez ou modifiez des modules ultérieurement, relancez l’installateur pour garder les skills synchronisés (voir [Dépannage](#dépannage)).
 
 ## Skills vs. Déclencheurs du menu Agent
 
 BMad offre deux façons de démarrer un travail, chacune ayant un usage différent.
 
-| Mécanisme | Comment l'invoquer | Ce qui se passe |
-| --- | --- | --- |
-| **Skill** | Tapez le nom du skill (ex. `bmad-help`) dans votre IDE | Charge directement un agent, exécute un workflow ou lance une tâche |
-| **Déclencheur du menu agent** | Chargez d'abord un agent, puis tapez un code court (ex. `DS`) | L'agent interprète le code et démarre le workflow correspondant tout en préservant son persona |
+| Mécanisme                     | Comment l’invoquer                                            | Ce qui se passe                                                                                |
+|-------------------------------|---------------------------------------------------------------|------------------------------------------------------------------------------------------------|
+| **Skill**                     | Tapez le nom du skill (ex. `bmad-help`) dans votre IDE        | Charge directement un agent, exécute un workflow ou lance une tâche                            |
+| **Déclencheur du menu agent** | Chargez d’abord un agent, puis tapez un code court (ex. `DS`) | L’agent interprète le code et démarre le workflow correspondant tout en préservant son persona |
 
 Les déclencheurs du menu agent nécessitent une session agent active. Utilisez les skills lorsque vous savez quel workflow vous voulez. Utilisez les déclencheurs lorsque vous travaillez déjà avec un agent et souhaitez changer de tâche sans quitter la conversation.
 
 ## Comment les skills sont générés
 
-Lorsque vous exécutez `npx bmad-method install`, l'installateur lit les manifests de chaque module sélectionné et écrit un skill par agent, workflow, tâche et outil. Chaque skill est un répertoire contenant un fichier `SKILL.md` qui indique à l'IA de charger le fichier source correspondant et de suivre ses instructions.
+Lorsque vous exécutez `npx bmad-method install`, l’installateur lit les manifests de chaque module sélectionné et écrit un skill par agent, workflow, tâche et outil. Chaque skill est un répertoire contenant un fichier `SKILL.md` qui indique à l’IA de charger le fichier source correspondant et de suivre ses instructions.
 
-L'installateur utilise des modèles pour chaque type de skill :
+L’installateur utilise des modèles pour chaque type de skill :
 
-| Type de skill | Ce que fait le fichier généré |
-| --- | --- |
-| **Lanceur d'agent** | Charge le fichier de persona de l'agent, active son menu et reste en caractère |
-| **Skill de workflow** | Charge la configuration du workflow et suit ses étapes |
-| **Skill de tâche** | Charge un fichier de tâche autonome et suit ses instructions |
-| **Skill d'outil** | Charge un fichier d'outil autonome et suit ses instructions |
+| Type de skill         | Ce que fait le fichier généré                                                  |
+|-----------------------|--------------------------------------------------------------------------------|
+| **Lanceur d’agent**   | Charge le fichier de persona de l’agent, active son menu et reste en caractère |
+| **Skill de workflow** | Charge la configuration du workflow et suit ses étapes                         |
+| **Skill de tâche**    | Charge un fichier de tâche autonome et suit ses instructions                   |
+| **Skill d’outil**     | Charge un fichier d’outil autonome et suit ses instructions                    |
 
-:::note[Relancer l'installateur]
-Si vous ajoutez ou supprimez des modules, relancez l'installateur. Il régénère tous les fichiers de skill pour correspondre à votre sélection actuelle de modules.
+:::note[Relancer l’installateur]
+Si vous ajoutez ou supprimez des modules, relancez l’installateur. Il régénère tous les fichiers de skill pour correspondre à votre sélection actuelle de modules.
 :::
 
 ## Emplacement des fichiers de skill
 
-L'installateur écrit les fichiers de skill dans un répertoire spécifique à l'IDE à l'intérieur de votre projet. Le chemin exact dépend de l'IDE que vous avez sélectionné lors de l'installation.
+L’installateur écrit les fichiers de skill dans un répertoire spécifique à l’IDE à l’intérieur de votre projet. Le chemin exact dépend de l’IDE que vous avez sélectionné lors de l’installation.
 
-| IDE / CLI | Répertoire des skills |
-| --- | --- |
-| Claude Code | `.claude/skills/` |
-| Cursor | `.cursor/skills/` |
-| Windsurf | `.windsurf/skills/` |
-| Autres IDE | Consultez la sortie de l'installateur pour le chemin cible |
+| IDE / CLI   | Répertoire des skills                                      |
+|-------------|------------------------------------------------------------|
+| Claude Code | `.claude/skills/`                                          |
+| Cursor      | `.agents/skills/`                                          |
+| Windsurf    | `.agents/skills/`                                          |
+| Autres IDE  | Consultez la sortie de l’installateur pour le chemin cible |
 
 Chaque skill est un répertoire contenant un fichier `SKILL.md`. Par exemple, une installation Claude Code ressemble à :
 
@@ -52,7 +52,7 @@ Chaque skill est un répertoire contenant un fichier `SKILL.md`. Par exemple, un
 .claude/skills/
 ├── bmad-help/
 │   └── SKILL.md
-├── bmad-create-prd/
+├── bmad-prd/
 │   └── SKILL.md
 ├── bmad-agent-dev/
 │   └── SKILL.md
@@ -63,7 +63,7 @@ Le nom du répertoire détermine le nom du skill dans votre IDE. Par exemple, le
 
 ## Comment découvrir vos skills
 
-Tapez le nom du skill dans votre IDE pour l'invoquer. Certaines plateformes nécessitent d'activer les skills dans les paramètres avant qu'ils n'apparaissent.
+Tapez le nom du skill dans votre IDE pour l’invoquer. Certaines plateformes nécessitent d’activer les skills dans les paramètres avant qu’ils n’apparaissent.
 
 Exécutez `bmad-help` pour obtenir des conseils contextuels sur votre prochaine étape.
 
@@ -73,40 +73,40 @@ Les répertoires de skills générés dans votre projet sont la liste de référ
 
 ## Catégories de skills
 
-### Skills d'agent
+### Skills d’agent
 
-Les skills d'agent chargent un persona[^2] IA spécialisé avec un rôle défini, un style de communication et un menu de workflows. Une fois chargé, l'agent reste en caractère et répond aux déclencheurs du menu.
+Les skills d’agent chargent un persona[^2] IA spécialisé avec un rôle défini, un style de communication et un menu de workflows. Une fois chargé, l’agent reste en caractère et répond aux déclencheurs du menu.
 
-| Exemple de skill | Agent                  | Rôle                                                        |
-|------------------|------------------------|-------------------------------------------------------------|
-| `bmad-agent-dev` | Amelia (Développeur)   | Implémente les stories avec une adhérence stricte aux specs |
-| `bmad-pm`        | John (Product Manager) | Crée et valide les PRDs[^1]                                 |
-| `bmad-architect` | Winston (Architecte)   | Conçoit l'architecture système                              |
+| Exemple de skill       | Agent                  | Rôle                                                        |
+|------------------------|------------------------|-------------------------------------------------------------|
+| `bmad-agent-dev`       | Amelia (Développeur)   | Implémente les stories avec une adhérence stricte aux specs |
+| `bmad-agent-pm`        | John (Product Manager) | Crée, met à jour et valide les PRDs[^1]                     |
+| `bmad-agent-architect` | Winston (Architecte)   | Conçoit l’architecture système                              |
 
 Consultez [Agents](./agents.md) pour la liste complète des agents par défaut et leurs déclencheurs.
 
 ### Skills de workflow
 
-Les skills de workflow exécutent un processus structuré en plusieurs étapes sans charger d'abord un persona d'agent. Ils chargent une configuration de workflow et suivent ses étapes.
+Les skills de workflow exécutent un processus structuré en plusieurs étapes sans charger d’abord un persona d’agent. Ils chargent une configuration de workflow et suivent ses étapes.
 
-| Exemple de skill | Objectif |
-| --- | --- |
-| `bmad-product-brief` | Créer un product brief[^3] — découverte guidée lorsque votre concept est clair |
-| `bmad-prfaq` | Défi [PRFAQ Working Backwards](../explanation/analysis-phase.md#prfaq-working-backwards) pour éprouver votre concept produit |
-| `bmad-create-prd` | Créer un PRD[^1] |
-| `bmad-create-architecture` | Concevoir l'architecture système |
-| `bmad-create-epics-and-stories` | Créer des epics et des stories |
-| `bmad-dev-story` | Implémenter une story |
-| `bmad-code-review` | Effectuer une revue de code |
-| `bmad-quick-dev` | Flux rapide unifié — clarifier l'intention, planifier, implémenter, réviser, présenter |
+| Exemple de skill                | Objectif                                                                                                                     |
+|---------------------------------|------------------------------------------------------------------------------------------------------------------------------|
+| `bmad-product-brief`            | Créer ou mettre à jour un product brief[^3] — découverte guidée lorsque votre concept est clair                              |
+| `bmad-prfaq`                    | Défi [PRFAQ Working Backwards](../explanation/analysis-phase.md#prfaq-working-backwards) pour éprouver votre concept produit |
+| `bmad-prd`                      | Créer, mettre à jour ou valider un PRD[^1]                                                                                   |
+| `bmad-create-architecture`      | Concevoir l’architecture système                                                                                             |
+| `bmad-create-epics-and-stories` | Créer des epics et des stories                                                                                               |
+| `bmad-dev-story`                | Implémenter une story                                                                                                        |
+| `bmad-code-review`              | Effectuer une revue de code                                                                                                  |
+| `bmad-quick-dev`                | Flux rapide unifié — clarifier l’intention, planifier, implémenter, réviser, présenter                                       |
 
 Consultez la [Carte des workflows](./workflow-map.md) pour la référence complète des workflows organisés par phase.
 
-### Skills de tâche et d'outil
+### Skills de tâche et d’outil
 
-Les tâches et outils sont des opérations autonomes qui ne nécessitent pas de contexte d'agent ou de workflow.
+Les tâches et outils sont des opérations autonomes qui ne nécessitent pas de contexte d’agent ou de workflow.
 
-**BMad-Help : Votre guide intelligent**
+**BMad-Help : Votre guide intelligent**
 
 `bmad-help` est votre interface principale pour découvrir quoi faire ensuite. Il inspecte votre projet, comprend les requêtes en langage naturel et recommande la prochaine étape requise ou optionnelle en fonction de vos modules installés.
 
@@ -120,22 +120,22 @@ bmad-help Quelles sont mes options pour le design UX ?
 
 **Autres tâches et outils principaux**
 
-Le module principal inclut 11 outils intégrés — revues, compression, brainstorming, gestion de documents, et plus. Consultez [Outils principaux](./core-tools.md) pour la référence complète.
+Le module principal inclut 12 outils intégrés — specs, revues, brainstorming, personnalisation, gestion de documents, et plus. Consultez [Outils principaux](./core-tools.md) pour la référence complète.
 
 ## Convention de nommage
 
-Tous les skills utilisent le préfixe `bmad-` suivi d'un nom descriptif (ex. `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`). Consultez [Modules](./modules.md) pour les modules disponibles.
+Tous les skills utilisent le préfixe `bmad-` suivi d’un nom descriptif (ex. `bmad-agent-dev`, `bmad-prd`, `bmad-help`). Consultez [Modules](./modules.md) pour les modules disponibles.
 
 ## Dépannage
 
-**Les skills n'apparaissent pas après l'installation.** Certaines plateformes nécessitent d'activer explicitement les skills dans les paramètres. Consultez la documentation de votre IDE ou demandez à votre assistant IA comment activer les skills. Vous devrez peut-être aussi redémarrer votre IDE ou recharger la fenêtre.
+**Les skills n’apparaissent pas après l’installation.** Certaines plateformes nécessitent d’activer explicitement les skills dans les paramètres. Consultez la documentation de votre IDE ou demandez à votre assistant IA comment activer les skills. Vous devrez peut-être aussi redémarrer votre IDE ou recharger la fenêtre.
 
-**Des skills attendus sont manquants.** L'installateur génère uniquement les skills pour les modules que vous avez sélectionnés. Exécutez à nouveau `npx bmad-method install` et vérifiez votre sélection de modules. Vérifiez que les fichiers de skill existent dans le répertoire attendu.
+**Des skills attendus sont manquants.** L’installateur génère uniquement les skills pour les modules que vous avez sélectionnés. Exécutez à nouveau `npx bmad-method install` et vérifiez votre sélection de modules. Vérifiez que les fichiers de skill existent dans le répertoire attendu.
 
-**Des skills d'un module supprimé apparaissent encore.** L'installateur ne supprime pas automatiquement les anciens fichiers de skill. Supprimez les répertoires obsolètes du répertoire de skills de votre IDE, ou supprimez tout le répertoire de skills et relancez l'installateur pour obtenir un ensemble propre.
+**Des skills d’un module supprimé apparaissent encore.** L’installateur ne supprime pas automatiquement les anciens fichiers de skill. Supprimez les répertoires obsolètes du répertoire de skills de votre IDE, ou supprimez tout le répertoire de skills et relancez l’installateur pour obtenir un ensemble propre.
 
 ## Glossaire
 
 [^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
-[^2]: Persona : dans le contexte de BMad, un persona désigne un agent IA avec un rôle défini, un style de communication et une expertise spécifiques (ex. Mary l'analyste, Winston l'architecte). Chaque persona garde son "caractère" pendant les interactions.
-[^3]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d'un projet ou d'une demande, afin d'aligner rapidement les parties prenantes avant le travail détaillé.
+[^2]: Persona : dans le contexte de BMad, un persona désigne un agent IA avec un rôle défini, un style de communication et une expertise spécifiques (ex. Mary l’analyste, Winston l’architecte). Chaque persona garde son « caractère » pendant les interactions.
+[^3]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.

docs/fr/reference/core-tools.md

@@ -5,71 +5,72 @@ sidebar:
   order: 3
 ---
 
-Chaque installation BMad comprend un ensemble de compétences principales qui peuvent être utilisées conjointement avec tout ce que vous faites — des tâches et des workflows autonomes qui fonctionnent dans tous les projets, tous les modules et toutes les phases. Ceux-ci sont toujours disponibles, quels que soient les modules optionnels que vous installez.
+Chaque installation BMad comprend un ensemble de compétences principales utilisables en complément de tout ce que vous faites — des tâches et des workflows autonomes qui fonctionnent dans tous les projets, tous les modules et toutes les phases. Elles restent toujours disponibles, quels que soient les modules optionnels que vous installez.
 
 :::tip[Raccourci Rapide]
-Exécutez n'importe quel outil principal en tapant son nom de compétence (par ex., `bmad-help`) dans votre IDE. Aucune session d'agent requise.
+Exécutez n’importe quel outil principal en tapant son nom de compétence (par ex., `bmad-help`) dans votre IDE. Aucune session d’agent requise.
 :::
 
-## Vue d'ensemble
+## Vue d’ensemble
 
-| Outil                                                                 | Type     | Objectif                                                                     |
-|-----------------------------------------------------------------------|----------|------------------------------------------------------------------------------|
-| [`bmad-help`](#bmad-help)                                             | Tâche    | Obtenir des conseils contextuels sur la prochaine étape                      |
-| [`bmad-brainstorming`](#bmad-brainstorming)                           | Workflow | Faciliter des sessions de brainstorming interactives                         |
-| [`bmad-party-mode`](#bmad-party-mode)                                 | Workflow | Orchestrer des discussions de groupe multi-agents                            |
-| [`bmad-spec`](#bmad-spec)                                             | Workflow | Distill any intent input into a SPEC kernel and companions (translation pending)                   |
-| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation)             | Tâche    | Pousser la sortie LLM à travers des méthodes de raffinement itératives       |
-| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Tâche    | Revue cynique qui trouve ce qui manque et ce qui ne va pas                   |
-| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter)       | Tâche    | Analyse exhaustive des chemins de branchement pour les cas limites non gérés |
-| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose)         | Tâche    | Révision de copie clinique pour la clarté de communication                   |
-| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Tâche    | Édition structurelle — coupes, fusions et réorganisation                     |
-| [`bmad-shard-doc`](#bmad-shard-doc)                                   | Tâche    | Diviser les fichiers markdown volumineux en sections organisées              |
-| [`bmad-index-docs`](#bmad-index-docs)                                 | Tâche    | Générer ou mettre à jour un index de tous les documents dans un dossier      |
+| Outil                                                                 | Type     | Objectif                                                                      |
+|-----------------------------------------------------------------------|----------|-------------------------------------------------------------------------------|
+| [`bmad-help`](#bmad-help)                                             | Tâche    | Obtenir des conseils contextuels sur la prochaine étape                       |
+| [`bmad-brainstorming`](#bmad-brainstorming)                           | Workflow | Faciliter des sessions de brainstorming interactives                          |
+| [`bmad-party-mode`](#bmad-party-mode)                                 | Workflow | Orchestrer des discussions de groupe multi-agents                             |
+| [`bmad-spec`](#bmad-spec)                                             | Workflow | Distiller toute formulation d’intention en un noyau SPEC et fichiers associés |
+| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation)             | Tâche    | Soumettre la sortie LLM à des méthodes de raffinement itératives              |
+| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Tâche    | Revue cynique qui traque ce qui manque et ce qui ne va pas                    |
+| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter)       | Tâche    | Analyse exhaustive des chemins de branchement pour les cas limites non gérés  |
+| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose)         | Tâche    | Correction éditoriale clinique pour la clarté de communication                |
+| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Tâche    | Édition structurelle — coupes, fusions et réorganisation                      |
+| [`bmad-shard-doc`](#bmad-shard-doc)                                   | Tâche    | Diviser les fichiers markdown volumineux en sections organisées               |
+| [`bmad-index-docs`](#bmad-index-docs)                                 | Tâche    | Générer ou mettre à jour un index de tous les documents dans un dossier       |
+| [`bmad-customize`](#bmad-customize)                                   | Tâche    | Créer et vérifier des personnalisations BMad                                  |
 
 ## bmad-help
 
-**Votre guide intelligent pour la suite.** — Inspecte l'état de votre projet, détecte ce qui a été fait et recommande la prochaine étape requise ou facultative.
+**Votre guide intelligent pour la suite.** — Inspecte l’état de votre projet, détecte ce qui a été fait et recommande la prochaine étape requise ou facultative.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Vous avez terminé un workflow et voulez savoir ce qui suit
-- Vous êtes nouveau sur BMad et avez besoin d'orientation
+- Vous avez terminé un workflow et voulez savoir quoi faire ensuite
+- Vous êtes nouveau sur BMad et avez besoin d’orientation
 - Vous êtes bloqué et voulez des conseils contextuels
 - Vous avez installé de nouveaux modules et voulez voir ce qui est disponible
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Analyse votre projet pour les artefacts existants (PRD, architecture, stories, etc.)
+1. Analyse votre projet pour détecter les artefacts existants (PRD, architecture, stories, etc.)
 2. Détecte quels modules sont installés et leurs workflows disponibles
-3. Recommande les prochaines étapes par ordre de priorité — étapes requises d'abord, puis facultatives
+3. Recommande les prochaines étapes par ordre de priorité — étapes requises d’abord, puis facultatives
 4. Présente chaque recommandation avec la commande de compétence et une brève description
 
-**Entrée :** Requête optionnelle en langage naturel (par ex., `bmad-help J'ai une idée de SaaS, par où commencer ?`)
+**Entrée :** Requête optionnelle en langage naturel (par ex., `bmad-help J'ai une idée de SaaS, par où commencer ?`)
 
-**Sortie :** Liste priorisée des prochaines étapes recommandées avec les commandes de compétence
+**Sortie :** Liste priorisée des prochaines étapes recommandées avec les commandes de compétence
 
 ## bmad-brainstorming
 
-**Génère des idées diverses à travers des techniques créatives interactives.** — Une session de brainstorming facilitée qui charge des méthodes d'idéation éprouvées depuis une bibliothèque de techniques et vous guide vers plus de 100 idées avant organisation.
+**Génère des idées variées grâce à des techniques créatives interactives.** — Une session de brainstorming facilitée qui charge des méthodes d’idéation éprouvées à partir d’une bibliothèque de techniques et vous guide vers plus de 100 idées avant de les organiser.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
 - Vous commencez un nouveau projet et devez explorer l’espace problème
-- Vous êtes bloqué dans la génération d'idées et avez besoin de créativité structurée
-- Vous voulez utiliser des cadres d'idéation éprouvés (SCAMPER, brainstorming inversé, etc.)
+- Vous êtes bloqué dans la génération d’idées et avez besoin de créativité structurée
+- Vous voulez utiliser des cadres d’idéation éprouvés (SCAMPER, brainstorming inversé, etc.)
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Configure une session de brainstorming avec votre sujet
-2. Charge les techniques créatives depuis une bibliothèque de méthodes
-3. Vous guide à travers technique après technique, générant des idées
-4. Applique un protocole anti-biais — change de domaine créatif toutes les 10 idées pour éviter le regroupement
+2. Charge les techniques créatives à partir d’une bibliothèque de méthodes
+3. Vous guide de technique en technique, en générant des idées
+4. Applique un protocole anti-biais — bascule de domaine créatif toutes les 10 idées pour éviter les biais de regroupement
 5. Produit un document de session en mode ajout uniquement avec toutes les idées organisées par technique
 
-**Entrée :** Sujet de brainstorming ou énoncé de problème, fichier de contexte optionnel
+**Entrée :** Sujet de brainstorming ou énoncé de problème, fichier de contexte optionnel
 
-**Sortie :** `brainstorming-session-{date}.md` avec toutes les idées générées
+**Sortie :** `brainstorming-session-{date}.md` avec toutes les idées générées
 
 :::note[Cible de Quantité]
 La magie se produit dans les idées 50–100. Le workflow encourage la génération de plus de 100 idées avant organisation.
@@ -77,195 +78,249 @@ La magie se produit dans les idées 50–100. Le workflow encourage la générat
 
 ## bmad-party-mode
 
-**Orchestre des discussions de groupe multi-agents.** — Charge tous les agents BMad installés et facilite une conversation naturelle où chaque agent contribue depuis son expertise et personnalité uniques.
+**Orchestre des discussions de groupe multi-agents.** — Charge tous les agents BMad installés et facilite une conversation naturelle où chaque agent apporte son expertise et sa personnalité uniques.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Vous avez besoin de multiples perspectives d'experts sur une décision
+- Vous avez besoin de multiples perspectives d’experts sur une décision
 - Vous voulez que les agents remettent en question les hypothèses des autres
 - Vous explorez un sujet complexe qui couvre plusieurs domaines
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Charge le manifeste d'agents avec toutes les personnalités d'agents installées
+1. Charge le manifeste d’agents avec toutes les personnalités d’agents installées
 2. Analyse votre sujet pour sélectionner les 2–3 agents les plus pertinents
-3. Les agents prennent des tours pour contribuer, avec des échanges naturels et des désaccords
-4. Fait rouler la participation des agents pour assurer des perspectives diverses au fil du temps
+3. Les agents contribuent à tour de rôle, avec des échanges spontanés et des désaccords
+4. Alterne la participation des agents pour garantir des perspectives variées
 5. Quittez avec `goodbye`, `end party` ou `quit`
 
-**Entrée :** Sujet de discussion ou question, ainsi que la spécification des personas que vous souhaitez faire participer (optionnel)
+**Entrée :** Sujet de discussion ou question, ainsi que la spécification des personas que vous souhaitez faire participer (optionnel)
+
+**Sortie :** Conversation multi-agents en temps réel conservant la personnalité de chaque agent
+
+## bmad-spec
+
+**Distille toute formulation d’intention en un contrat SPEC canonique pour le travail en aval.** — Accepte un brief, un PRD, un GDD, un RFC, un brain dump, une transcription, un dossier UX ou une entrée multi-source mixte et produit un `SPEC.md` structuré autour d’un noyau de cinq champs (Pourquoi, Capacités, Contraintes, Non-objectifs, Signal de succès) ainsi que des fichiers compagnons pour le contenu essentiel qui ne trouve pas sa place dans le noyau.
+
+**À utiliser quand :**
+
+- Vous devez verrouiller le QUOI avant le COMMENT pour tout type de travail (logiciel, game design, recherche, éditorial, politique, entreprise)
+- Vous souhaitez un contrat succinct optimisé pour les LLM, sans fioritures, que les compétences en aval peuvent consommer sans relire chaque artefact en amont
+- Vous voulez valider ou mettre à jour une spécification existante
+
+**Fonctionnement :**
+
+1. Lit l’entrée et tout document annexe lié
+2. Distille en un noyau à cinq champs via un modèle configurable ; redirige l’excédent vers des fichiers compagnons correctement nommés
+3. Exécute une auto-validation en deux passes (règles de cohérence, puis préservation de chaque affirmation essentielle de la source)
+4. Écrit `SPEC.md`, les compagnons associés, et un `.decision-log.md` sous `{output_folder}/specs/spec-{slug}/`
+
+La loi Spec impose huit règles : les capacités expriment à la fois l’intention et le critère de succès ; les intentions décrivent le QUOI, pas le COMMENT ; les contraintes guident réellement les décisions ; les non-objectifs sont explicites ; les signaux de succès sont concrets ; les identifiants de capacité sont stables ; chaque affirmation essentielle de la source est préservée ; la rédaction est concise.
+
+**Entrée :**
+
+- `input` (requis) — Chemin ou texte fourni directement. Idée vague, brain dump, PRD, GDD, RFC, brief, transcription, dossier de maquettes, multi-source mixte
+- `slug` (optionnel) — Requis uniquement lorsque l’entrée est succincte et qu’aucun slug ne peut être dérivé du nom de fichier source
+- `target_spec_path` (optionnel) — Définir pour mettre à jour une spécification existante au lieu d’en créer une nouvelle
+
+**Sortie :** Dossier de spécification contenant `SPEC.md`, les éventuels fichiers compagnons, et un `.decision-log.md`. Les appelants en mode headless reçoivent une réponse JSON avec le statut du résultat et la liste des fichiers écrits ou modifiés.
+
+:::note[Contrat de mutation]
+`bmad-spec` est le seul outil autorisé à écrire `SPEC.md` et les fichiers compagnons de la spécification. Les autres compétences produisent leurs propres artefacts natifs et invoquent `bmad-spec` en mode headless lorsqu’elles ont besoin d’exprimer une intention sous forme de contrat canonique ou de proposer des mises à jour.
+:::
 
-**Sortie :** Conversation multi-agents en temps réel avec des personnalités d'agents maintenues
 
 ## bmad-advanced-elicitation
 
-**Passer la sortie du LLM à travers des méthodes de raffinement itératives.** — Sélectionne depuis une bibliothèque de techniques d'élicitation pour améliorer systématiquement le contenu à travers multiples passages.
+**Soumet la sortie du LLM à des méthodes de raffinement itératives.** — Sélectionne à partir d’une bibliothèque de techniques d’élicitation pour améliorer systématiquement le contenu en plusieurs passages.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
 - La sortie du LLM semble superficielle ou générique
-- Vous voulez explorer un sujet depuis de multiples angles analytiques
-- Vous raffinez un document critique et voulez une réflexion plus approfondie
+- Vous voulez explorer un sujet sous plusieurs angles analytiques
+- Vous raffinez un document critique et souhaitez une réflexion plus approfondie
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Charge le registre de méthodes avec plus de 5 techniques d'élicitation
+1. Charge le registre de méthodes avec plus de 5 techniques d’élicitation
 2. Sélectionne les 5 méthodes les mieux adaptées selon le type de contenu et la complexité
 3. Présente un menu interactif — choisissez une méthode, remélangez, ou listez tout
 4. Applique la méthode sélectionnée pour améliorer le contenu
-5. Re-présente les options pour l'amélioration itérative jusqu'à ce que vous sélectionniez "Procéder"
+5. Affiche à nouveau les options d’amélioration itérative jusqu’à ce que vous sélectionniez « Procéder »
 
-**Entrée :** Section de contenu à améliorer
+**Entrée :** Section de contenu à améliorer
 
-**Sortie :** Version améliorée du contenu avec les améliorations appliquées
+**Sortie :** Version améliorée du contenu avec les améliorations appliquées
 
 ## bmad-review-adversarial-general
 
-**Revue contradictoire qui suppose que des problèmes existent et les recherche.** — Adopte une perspective de réviseur sceptique et blasé avec zéro tolérance pour le travail bâclé. Cherche ce qui manque, pas seulement ce qui ne va pas.
+**Revue contradictoire qui part du principe que des problèmes existent et les traque.** — Adopte un regard de réviseur sceptique et blasé, sans aucune tolérance pour le travail bâclé. Cherche ce qui manque, pas seulement ce qui ne va pas.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Vous avez besoin d'assurance qualité avant de finaliser un livrable
-- Vous voulez tester en conditions réelles une spécification, story ou document
+- Vous avez besoin d’assurance qualité avant de finaliser un livrable
+- Vous voulez éprouver une spécification, une story ou un document
 - Vous voulez trouver des lacunes de couverture que les revues optimistes manquent
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Lit le contenu avec une perspective contradictoire et critique
-2. Identifie les problèmes à travers l'exhaustivité, la justesse et la qualité
+1. Lit le contenu avec un regard contradictoire et critique
+2. Identifie les problèmes sur les plans de l’exhaustivité, de la justesse et de la qualité
 3. Recherche spécifiquement ce qui manque — pas seulement ce qui est présent et faux
-4. Doit trouver un minimum de 10 problèmes ou réanalyse plus profondément
+4. Doit trouver un minimum de 10 problèmes ou réanalyser plus en profondeur
 
-**Entrée :**
+**Entrée :**
 
 - `content` (requis) — Diff, spécification, story, document ou tout artefact
-- `also_consider` (optionnel) — Domaines supplémentaires à garder à l'esprit
+- `also_consider` (optionnel) — Domaines supplémentaires à garder à l’esprit
 
-**Sortie :** Liste markdown de plus de 10 constatations avec descriptions
+**Sortie :** Liste markdown de plus de 10 constatations avec descriptions
 
 ## bmad-review-edge-case-hunter
 
-**Parcours tous les chemins de branchement et les conditions limites, ne rapporte que les cas non gérés.** — Méthodologie pure de traçage de chemin[^1] qui dérive mécaniquement les classes de cas limites. Orthogonale à la revue contradictoire — centrée sur la méthode, pas sur l'attitude.
+**Parcourt tous les chemins de branchement et les conditions limites, ne signale que les cas non gérés.** — Méthodologie pure de traçage de chemin[^1] qui dérive mécaniquement les classes de cas limites. Orthogonale à la revue contradictoire — centrée sur la méthode, pas sur l’attitude.
 
-**À utiliser quand :**
+**À utiliser quand :**
 
 - Vous souhaitez une couverture exhaustive des cas limites pour le code ou la logique
-- Vous avez besoin d'un complément à la revue contradictoire (méthodologie différente, résultats différents)
+- Vous avez besoin d’un complément à la revue contradictoire (méthodologie différente, résultats différents)
 - Vous révisez un diff ou une fonction pour des conditions limites
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Énumère tous les chemins de branchement dans le contenu
-2. Dérive mécaniquement les classes de cas limites : else/default manquants, entrées non vérifiées, décalage d’unité, overflow arithmétique, coercition implicite des types, conditions de concurrence, écarts de timeout
-3. Teste chaque chemin contre les protections existantes
-4. Ne rapporte que les chemins non gérés — ignore silencieusement les chemins gérés
+2. Dérive mécaniquement les classes de cas limites : else/default manquants, entrées non protégées, erreurs off-by-one, dépassements arithmétiques, conversions de type implicites, conditions de concurrence, dépassements de délai
+3. Teste chaque chemin face aux protections existantes
+4. Ne signale que les chemins non gérés — ignore silencieusement les chemins gérés
 
-**Entrée :**
+**Entrée :**
 
 - `content` (obligatoire) — Diff, fichier complet ou fonction
-- `also_consider` (facultatif) — Zones supplémentaires à garder à l’esprit
+- `also_consider` (facultatif) — Domaines supplémentaires à garder à l’esprit
 
-**Sortie :** Tableau JSON des résultats, chacun avec `location`, `trigger_condition`, `guard_snippet` et `potential_consequence`
+**Sortie :** Tableau JSON des résultats, chacun avec `location`, `trigger_condition`, `guard_snippet` et `potential_consequence`
 
 :::note[Revue Complémentaire]
-Exécutez à la fois `bmad-review-adversarial-general` et `bmad-review-edge-case-hunter` pour une couverture orthogonale. La revue contradictoire détecte les problèmes de qualité et de complétude ; le chasseur de cas limites détecte les chemins non gérés.
+Exécutez à la fois `bmad-review-adversarial-general` et `bmad-review-edge-case-hunter` pour une couverture orthogonale. La revue contradictoire détecte les problèmes de qualité et de complétude ; le chasseur de cas limites détecte les chemins non gérés.
 :::
 
 ## bmad-editorial-review-prose
 
-**Relecture éditoriale clinique centrée sur la clarté de communication.** — Analyse le texte pour détecter les problèmes qui nuisent à la compréhension. Applique le Microsoft Writing Style Guide baseline. Préserve la voix de l’auteur.
+**Correction éditoriale clinique centrée sur la clarté de communication.** — Analyse le texte pour détecter les problèmes qui nuisent à la compréhension. Applique le Microsoft Writing Style Guide comme référence de base. Préserve la voix de l’auteur.
 
-**À utiliser quand :**
+**À utiliser quand :**
 
-- Vous avez rédigé un document et souhaitez polir le style
+- Vous avez rédigé un document et souhaitez en polir le style
 - Vous devez assurer la clarté pour un public spécifique
 - Vous voulez des corrections de communication sans modifier les choix stylistiques
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Lit le contenu en ignorant les blocs de code et le frontmatter
 2. Identifie les problèmes de communication (pas les préférences de style)
-3. Déduit les doublons du même problème à différents emplacements
+3. Dédoublonne les occurrences d’un même problème à différents endroits
 4. Produit un tableau de corrections en trois colonnes
 
-**Entrée :**
+**Entrée :**
 
 - `content` (obligatoire) — Markdown, texte brut ou XML
 - `style_guide` (facultatif) — Guide de style spécifique au projet
 - `reader_type` (facultatif) — `humans` (par défaut) pour clarté/fluide, ou `llm` pour précision/consistance
 
-**Sortie :** Tableau Markdown en trois colonnes : Texte original | Texte révisé | Modifications
+**Sortie :** Tableau Markdown en trois colonnes : Texte original | Texte révisé | Modifications
 
 ## bmad-editorial-review-structure
 
-**Édition structurelle — propose des coupes, fusions, déplacements et condensations.** — Révise l'organisation du document et propose des changements substantiels pour améliorer la clarté et le flux avant la révision de copie.
+**Édition structurelle — propose des coupes, fusions, réorganisations et condensations.** — Révise l’organisation du document et propose des changements substantiels pour améliorer la clarté et le flux avant la correction éditoriale.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Un document a été produit depuis de multiples sous-processus et a besoin de cohérence structurelle
+- Un document a été produit par plusieurs sous-processus et nécessite une cohérence structurelle
 - Vous voulez réduire la longueur du document tout en préservant la compréhension
 - Vous devez identifier les violations de portée ou les informations critiques enfouies
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Analyse le document contre 5 modèles de structure (Tutoriel, Référence, Explication, Prompt, Stratégique)
 2. Identifie les redondances, violations de portée et informations enfouies
-3. Produit des recommandations priorisées : COUPER, FUSIONNER, DÉPLACER, CONDENSER, QUESTIONNER, PRÉSERVER
-4. Estime la réduction totale en mots et pourcentage
+3. Produit des recommandations priorisées : COUPER, FUSIONNER, DÉPLACER, CONDENSER, QUESTIONNER, PRÉSERVER
+4. Estime la réduction totale en mots et en pourcentage
 
-**Entrée :**
+**Entrée :**
 
 - `content` (requis) — Document à réviser
-- `purpose` (optionnel) — Objectif prévu (par ex., "tutoriel de démarrage rapide")
+- `purpose` (optionnel) — Objectif prévu (par ex., « tutoriel de démarrage rapide »)
 - `target_audience` (optionnel) — Qui lit ceci
 - `reader_type` (optionnel) — `humans` ou `llm`
-- `length_target` (optionnel) — Réduction cible (par ex., "30% plus court")
+- `length_target` (optionnel) — Réduction cible (par ex., « 30% plus court »)
 
-**Sortie :** Résumé du document, liste de recommandations priorisées et réduction estimée
+**Sortie :** Résumé du document, liste de recommandations priorisées et réduction estimée
 
 ## bmad-shard-doc
 
-**Diviser les fichiers markdown volumineux en fichiers de sections organisés.** — Utilise les en-têtes de niveau 2 comme points de division pour créer un dossier de fichiers de sections autonomes avec un index.
+**Fractionne les fichiers markdown volumineux en sections organisées.** — Utilise les en-têtes de niveau 2 comme points de découpe pour créer un dossier de fichiers de sections autonomes avec un index.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
 - Un document markdown est devenu trop volumineux pour être géré efficacement (plus de 500 lignes)
-- Vous voulez diviser un document monolithique en sections navigables
-- Vous avez besoin de fichiers séparés pour l'édition parallèle ou la gestion de contexte LLM
+- Vous voulez découper un document monolithique en sections navigables
+- Vous avez besoin de fichiers séparés pour l’édition parallèle ou la gestion de contexte LLM
 
-**Fonctionnement :**
+**Fonctionnement :**
 
-1. Valide que le fichier source existe et est markdown
-2. Divise sur les en-têtes de niveau 2 (`##`) en fichiers de sections numérotées
-3. Crée un `index.md` avec manifeste de sections et liens
-4. Vous invite à supprimer, archiver ou conserver l'original
+1. Valide que le fichier source existe et est au format markdown
+2. Découpe sur les en-têtes de niveau 2 (`##`) en fichiers de sections numérotées
+3. Crée un `index.md` avec le manifeste de sections et les liens
+4. Vous invite à supprimer, archiver ou conserver l’original
 
-**Entrée :** Chemin du fichier markdown source, dossier de destination optionnel
+**Entrée :** Chemin du fichier markdown source, dossier de destination optionnel
 
-**Sortie :** Dossier avec `index.md` et `01-{section}.md`, `02-{section}.md`, etc.
+**Sortie :** Dossier avec `index.md` et `01-{section}.md`, `02-{section}.md`, etc.
 
 ## bmad-index-docs
 
-**Générer ou mettre à jour un index de tous les documents dans un dossier.** — Analyse un répertoire, lit chaque fichier pour comprendre son objectif et produit un `index.md` organisé avec liens et descriptions.
+**Génère ou met à jour un index de tous les documents dans un dossier.** — Analyse un répertoire, lit chaque fichier pour comprendre son objectif et produit un `index.md` organisé avec liens et descriptions.
 
-**Utilisez-le quand :**
+**À utiliser quand :**
 
-- Vous avez besoin d'un index léger pour un scan LLM rapide des documents disponibles
-- Un dossier de documentation a grandi et a besoin d'une table des matières organisée
+- Vous avez besoin d’un index léger pour un scan LLM rapide des documents disponibles
+- Un dossier de documentation a grandi et nécessite une table des matières organisée
 - Vous voulez un aperçu auto-généré qui reste à jour
 
-**Fonctionnement :**
+**Fonctionnement :**
 
 1. Analyse le répertoire cible pour tous les fichiers non cachés
 2. Lit chaque fichier pour comprendre son objectif réel
 3. Groupe les fichiers par type, objectif ou sous-répertoire
 4. Génère des descriptions concises (3–10 mots chacune)
 
-**Entrée :** Chemin du dossier cible
+**Entrée :** Chemin du dossier cible
 
-**Sortie :** `index.md` avec listes de fichiers organisées, liens relatifs et brèves descriptions
+**Sortie :** `index.md` avec listes de fichiers organisées, liens relatifs et brèves descriptions
+
+## bmad-customize
+
+**Créer et vérifier des personnalisations.** — Vous aide à modifier le comportement d’un agent ou d’un workflow BMad installé sans avoir à écrire de TOML manuellement.
+
+**À utiliser quand :**
+
+- Vous souhaitez modifier le comportement d’un agent ou d’un workflow
+- Vous devez ajouter des faits persistants, des hooks d’activation ou des éléments de menu personnalisés
+- Vous voulez que le bon périmètre de surcharge soit sélectionné et vérifié automatiquement
+
+**Fonctionnement :**
+
+1. Analyse les skills BMad installés pour identifier les surfaces personnalisables
+2. Sélectionne le bon périmètre pour le changement demandé
+3. Écrit les fichiers de surcharge sous `_bmad/custom/`
+4. Vérifie la configuration fusionnée
+
+**Entrée :** Description en langage naturel de la personnalisation souhaitée
+
+**Sortie :** Fichiers de surcharge TOML sous `_bmad/custom/`
+
+Pour un guide détaillé sur la personnalisation de BMad, consultez [Comment personnaliser BMad](../how-to/customize-bmad.md).
 
 ## Glossaire
 
-[^1]: Path-tracing : méthode d'analyse qui suit systématiquement tous les chemins d'exécution possibles dans un programme pour identifier les cas non gérés.
-
+[^1]: Path-tracing : méthode d’analyse qui suit systématiquement tous les chemins d’exécution possibles dans un programme pour identifier les cas non gérés.

docs/fr/reference/modules.md

@@ -1,25 +1,25 @@
 ---
 title: Modules Officiels
-description: Modules additionnels pour créer des agents personnalisés, de l'intelligence créative, du développement de jeux et des tests
+description: Modules additionnels pour créer des agents personnalisés, de l’intelligence créative, du développement de jeux et des tests
 sidebar:
   order: 5
 ---
 
-BMad s'étend via des modules officiels que vous sélectionnez lors de l'installation. Ces modules additionnels fournissent des agents, des workflows et des tâches spécialisés pour des domaines spécifiques, au-delà du noyau intégré et de BMM (suite Agile).
+BMad s’étend via des modules officiels que vous sélectionnez lors de l’installation. Ces modules additionnels fournissent des agents, des workflows et des tâches spécialisés pour des domaines spécifiques, au-delà du noyau intégré et de BMM (suite Agile).
 
 :::tip[Installer des Modules]
-Exécutez `npx bmad-method install` et sélectionnez les modules souhaités. L'installateur gère automatiquement le téléchargement, la configuration et l'intégration IDE.
+Exécutez `npx bmad-method install` et sélectionnez les modules souhaités. L’installateur gère automatiquement le téléchargement, la configuration et l’intégration IDE.
 :::
 
 ## BMad Builder
 
 Créez des agents personnalisés, des workflows et des modules spécifiques à un domaine avec une assistance guidée. BMad Builder est le méta-module pour étendre le framework lui-même.
 
-- **Code :** `bmb`
-- **npm :** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
-- **GitHub :** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
+- **Code :** `bmb`
+- **npm :** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
+- **GitHub :** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
 
-**Fournit :**
+**Fournit :**
 
 - Agent Builder — créez des agents IA spécialisés avec une expertise et un accès aux outils personnalisés
 - Workflow Builder — concevez des processus structurés avec des étapes et des points de décision
@@ -28,46 +28,46 @@ Créez des agents personnalisés, des workflows et des modules spécifiques à u
 
 ## Creative Intelligence Suite
 
-Outils basés sur l'IA pour la créativité structurée, l'idéation et l'innovation pendant le développement en phase amont. La suite fournit plusieurs agents qui facilitent le brainstorming, le design thinking et la résolution de problèmes en utilisant des cadres éprouvés.
+Outils basés sur l’IA pour la créativité structurée, l’idéation et l’innovation pendant le développement en phase amont. La suite fournit plusieurs agents qui facilitent le brainstorming, le design thinking et la résolution de problèmes en utilisant des cadres éprouvés.
 
-- **Code :** `cis`
-- **npm :** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
-- **GitHub :** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
+- **Code :** `cis`
+- **npm :** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
+- **GitHub :** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
 
-**Fournit :**
+**Fournit :**
 
 - Agents Innovation Strategist, Design Thinking Coach et Brainstorming Coach
 - Problem Solver et Creative Problem Solver pour la pensée systématique et latérale
 - Storyteller et Presentation Master pour les récits et les présentations
-- Cadres d'idéation incluant SCAMPER[^1], Brainstorming inversé et reformulation de problèmes
+- Cadres d’idéation incluant SCAMPER[^1], Brainstorming inversé et reformulation de problèmes
 
 ## Game Dev Studio
 
 Workflows de développement de jeux structurés adaptés pour Unity, Unreal, Godot et moteurs personnalisés. Supporte le prototypage rapide via Quick Dev et la production à grande échelle avec des sprints propulsés par epics.
 
-- **Code :** `gds`
-- **npm :** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
-- **GitHub :** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
+- **Code :** `gds`
+- **npm :** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
+- **GitHub :** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
 
-**Fournit :**
+**Fournit :**
 
 - Workflow de génération de Document de Design de Jeu (GDD[^3])
 - Mode Quick Dev pour le prototypage rapide
 - Support de design narratif pour les personnages, dialogues et construction de monde
-- Couverture de plus de 21 types de jeux avec des conseils d'architecture spécifiques au moteur
+- Couverture de plus de 21 types de jeux avec des conseils d’architecture spécifiques au moteur
 
 ## Test Architect (TEA)
 
-Stratégie de test de niveau entreprise, conseils d'automatisation et décisions de porte de release via un agent expert et neuf workflows structurés. TEA va bien au-delà du workflow QA intégré avec une priorisation basée sur les risques et une traçabilité des exigences.
+Stratégie de test de niveau entreprise, conseils d’automatisation et décisions de porte de release via un agent expert et neuf workflows structurés. TEA va bien au-delà du workflow QA intégré avec une priorisation basée sur les risques et une traçabilité des exigences.
 
-- **Code :** `tea`
-- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
-- **GitHub :** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
+- **Code :** `tea`
+- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+- **GitHub :** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
 
-**Fournit :**
+**Fournit :**
 
 - Agent Murat (Master Test Architect and Quality Advisor)
-- Workflows pour la conception de tests, ATDD, l'automatisation, la revue de tests et la traçabilité
+- Workflows pour la conception de tests, ATDD, l’automatisation, la revue de tests et la traçabilité
 - Évaluation NFR[^2], configuration CI et scaffolding de framework
 - Priorisation P0-P3 avec Playwright Utils et intégrations MCP optionnelles
 
@@ -77,6 +77,6 @@ Les modules communautaires et une marketplace de modules sont à venir. Consulte
 
 ## Glossaire
 
-[^1]: SCAMPER : acronyme anglais pour une technique de créativité structurée (Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse) qui permet d'explorer systématiquement les modifications possibles d'un produit ou d'une idée pour générer des innovations.
+[^1]: SCAMPER : acronyme anglais pour une technique de créativité structurée (Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse) qui permet d’explorer systématiquement les modifications possibles d’un produit ou d’une idée pour générer des innovations.
 [^2]: NFR (Non-Functional Requirement) : exigence décrivant les contraintes de qualité du système (performance, sécurité, fiabilité, ergonomie) plutôt que ses fonctionnalités.
-[^3]: GDD (Game Design Document) : document de conception de jeu qui décrit en détail les mécaniques, l'univers, les personnages, les niveaux et tous les aspects du jeu à développer.
+[^3]: GDD (Game Design Document) : document de conception de jeu qui décrit en détail les mécaniques, l’univers, les personnages, les niveaux et tous les aspects du jeu à développer.

docs/fr/reference/testing.md

@@ -1,53 +1,53 @@
 ---
 title: Options de Testing
-description: Comparaison du workflow QA intégré avec le module Test Architect (TEA) pour l'automatisation des tests.
+description: Comparaison du workflow QA intégré avec le module Test Architect (TEA) pour l’automatisation des tests.
 sidebar:
   order: 6
 ---
 
-BMad propose deux approches de test : un workflow QA[^1] intégré pour une génération rapide de tests et un module Test Architect installable pour une stratégie de test de qualité entreprise.
+BMad propose deux approches de test : un workflow QA[^1] intégré pour une génération rapide de tests et un module Test Architect installable pour une stratégie de test de qualité entreprise.
 
-## Lequel Choisir ?
+## Lequel Choisir ?
 
-| Facteur                 | QA Intégré                           | Module TEA                                                          |
+| Facteur                 | QA Intégré                                   | Module TEA                                                          |
 |-------------------------|----------------------------------------------|---------------------------------------------------------------------|
 | **Idéal pour**          | Projets petits et moyens, couverture rapide  | Grands projets, domaines réglementés ou complexes                   |
-| **Installation**        | Rien à installer — inclus dans BMM          | Installer séparément via `npx bmad-method install`                  |
-| **Approche**            | Générer les tests rapidement, itérer ensuite | Planifier d'abord, puis générer avec traçabilité                    |
+| **Installation**        | Rien à installer — inclus dans BMM           | Installer séparément via `npx bmad-method install`                  |
+| **Approche**            | Générer les tests rapidement, itérer ensuite | Planifier d’abord, puis générer avec traçabilité                    |
 | **Types de tests**      | Tests API et E2E                             | API, E2E, ATDD[^2], NFR, et plus                                    |
 | **Stratégie**           | Chemin nominal + cas limites critiques       | Priorisation basée sur les risques (P0-P3)                          |
 | **Nombre de workflows** | 1 (Automate)                                 | 9 (conception, ATDD, automatisation, revue, traçabilité, et autres) |
 
 :::tip[Commencez avec le QA Intégré]
-La plupart des projets devraient commencer avec le workflow QA intégré. Si vous avez ensuite besoin d'une stratégie de test, de murs de qualité ou de traçabilité des exigences, installez TEA en complément.
+La plupart des projets devraient commencer avec le workflow QA intégré. Si vous avez ensuite besoin d’une stratégie de test, de murs de qualité ou de traçabilité des exigences, installez TEA en complément.
 :::
 
 ## Workflow QA Intégré
 
-Le workflow QA intégré (`bmad-qa-generate-e2e-tests`) fait partie du module BMM (suite Agile), disponible via l'agent Developer. Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
+Le workflow QA intégré (`bmad-qa-generate-e2e-tests`) fait partie du module BMM (suite Agile), disponible via l’agent Developer. Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
 
-**Déclencheur :** `QA` (via l'agent Developer) ou `bmad-qa-generate-e2e-tests`
+**Déclencheur :** `QA` (via l’agent Developer) ou `bmad-qa-generate-e2e-tests`
 
 ### Ce que le Workflow QA Fait
 
 Le workflow QA exécute un processus unique (Automate) qui parcourt cinq étapes :
 
-1. **Détecte le framework de test** — analyse `package.json` et les fichiers de test existants pour identifier votre framework (Jest, Vitest, Playwright, Cypress, ou tout runner standard). Si aucun n'existe, analyse la pile technologique du projet et en suggère un.
-2. **Identifie les fonctionnalités** — demande ce qu'il faut tester ou découvre automatiquement les fonctionnalités dans le codebase.
-3. **Génère les tests API** — couvre les codes de statut, la structure des réponses, le chemin nominal, et 1-2 cas d'erreur.
-4. **Génére les tests E2E** — couvre les parcours utilisateur avec des localisateurs sémantiques et des assertions sur les résultats visibles.
+1. **Détecte le framework de test** — analyse `package.json` et les fichiers de test existants pour identifier votre framework (Jest, Vitest, Playwright, Cypress, ou tout runner standard). Si aucun n’existe, analyse la pile technologique du projet et en suggère un.
+2. **Identifie les fonctionnalités** — demande ce qu’il faut tester ou découvre automatiquement les fonctionnalités dans le codebase.
+3. **Génère les tests API** — couvre les codes de statut, la structure des réponses, le chemin nominal, et 1-2 cas d’erreur.
+4. **Génère les tests E2E** — couvre les parcours utilisateur avec des localisateurs sémantiques et des assertions sur les résultats visibles.
 5. **Exécute et vérifie** — lance les tests générés et corrige immédiatement les échecs.
 
-Le workflow QA produit un résumé de test sauvegardé dans le dossier des artefacts d'implémentation de votre projet.
+Le workflow QA produit un résumé de test sauvegardé dans le dossier des artefacts d’implémentation de votre projet.
 
 ### Patterns de Test
 
-Les tests générés suivent une philosophie "simple et maintenable" :
+Les tests générés suivent une philosophie « simple et maintenable » :
 
-- **APIs standard du framework uniquement** — pas d'utilitaires externes ni d'abstractions personnalisées
+- **APIs standard du framework uniquement** — pas d’utilitaires externes ni d’abstractions personnalisées
 - **Localisateurs sémantiques** pour les tests UI (rôles, labels, texte plutôt que sélecteurs CSS)
-- **Tests indépendants** sans dépendances d'ordre
-- **Pas d'attentes ou de sleeps codés en dur**
+- **Tests indépendants** sans dépendances d’ordre
+- **Pas d’attentes ou de sleeps codés en dur**
 - **Descriptions claires** qui se lisent comme de la documentation fonctionnelle
 
 :::note[Portée]
@@ -59,28 +59,28 @@ Le workflow QA génère uniquement des tests. Pour la revue de code et la valida
 - Couverture de test rapide pour une fonctionnalité nouvelle ou existante
 - Automatisation de tests accessible aux débutants sans configuration avancée
 - Patterns de test standards que tout développeur peut lire et maintenir
-- Projets petits et moyens où une stratégie de test complète n'est pas nécessaire
+- Projets petits et moyens où une stratégie de test complète n’est pas nécessaire
 
 ## Module Test Architect (TEA)
 
 TEA est un module autonome qui fournit un agent expert (Murat) et neuf workflows structurés pour des tests de qualité entreprise. Il va au-delà de la génération de tests pour inclure la stratégie de test, la planification basée sur les risques, les murs de qualité et la traçabilité des exigences.
 
-- **Documentation :** [TEA Module Docs](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
-- **Installation :** `npx bmad-method install` et sélectionnez le module TEA
-- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+- **Documentation :** [TEA Module Docs](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+- **Installation :** `npx bmad-method install` et sélectionnez le module TEA
+- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
 
 ### Ce que TEA Fournit
 
 | Workflow              | Objectif                                                                             |
 |-----------------------|--------------------------------------------------------------------------------------|
 | Test Design           | Créer une stratégie de test complète liée aux exigences                              |
-| ATDD                  | Développement piloté par les tests d'acceptation avec critères des parties prenantes |
+| ATDD                  | Développement piloté par les tests d’acceptation avec critères des parties prenantes |
 | Automate              | Générer des tests avec des patterns et utilitaires avancés                           |
 | Test Review           | Valider la qualité et la couverture des tests par rapport à la stratégie             |
-| Traceability          | Remonter les tests aux exigences pour l'audit et la conformité                       |
+| Traceability          | Remonter les tests aux exigences pour l’audit et la conformité                       |
 | NFR Assessment        | Évaluer les exigences non-fonctionnelles (performance, sécurité)                     |
-| CI Setup              | Configurer l'exécution des tests dans les pipelines d'intégration continue           |
-| Framework Scaffolding | Configurer l'infrastructure de test et la structure du projet                        |
+| CI Setup              | Configurer l’exécution des tests dans les pipelines d’intégration continue           |
+| Framework Scaffolding | Configurer l’infrastructure de test et la structure du projet                        |
 | Release Gate          | Prendre des décisions de livraison go/no-go basées sur les données                   |
 
 TEA supporte également la priorisation basée sur les risques P0-P3 et des intégrations optionnelles avec Playwright Utils et les outils MCP.
@@ -88,24 +88,24 @@ TEA supporte également la priorisation basée sur les risques P0-P3 et des int
 ### Quand Utiliser TEA
 
 - Projets nécessitant une traçabilité des exigences ou une documentation de conformité
-- Équipes ayant besoin d'une priorisation des tests basée sur les risques sur plusieurs fonctionnalités
+- Équipes ayant besoin d’une priorisation des tests basée sur les risques sur plusieurs fonctionnalités
 - Environnements entreprise avec des murs de qualité formels avant livraison
-- Domaines complexes où la stratégie de test doit être planifiée avant d'écrire les tests
-- Projets ayant dépassé l'approche à workflow unique du QA intégré
+- Domaines complexes où la stratégie de test doit être planifiée avant d’écrire les tests
+- Projets ayant dépassé l’approche à workflow unique du QA intégré
 
-## Comment les Tests S'Intègrent dans les Workflows
+## Comment les Tests S’Intègrent dans les Workflows
 
-Le workflow Automate du QA intégré apparaît dans la Phase 4 (Implémentation) de la carte de workflow méthode BMad. Il est conçu pour s'exécuter **après qu'un epic complet soit terminé** — une fois que toutes les stories d'un epic ont été implémentées et revues. Une séquence typique :
+Le workflow Automate du QA intégré apparaît dans la Phase 4 (Implémentation) de la carte de workflow méthode BMad. Il est conçu pour s’exécuter **après qu’un epic complet soit terminé** — une fois que toutes les stories d’un epic ont été implémentées et revues. Une séquence typique :
 
-1. Pour chaque story de l'epic : implémenter avec Dev Story (`DS`), puis valider avec Code Review (`CR`)
-2. Après la fin de l'epic : générer les tests avec `QA` (via l'agent Developer) ou le workflow Automate de TEA
+1. Pour chaque story de l’epic : implémenter avec Dev Story (`DS`), puis valider avec Code Review (`CR`)
+2. Après la fin de l’epic : générer les tests avec `QA` (via l’agent Developer) ou le workflow Automate de TEA
 3. Lancer la rétrospective (`bmad-retrospective`) pour capturer les leçons apprises
 
-Le workflow QA travaille directement à partir du code source sans charger les documents de planification (PRD, architecture). Les workflows TEA peuvent s'intégrer avec les artefacts de planification en amont pour la traçabilité.
+Le workflow QA travaille directement à partir du code source sans charger les documents de planification (PRD, architecture). Les workflows TEA peuvent s’intégrer avec les artefacts de planification en amont pour la traçabilité.
 
 Pour en savoir plus sur la place des tests dans le processus global, consultez la [Carte des Workflows](./workflow-map.md).
 
 ## Glossaire
 
 [^1]: QA (Quality Assurance) : assurance qualité, ensemble des processus et activités visant à garantir que le produit logiciel répond aux exigences de qualité définies.
-[^2]: ATDD (Acceptance Test-Driven Development) : méthode de développement où les tests d'acceptation sont écrits avant le code, en collaboration avec les parties prenantes pour définir les critères de réussite.
+[^2]: ATDD (Acceptance Test-Driven Development) : méthode de développement où les tests d’acceptation sont écrits avant le code, en collaboration avec les parties prenantes pour définir les critères de réussite.

docs/fr/reference/workflow-map.md

@@ -1,27 +1,27 @@
 ---
 title: "Carte des Workflows"
-description: Référence visuelle des phases et des résultats des workflows de la méthode BMad
+description: Référence visuelle des phases et des livrables des workflows de la méthode BMad
 sidebar:
   order: 1
 ---
 
-La méthode BMad (BMM) est un module de l'écosystème BMad, conçu pour suivre les meilleures pratiques de l'ingénierie du
-contexte et de la planification. Les agents IA fonctionnent de manière optimale avec un contexte clair et structuré. Le
-système BMM construit ce contexte progressivement à travers 4 phases distinctes — chaque phase, et plusieurs workflows
-optionnels au sein de chaque phase, produisent des documents qui alimentent la phase suivante, afin que les agents
-sachent toujours quoi construire et pourquoi.
+La méthode BMad (BMM) est un module de l’écosystème BMad, conçu pour appliquer les meilleures pratiques d’ingénierie du
+contexte et de planification. Les agents IA sont plus performants lorsqu’ils disposent d’un contexte clair et structuré. Le
+système BMM construit ce contexte de manière progressive, en 4 phases distinctes — chaque phase, ainsi que les workflows
+optionnels qu’elle contient, produit des documents qui nourrissent la phase suivante. Ainsi, les agents savent toujours
+ce qu’ils doivent construire et pourquoi.
 
-La logique et les concepts proviennent des méthodologies agiles qui ont été utilisées avec succès dans l'industrie comme
-cadre mental de référence.
+La logique et les concepts sous-jacents s’appuient sur les méthodologies agiles, largement éprouvées dans l’industrie
+comme cadre de référence.
 
-Si à tout moment vous ne savez pas quoi faire, le skill `bmad-help` vous aidera à rester sur la bonne voie ou à savoir
-quoi faire ensuite. Vous pouvez toujours vous référer à cette page également — mais `bmad-help` est entièrement
-interactif et beaucoup plus rapide si vous avez déjà installé la méthode BMad. De plus, si vous utilisez différents
-modules qui ont étendu la méthode BMad ou ajouté d'autres modules complémentaires non extensifs — `bmad-help` évolue
-pour connaître tout ce qui est disponible et vous donner les meilleurs conseils du moment.
+Si vous ne savez plus où vous en êtes, le skill `bmad-help` vous remettra sur la bonne voie ou vous indiquera la prochaine
+étape. Cette page reste une référence utile, mais `bmad-help` est interactif et bien plus rapide si vous avez déjà installé
+la méthode BMad. Par ailleurs, si vous utilisez des modules ayant étendu la méthode BMad ou ajouté d’autres modules
+complémentaires non extensibles, `bmad-help` s’adapte automatiquement pour couvrir tout ce qui est disponible et vous
+fournir les meilleurs conseils en temps réel.
 
-Note finale importante : Chaque workflow ci-dessous peut être exécuté directement avec l'outil de votre choix via un
-skill ou en chargeant d'abord un agent et en utilisant l'entrée du menu des agents.
+Note importante : chaque workflow ci-dessous peut être exécuté directement via un skill avec l’outil de votre choix, ou
+en chargeant d’abord un agent depuis le menu des agents.
 
 <iframe src="/workflow-map-diagram-fr.html" title="Diagramme de la carte des workflows de la méthode BMad" width="100%" height="100%" style="border-radius: 8px; border: 1px solid #334155; min-height: 900px;"></iframe>
 
@@ -29,93 +29,99 @@ skill ou en chargeant d'abord un agent et en utilisant l'entrée du menu des age
   <a href="/workflow-map-diagram-fr.html" target="_blank" rel="noopener noreferrer">Ouvrir le diagramme dans un nouvel onglet ↗</a>
 </p>
 
-## Phase 1 : Analyse (Optionnelle)
+## Phase 1 : Analyse (Optionnelle)
 
-Explorez l’espace problème et validez les idées avant de vous engager dans la planification. [**Découvrez ce que fait
+Explorez l’espace problème et validez vos idées avant de vous lancer dans la planification. [**Découvrez ce que fait
 chaque outil et quand l’utiliser**](../explanation/analysis-phase.md).
 
-| Workflow                                                                  | Objectif                                                                                 | Produit                   |
-|---------------------------------------------------------------------------|------------------------------------------------------------------------------------------|---------------------------|
-| `bmad-brainstorming`                                                      | Brainstormez des idées de projet avec l’accompagnement guidé d’un coach de brainstorming | `brainstorming-report.md` |
-| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validez les hypothèses de marché, techniques ou de domaine                               | Rapport de recherches     |
-| `bmad-product-brief`                                                      | Capturez la vision stratégique — idéal lorsque votre concept est clair                   | `product-brief.md`        |
-| `bmad-prfaq`                                                              | Working Backwards — éprouvez et forgez votre concept produit                             | `prfaq-{project}.md`      |
+| Workflow                                                                  | Objectif                                                                       | Livrable                  |
+|---------------------------------------------------------------------------|--------------------------------------------------------------------------------|---------------------------|
+| `bmad-brainstorming`                                                      | Brainstormez des idées de projet, animé par un coach de brainstorming dédié    | `brainstorming-report.md` |
+| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validez vos hypothèses de marché, techniques ou liées au domaine               | Rapport de recherches     |
+| `bmad-product-brief`                                                      | Formalisez la vision stratégique — idéal lorsque votre concept est bien défini | `product-brief.md`        |
+| `bmad-prfaq`                                                              | Working Backwards — mettez à l’épreuve et affinez votre concept produit        | `prfaq-{project}.md`      |
 
-## Phase 2 : Planification
+## Phase 2 : Planification
 
-Définissez ce qu'il faut construire et pour qui.
+Définissez ce qu’il faut construire et pour qui.
 
-| Workflow                | Objectif                                                | Produit      |
-|-------------------------|---------------------------------------------------------|--------------|
-| `bmad-create-prd`       | Définissez les exigences (FRs/NFRs)[^1]                 | `PRD.md`[^2] |
-| `bmad-ux`            | Concevez l'expérience utilisateur (lorsque l'UX compte) | `DESIGN.md`, `EXPERIENCE.md` |
+| Workflow   | Objectif                                                                                               | Livrable                                                                                                          |
+|------------|--------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------|
+| `bmad-prd` | Créez, mettez à jour ou validez un PRD[^1] — découverte accompagnée, trois intentions en un seul skill | Création/Mise à jour : `prd.md`, `addendum.md`, `decision-log.md` ; Validation : `validation-report.html` + `.md` |
+| `bmad-ux`  | Concevez l’expérience utilisateur (lorsque l’UX compte)                                                | `DESIGN.md`, `EXPERIENCE.md`                                                                                      |
 
-## Phase 3 : Solutioning
+:::tip[Trois intentions en un seul skill]
+`bmad-prd` couvre l’intégralité du cycle de vie du PRD. Précisez votre intention lors de l’appel, sinon le skill vous la demandera :
+
+- **Créer** — nouveau PRD à partir de zéro via une découverte accompagnée ; produit `prd.md`, `addendum.md` et `decision-log.md`
+- **Mettre à jour** — réconcilie un PRD existant avec un signal de changement, en mettant en évidence les conflits avant d’appliquer les modifications
+- **Valider** — évalue un PRD à l’aide d’une liste de contrôle configurable et produit un rapport de constats structuré au format HTML
+:::
+
+:::tip[En amont : `bmad-product-brief`]
+`bmad-product-brief` (Phase 1) produit un `product-brief.md` que `bmad-prd` peut exploiter lors de la découverte, réduisant les redondances et gardant les deux documents alignés. Aucun des deux skills ne nécessite l’autre — commencez directement par `bmad-prd` si vous savez déjà ce que vous construisez.
+:::
+
+## Phase 3 : Conception de la Solution
 
 Décidez comment le construire et décomposez le travail en stories.
 
-| Workflow                              | Objectif                                          | Produit                         |
+| Workflow                              | Objectif                                          | Livrable                        |
 |---------------------------------------|---------------------------------------------------|---------------------------------|
-| `bmad-create-architecture`            | Rendez les décisions techniques explicites        | `architecture.md` avec ADRs[^3] |
-| `bmad-create-epics-and-stories`       | Décomposez les exigences en travail implémentable | Fichiers d'epic avec stories    |
-| `bmad-check-implementation-readiness` | Vérification avant implémentation                 | Décision Passe/Réserves/Échec   |
+| `bmad-create-architecture`            | Rendez explicites les décisions techniques        | `architecture.md` avec ADRs[^2] |
+| `bmad-create-epics-and-stories`       | Décomposez les exigences en tâches implémentables | Fichiers d’epic avec stories    |
+| `bmad-check-implementation-readiness` | Jalon de validation avant implémentation          | Décision OK / RÉSERVES / ÉCHEC  |
 
-## Phase 4 : Implémentation
+## Phase 4 : Implémentation
 
-Construisez, une story à la fois. Bientôt disponible : automatisation complète de la phase 4 !
+Construisez, une story à la fois. L’automatisation complète de la phase 4 arrive bientôt !
 
-| Workflow               | Objectif                                                                            | Produit                                              |
-|------------------------|-------------------------------------------------------------------------------------|------------------------------------------------------|
-| `bmad-sprint-planning` | Initialisez le suivi (une fois par projet pour séquencer le cycle de développement) | `sprint-status.yaml`                                 |
-| `bmad-create-story`    | Préparez la story suivante pour implémentation                                      | `story-[slug].md`                                    |
-| `bmad-dev-story`       | Implémentez la story                                                                | Code fonctionnel + tests                             |
-| `bmad-code-review`     | Validez la qualité de l'implémentation                                              | Approuvé ou changements demandés                     |
-| `bmad-correct-course`  | Gérez les changements significatifs en cours de sprint                              | Plan mis à jour ou réorientation                     |
-| `bmad-sprint-status`   | Suivez la progression du sprint et le statut des stories                            | Mise à jour du statut du sprint                      |
-| `bmad-retrospective`   | Revue après complétion d'un epic                                                    | Leçons apprises                                      |
-| `bmad-investigate`     | Enquête de cas avec conclusions à preuves graduées, calibrée selon l'entrée         | `{slug}-investigation.md`        |
+| Workflow               | Objectif                                                                             | Livrable                         |
+|------------------------|--------------------------------------------------------------------------------------|----------------------------------|
+| `bmad-sprint-planning` | Initialisez le suivi (une fois par projet, pour séquencer le cycle de développement) | `sprint-status.yaml`             |
+| `bmad-create-story`    | Préparez la story suivante pour implémentation                                       | `story-[slug].md`                |
+| `bmad-dev-story`       | Implémentez la story                                                                 | Code fonctionnel + tests         |
+| `bmad-code-review`     | Validez la qualité de l’implémentation                                               | Approuvé ou changements demandés |
+| `bmad-correct-course`  | Gérez les changements significatifs en cours de sprint                               | Plan mis à jour ou réorientation |
+| `bmad-sprint-status`   | Suivez la progression du sprint et le statut des stories                             | Mise à jour du statut du sprint  |
+| `bmad-retrospective`   | Bilan après l’achèvement d’un epic                                                   | Leçons apprises                  |
+| `bmad-investigate`     | Analyse forensique avec conclusions pondérées par les preuves, adaptée au cas traité | `{slug}-investigation.md`        |
 
-## Quick Dev (Parcours Parallèle)
+## Flux Rapide (Parcours Parallèle)
 
-Sautez les phases 1-3 pour les travaux de faible envergure et bien compris.
+Ignorez les phases 1 à 3 pour les travaux de faible envergure et bien cernés.
 
-| Workflow         | Objectif                                                                            | Produit            |
-|------------------|-------------------------------------------------------------------------------------|--------------------|
-| `bmad-quick-dev` | Flux rapide unifié — clarifie l'intention, planifie, implémente, révise et présente | `spec-*.md` + code |
+| Workflow         | Objectif                                                                              | Livrable           |
+|------------------|---------------------------------------------------------------------------------------|--------------------|
+| `bmad-quick-dev` | Flux rapide unifié — clarifiez l’intention, planifiez, implémentez, révisez et livrez | `spec-*.md` + code |
 
 ## Gestion du Contexte
 
-Chaque document devient le contexte de la phase suivante. Le PRD[^2] indique à l'architecte quelles contraintes sont
-importantes. L'architecture indique à l'agent de développement quels modèles suivre. Les fichiers de story fournissent
-un contexte focalisé et complet pour l'implémentation. Sans cette structure, les agents prennent des décisions
-incohérentes.
+Chaque document nourrit le contexte de la phase suivante. Le PRD indique à l’architecte les contraintes à respecter.
+L’architecture précise à l’agent de développement les modèles à suivre. Les fichiers de story fournissent un contexte
+ciblé et exhaustif pour l’implémentation. Sans cette structure, les agents prennent des décisions incohérentes.
 
 ### Contexte du Projet
 
 :::tip[Recommandé]
-Créez `project-context.md` pour vous assurer que les agents IA suivent les règles et préférences de votre projet. Ce
-fichier fonctionne comme une constitution pour votre projet — il guide les décisions d'implémentation à travers tous les
-workflows. Ce fichier optionnel peut être généré à la fin de la création de l'architecture, ou dans un projet existant
-il peut également être généré pour capturer ce qui est important de conserver aligné avec les conventions actuelles.
+Créez `project-context.md` pour que les agents IA respectent les règles et préférences de votre projet. Ce fichier agit
+comme une charte pour votre projet — il oriente les décisions d’implémentation à travers tous les workflows. Ce fichier
+optionnel peut être généré à la fin de la création de l’architecture, ou, dans un projet existant, pour capturer les
+éléments clés et les garder alignés avec les conventions en vigueur.
 :::
 
-**Comment le créer :**
+**Comment le créer :**
 
-- **Manuellement** — Créez `_bmad-output/project-context.md` avec votre pile technologique et vos règles
-  d'implémentation
-- **Générez-le** — Exécutez `bmad-generate-project-context` pour l'auto-générer à partir de votre architecture ou de
-  votre codebase
+- **Manuellement** — Créez `_bmad-output/project-context.md` avec votre stack technique et vos règles d’implémentation
+- **Générez-le** — Exécutez `bmad-generate-project-context` pour l’auto-générer à partir de votre architecture ou de votre codebase
 
 [**En savoir plus sur project-context.md**](../explanation/project-context.md)
 
 ## Glossaire
 
-[^1]: FR / NFR (Functional / Non-Functional Requirement) : exigences décrivant respectivement **ce que le système doit
-faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité,
-fiabilité, ergonomie, etc.).
-[^2]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins
+[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins
 utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur
 ce qui doit être construit et pourquoi.
-[^3]: ADR (Architecture Decision Record) : document qui consigne une décision d’architecture, son contexte, les options
+[^2]: ADR (Architecture Decision Record) : document qui consigne une décision d’architecture, son contexte, les options
 envisagées, le choix retenu et ses conséquences, afin d’assurer la traçabilité et la compréhension des décisions
 techniques dans le temps.

docs/fr/roadmap.mdx

@@ -3,7 +3,7 @@ title: Feuille de route
 description: La suite pour BMad - Fonctionnalités, améliorations et contributions de la communauté
 ---
 
-# La Méthode BMad : Feuille de route publique
+# La Méthode BMad : Feuille de route publique
 
 La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voici ce sur quoi nous travaillons et ce qui arrive prochainement.
 
@@ -30,17 +30,17 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">📦</span>
       <h4>Skills Centralisés</h4>
-      <p>Installez une fois, utilisez partout. Partagez des skills entre projets sans l'encombrement de fichiers.</p>
+      <p>Installez une fois, utilisez partout. Partagez des skills entre projets sans l’encombrement de fichiers.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🔄</span>
       <h4>Skills Adaptatifs</h4>
-      <p>Des skills qui connaissent vos outils. Des variantes optimisées pour Claude, Codex, Kimi et OpenCode, et bien d'autres encore.</p>
+      <p>Des skills qui connaissent vos outils. Des variantes optimisées pour Claude, Codex, Kimi et OpenCode, et bien d’autres encore.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">📝</span>
       <h4>Blog BMad Team Pros</h4>
-      <p>Guides, articles et perspectives de l'équipe. Lancement prochainement.</p>
+      <p>Guides, articles et perspectives de l’équipe. Lancement prochainement.</p>
     </div>
   </div>
 
@@ -60,12 +60,12 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🚀</span>
       <h4>Optimisation Phases 1-3</h4>
-      <p>Planification éclair avec collecte de contexte par sous-agents. Le mode YOLO rencontre l'excellence guidée.</p>
+      <p>Planification éclair avec collecte de contexte par sous-agents. Le mode YOLO rencontre l’excellence guidée.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🌐</span>
-      <h4>Prêt pour l'Entreprise</h4>
-      <p>SSO, journaux d'audit, espaces de travail d'équipe. Toutes les choses ennuyantes qui feront dire oui aux entreprises.</p>
+      <h4>Prêt pour l’Entreprise</h4>
+      <p>SSO, journaux d’audit, espaces de travail d’équipe. Toutes les choses ennuyantes qui feront dire oui aux entreprises.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">💎</span>
@@ -75,7 +75,7 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">⚡</span>
       <h4>Automatisation de la Boucle de Développement</h4>
-      <p>Pilote automatique optionnel pour le développement. Laissez l'IA gérer le flux tout en maintenant une qualité optimale.</p>
+      <p>Pilote automatique optionnel pour le développement. Laissez l’IA gérer le flux tout en maintenant une qualité optimale.</p>
     </div>
   </div>
 
@@ -85,12 +85,12 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🎙️</span>
       <h4>Le Podcast de la Méthode BMad</h4>
-      <p>Conversations sur le développement natif IA. Lancement le 1er mars 2026 !</p>
+      <p>Conversations sur le développement natif IA. Lancement le 1er mars 2026 !</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🎓</span>
       <h4>Le Master Class de la Méthode BMad</h4>
-      <p>Passez d'utilisateur à expert. Approfondissements dans chaque phase, chaque workflow, chaque secret.</p>
+      <p>Passez d’utilisateur à expert. Approfondissements dans chaque phase, chaque workflow, chaque secret.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🏗️</span>
@@ -100,17 +100,17 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">⚡</span>
       <h4>BMad Prototype First</h4>
-      <p>De l'idée au prototype fonctionnel en une seule session. Créez l'application de vos rêves comme une œuvre d'art.</p>
+      <p>De l’idée au prototype fonctionnel en une seule session. Créez l’application de vos rêves comme une œuvre d’art.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🌴</span>
-      <h4>BMad BALM !</h4>
-      <p>Gestion de vie native IA. Tâches, habitudes, objectifs : votre copilote IA pour tout.</p>
+      <h4>BMad BALM !</h4>
+      <p>Gestion de vie native IA. Tâches, habitudes, objectifs : votre copilote IA pour tout.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🖥️</span>
       <h4>UI Officielle</h4>
-      <p>Une belle interface pour tout l'écosystème BMad. La puissance de la CLI, le polissage de l'interface graphique.</p>
+      <p>Une belle interface pour tout l’écosystème BMad. La puissance de la CLI, le polissage de l’interface graphique.</p>
     </div>
     <div class="roadmap-future-card">
       <span class="roadmap-emoji">🔒</span>
@@ -120,16 +120,16 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
   </div>
 
   <div style="text-align: center; margin-top: 3rem; padding: 2rem; background: var(--color-bg-card); border-radius: 12px; border: 1px solid var(--color-border);">
-    <h3 style="margin: 0 0 1rem;">Envie de contribuer ?</h3>
+    <h3 style="margin: 0 0 1rem;">Envie de contribuer ?</h3>
     <p style="color: var(--slate-color-400); margin: 0;">
-      Ce n'est qu'une liste partielle de ce qui est prévu. L'équipe Open Source BMad accueille les contributeurs !{" "}<br />
-      <a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Rejoignez-nous sur GitHub</a> pour aider à façonner l'avenir du développement propulsé par l'IA.
+      Ce n’est qu’une liste partielle de ce qui est prévu. L’équipe Open Source BMad accueille les contributeurs !{" "}<br />
+      <a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Rejoignez-nous sur GitHub</a> pour aider à façonner l’avenir du développement propulsé par l’IA.
     </p>
     <p style="color: var(--slate-color-400); margin: 1.5rem 0 0;">
-      Vous aimez ce que nous construisons ? Nous apprécions le soutien ponctuel et mensuel sur{" "}<a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">Buy Me a Coffee</a>.
+      Vous aimez ce que nous construisons ? Nous apprécions le soutien ponctuel et mensuel sur{" "}<a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">Buy Me a Coffee</a>.
     </p>
     <p style="color: var(--slate-color-400); margin: 1rem 0 0;">
-      Pour les parrainages d'entreprise, les demandes de partenariat, les interventions, les formations ou les demandes médias :{" "}
+      Pour les parrainages d’entreprise, les demandes de partenariat, les interventions, les formations ou les demandes médias :{" "}
       <a href="mailto:contact@bmadcode.com" style="color: var(--color-in-progress);">contact@bmadcode.com</a>
     </p>
   </div>

docs/fr/tutorials/getting-started.md

@@ -1,90 +1,91 @@
 ---
 title: "Premiers pas"
-description: Installer BMad et construire votre premier projet
+description: Installer BMad et développer votre premier projet
 ---
 
-Construisez des logiciels plus rapidement en utilisant des workflows propulsés par l'IA avec des agents spécialisés qui vous guident à travers la planification, l'architecture et l'implémentation.
+Accélérez le développement de vos applications grâce à des workflows alimentés par l’IA et des agents spécialisés qui vous guident dans la planification, l’architecture et l’implémentation.
 
 ## Ce que vous allez apprendre
 
 - Installer et initialiser la méthode BMad pour un nouveau projet
 - Utiliser **BMad-Help** — votre guide intelligent qui sait quoi faire ensuite
 - Choisir la bonne voie de planification selon la taille de votre projet
-- Progresser à travers les phases, des exigences au code fonctionnel
+- Progresser dans les phases, de la définition des exigences au code fonctionnel
 - Utiliser efficacement les agents et les workflows
 
 :::note[Prérequis]
-- **Node.js 20.12+** — Requis pour l'installateur
-- **Git** — Recommandé pour le contrôle de version
-- **IDE IA** — Claude Code, Cursor, ou similaire
-- **Une idée de projet** — Même simple, elle fonctionne pour apprendre
+- **Node.js 20.12+** — Nécessaire pour l’installation
+- **Git** — Recommandé pour la gestion de versions
+- **IDE avec IA intégrée** — Claude Code, Cursor ou équivalent
+- **Une idée de projet** — Même simple, elle fera l’affaire pour commencer
 :::
 
-:::tip[Le chemin le plus simple]
+:::tip[Le chemin le plus rapide]
 **Installer** → `npx bmad-method install`
 **Demander** → `bmad-help que dois-je faire en premier ?`
-**Construire** → Laissez BMad-Help vous guider workflow par workflow
+**Développez** → Laissez BMad-Help vous guider, workflow par workflow
 :::
 
-## Découvrez BMad-Help : votre guide intelligent
+## Découvrez BMad-Help : votre guide intelligent
 
-**BMad-Help est le moyen le plus rapide de démarrer avec BMad.** Vous n'avez pas besoin de mémoriser les workflows ou les phases — posez simplement la question, et BMad-Help va :
+**BMad-Help est le moyen le plus rapide de démarrer avec BMad.** Pas besoin de mémoriser les workflows ou les phases — posez simplement votre question et BMad-Help saura :
 
 - **Inspecter votre projet** pour voir ce qui a déjà été fait
-- **Vous montrer vos options** en fonction des modules que vous avez installés
-- **Recommander la prochaine étape** — y compris la première tâche obligatoire
-- **Répondre aux questions** comme « J'ai une idée de SaaS, par où commencer ? »
+- **Vous présenter vos options** en fonction des modules installés
+- **Vous recommander la prochaine étape** — y compris la première tâche obligatoire
+- **Répondre à vos questions**, par exemple : « J’ai une idée de SaaS, par où commencer ? »
 
 ### Comment utiliser BMad-Help
 
-Exécutez-le dans votre IDE avec IA en invoquant la skill :
+Dans votre IDE IA, invoquez le skill :
 
 ```
 bmad-help
 ```
 
-Ou combinez-le avec une question pour obtenir des conseils adaptés au contexte :
+Ou accompagnez-le d’une question pour obtenir des conseils contextualisés :
 
 ```
 bmad-help J'ai une idée de produit SaaS, je connais déjà toutes les fonctionnalités que je veux. Par où dois-je commencer ?
 ```
 
-BMad-Help répondra avec :
+BMad-Help vous indiquera :
+
 - Ce qui est recommandé pour votre situation
 - Quelle est la première tâche obligatoire
 - À quoi ressemble le reste du processus
 
-### Il alimente aussi les workflows
+### Il intervient aussi dans les workflows
 
-BMad-Help ne se contente pas de répondre aux questions — **il s'exécute automatiquement à la fin de chaque workflow** pour vous dire exactement quoi faire ensuite. Pas de devinettes, pas de recherche dans la documentation — juste des conseils clairs sur le prochain workflow requis.
+BMad-Help ne se contente pas de répondre aux questions — **il se lance automatiquement à la fin de chaque workflow** pour vous indiquer exactement la suite. Finies les devinettes et les recherches dans la doc : vous recevez des instructions claires sur le prochain workflow à exécuter.
 
 :::tip[Commencez ici]
-Après avoir installé BMad, invoquez immédiatement la skill `bmad-help`. Elle détectera les modules que vous avez installés et vous guidera vers le bon point de départ pour votre projet.
+Après avoir installé BMad, invoquez immédiatement le skill `bmad-help`. Il détectera les modules que vous avez installés et vous orientera vers le bon point de départ pour votre projet.
 :::
 
 ## Comprendre BMad
 
-BMad vous aide à construire des logiciels grâce à des workflows guidés avec des agents IA spécialisés. Le processus suit quatre phases :
+BMad vous aide à développer des logiciels grâce à des workflows guidés par des agents IA spécialisés. Le processus s’articule en quatre phases :
 
 | Phase | Nom            | Ce qui se passe                                                |
 |-------|----------------|----------------------------------------------------------------|
-| 1     | Analyse        | Brainstorming, recherche, product brief ou PRFAQ *(optionnel)*          |
-| 2     | Planification  | Créer les exigences (PRD[^1] ou spécification technique)       |
-| 3     | Solutioning    | Concevoir l'architecture *(BMad Method/Enterprise uniquement)* |
-| 4     | Implémentation | Construire epic[^2] par epic, story[^3] par story              |
+| 1     | Analyse        | Brainstorming, recherche, product brief ou PRFAQ _(optionnel)_ |
+| 2     | Planification  | Définir les exigences (PRD[^1] ou spécification technique)     |
+| 3     | Solutioning    | Concevoir l’architecture _(BMad Method/Enterprise uniquement)_ |
+| 4     | Implémentation | Développer epic[^2] par epic, story[^3] par story              |
 
-**[Ouvrir la carte des workflows](../reference/workflow-map.md)** pour explorer les phases, les workflows et la gestion du contexte.
+**[Ouvrez la carte des workflows](../reference/workflow-map.md)** pour explorer les phases, les workflows et la gestion du contexte.
 
 Selon la complexité de votre projet, BMad propose trois voies de planification :
 
 | Voie             | Idéal pour                                                                   | Documents créés                        |
 |------------------|------------------------------------------------------------------------------|----------------------------------------|
 | **Quick Dev**    | Corrections de bugs, fonctionnalités simples, périmètre clair (1-15 stories) | Spécification technique uniquement     |
-| **méthode BMad** | Produits, plateformes, fonctionnalités complexes (10-50+ stories)            | PRD + Architecture + UX[^4]            |
+| **BMad Method**  | Produits, plateformes, fonctionnalités complexes (10-50+ stories)            | PRD + Architecture + UX[^4]            |
 | **Enterprise**   | Conformité, systèmes multi-tenant[^5] (30+ stories)                          | PRD + Architecture + Security + DevOps |
 
 :::note
-Les comptes de stories sont indicatifs, pas des définitions. Choisissez votre voie en fonction des besoins de planification, pas du calcul des stories.
+Le nombre de stories est indicatif, pas strictement défini. Choisissez votre voie en fonction de vos besoins de planification, pas d’un simple décompte de stories.
 :::
 
 ## Installation
@@ -95,13 +96,14 @@ Ouvrez un terminal dans le répertoire de votre projet et exécutez :
 npx bmad-method install
 ```
 
-Si vous souhaitez la version préliminaire la plus récente au lieu du canal de release par défaut, utilisez `npx bmad-method@next install`.
+Si vous préférez la dernière version préliminaire au lieu du canal de publication par défaut, utilisez `npx bmad-method@next install`.
 
-Lorsque vous êtes invité à sélectionner des modules, choisissez **méthode BMad**.
+À l’invite de sélection des modules, choisissez **BMad Method**.
+
+L’installateur crée deux dossiers :
 
-L'installateur crée deux dossiers :
 - `_bmad/` — agents, workflows, tâches et configuration
-- `_bmad-output/` — vide pour l'instant, mais c'est là que vos artefacts seront enregistrés
+- `_bmad-output/` — vide pour le moment, mais c’est là que seront enregistrés vos artefacts
 
 :::tip[Votre prochaine étape]
 Ouvrez votre IDE avec IA dans le dossier du projet et exécutez :
@@ -110,108 +112,120 @@ Ouvrez votre IDE avec IA dans le dossier du projet et exécutez :
 bmad-help
 ```
 
-BMad-Help détectera ce que vous avez accompli et recommandera exactement quoi faire ensuite. Vous pouvez aussi lui poser des questions comme « Quelles sont mes options ? » ou « J'ai une idée de SaaS, par où devrais-je commencer ? »
+BMad-Help détectera ce que vous avez déjà accompli et vous recommandera exactement la suite. Vous pouvez aussi lui poser des questions comme « Quelles sont mes options ? » ou « J’ai une idée de SaaS, par où devrais-je commencer ? »
 :::
 
 :::note[Comment charger les agents et exécuter les workflows]
-Chaque workflow possède une **skill** que vous invoquez par nom dans votre IDE (par ex., `bmad-create-prd`). Votre outil IA reconnaîtra le nom `bmad-*` et l'exécutera — vous n'avez pas besoin de charger les agents séparément. Vous pouvez aussi invoquer directement une skill d'agent pour une conversation générale (par ex., `bmad-agent-pm` pour l'agent PM).
+Chaque workflow possède une **skill** que vous invoquez par son nom dans votre IDE (par ex. `bmad-prd`). Votre outil IA reconnaîtra le nom `bmad-*` et l’exécutera — pas besoin de charger les agents séparément. Vous pouvez aussi invoquer directement une skill d’agent pour une conversation générale (par ex. `bmad-agent-pm` pour l’agent PM).
 :::
 
 :::caution[Nouveaux chats]
-Démarrez toujours un nouveau chat pour chaque workflow. Cela évite que les limitations de contexte ne causent des problèmes.
+Démarrez toujours un nouveau chat pour chaque workflow. Cela évite les problèmes liés aux limites de contexte de l’IA.
 :::
 
-## Étape 1 : Créer votre plan
+## Étape 1 : Élaborer votre plan
 
-Travaillez à travers les phases 1-3. **Utilisez de nouveaux chats pour chaque workflow.**
+Parcourez les phases 1 à 3. **Utilisez un nouveau chat pour chaque workflow.**
 
-:::tip[Contexte de projet (Optionnel)]
-Avant de commencer, envisagez de créer `project-context.md` pour documenter vos préférences techniques et règles d'implémentation. Cela garantit que tous les agents IA suivent vos conventions tout au long du projet.
+:::tip[Contexte projet (optionnel)]
+Avant de commencer, pensez à créer `project-context.md` pour documenter vos préférences techniques et vos règles d’implémentation. Ainsi, tous les agents IA respecteront vos conventions tout au long du projet.
 
-Créez-le manuellement dans `_bmad-output/project-context.md` ou générez-le après l'architecture en utilisant `bmad-generate-project-context`. [En savoir plus](../explanation/project-context.md).
+Créez-le manuellement à l’emplacement `_bmad-output/project-context.md`, ou générez-le après l’architecture avec `bmad-generate-project-context`. [En savoir plus](../explanation/project-context.md).
 :::
 
-### Phase 1 : Analyse (Optionnel)
+### Phase 1 : Analyse (optionnelle)
+
+Tous les workflows de cette phase sont optionnels. [**Vous ne savez pas lequel choisir ?**](../explanation/analysis-phase.md)
 
-Tous les workflows de cette phase sont optionnels. [**Pas sûr de quel outil utiliser ?**](../explanation/analysis-phase.md)
 - **brainstorming** (`bmad-brainstorming`) — Idéation guidée
 - **research** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Recherche marché, domaine et technique
-- **product-brief** (`bmad-product-brief`) — Document de base recommandé lorsque votre concept est clair
-- **prfaq** (`bmad-prfaq`) — Défi Working Backwards pour éprouver et forger votre concept produit
+- **product-brief** (`bmad-product-brief`) — Document fondateur recommandé une fois votre concept bien défini
+- **prfaq** (`bmad-prfaq`) — Exercice Working Backwards pour tester et affiner votre concept produit
 
-### Phase 2 : Planification (Requis)
+### Phase 2 : Planification (requise)
 
-**Pour les voies BMad Method et Enterprise :**
-1. Invoquez l'**agent PM** (`bmad-agent-pm`) dans un nouveau chat
-2. Exécutez le workflow `bmad-create-prd` (`bmad-create-prd`)
-3. Sortie : `PRD.md`
+**Pour les voies BMad Method et Enterprise :**
 
-**Pour la voie Quick Dev :**
-- Exécutez `bmad-quick-dev` — il gère la planification et l'implémentation dans un seul workflow, passez directement à l'implémentation
+1. Exécutez `bmad-prd` dans un nouveau chat — précisez votre intention (Create / Update / Validate) ou laissez le skill vous la demander
+2. Résultat : `prd.md`, `addendum.md`, `decision-log.md`
 
-:::note[Design UX (Optionnel)]
-Si votre projet a une interface utilisateur, invoquez l'**agent Designer UX** (`bmad-agent-ux-designer`) et exécutez le workflow de design UX (`bmad-ux`) après avoir créé votre PRD.
+:::note[Intentions de `bmad-prd`]
+
+- **Create** — exploration guidée à partir de zéro ; le skill nomme le dossier de travail et vous accompagne jusqu’à l’obtention d’un PRD dont vous serez fier
+- **Update** — pointez vers un PRD existant et un changement à apporter ; le skill met en évidence les conflits avant d’appliquer les modifications
+- **Validate** — critiquez un PRD finalisé à l’aide d’une liste de contrôle et générez un rapport HTML des constatations
 :::
 
-### Phase 3 : Solutioning (méthode BMad/Enterprise)
 
-**Créer l'Architecture**
+**Pour la voie Quick Dev :**
+
+- Exécutez `bmad-quick-dev` — ce workflow couvre la planification et l’implémentation en une seule fois ; vous pouvez passer directement à l’implémentation
+
+:::note[Design UX (optionnel)]
+Si votre projet comporte une interface utilisateur, invoquez l'**agent UX Designer** (`bmad-agent-ux-designer`) et lancez le workflow de design UX (`bmad-ux`) après avoir créé votre PRD.
+:::
+
+### Phase 3 : Solutioning (BMad Method/Enterprise)
+
+**Créer l’architecture**
+
 1. Invoquez l'**agent Architecte** (`bmad-agent-architect`) dans un nouveau chat
 2. Exécutez `bmad-create-architecture` (`bmad-create-architecture`)
-3. Sortie : Document d'architecture avec les décisions techniques
+3. Résultat : document d’architecture avec les décisions techniques
 
-**Créer les Epics et Stories**
+**Créer les epics et les stories**
 
 :::tip[Amélioration V6]
-Les epics et stories sont maintenant créés *après* l'architecture. Cela produit des stories de meilleure qualité car les décisions d'architecture (base de données, patterns d'API, pile technologique) affectent directement la façon dont le travail doit être décomposé.
+Les epics et stories sont désormais créés *après* l’architecture. Cela produit des stories de meilleure qualité, car les décisions d’architecture (choix de la base de données, patterns d’API, pile technologique) influencent directement la façon dont le travail doit être découpé.
 :::
 
 1. Invoquez l'**agent PM** (`bmad-agent-pm`) dans un nouveau chat
 2. Exécutez `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
-3. Le workflow utilise à la fois le PRD et l'Architecture pour créer des stories techniquement éclairées
+3. Le workflow s’appuie sur le PRD et l’architecture pour créer des stories techniquement fondées
+
+**Vérification de la préparation à l’implémentation** *(fortement recommandée)*
 
-**Vérification de préparation à l'implémentation** *(Hautement recommandé)*
 1. Invoquez l'**agent Architecte** (`bmad-agent-architect`) dans un nouveau chat
 2. Exécutez `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
-3. Valide la cohérence entre tous les documents de planification
+3. Valide la cohérence de l’ensemble des documents de planification
 
-## Étape 2 : Construire votre projet
+## Étape 2 : Développer votre projet
 
-Une fois la planification terminée, passez à l'implémentation. **Chaque workflow doit s'exécuter dans un nouveau chat.**
+Une fois la planification terminée, passez à l’implémentation. **Chaque workflow doit être exécuté dans un nouveau chat.**
 
 ### Initialiser la planification de sprint
 
-Invoquez **l’agent Développeur** (`bmad-agent-dev`) et lancez `bmad-sprint-planning`. Cela crée `sprint-status.yaml` pour suivre tous les epics et stories.
+Invoquez l'**agent Développeur** (`bmad-agent-dev`) et exécutez `bmad-sprint-planning` (`bmad-sprint-planning`). Cette commande crée `sprint-status.yaml` pour suivre tous les epics et stories.
 
-### Le cycle de construction
+### Le cycle de développement
 
-Pour chaque story, répétez ce cycle avec de nouveaux chats :
+Pour chaque story, répétez ce cycle dans de nouveaux chats :
 
-| Étape | AGENT | Workflow            | Commande            | Objectif                             |
+| Étape | Agent | Workflow            | Commande            | Objectif                             |
 |-------|-------|---------------------|---------------------|--------------------------------------|
-| 1     | DEV   | `bmad-create-story` | `bmad-create-story` | Créer le fichier story depuis l'epic |
+| 1     | DEV   | `bmad-create-story` | `bmad-create-story` | Créer le fichier story depuis l’epic |
 | 2     | DEV   | `bmad-dev-story`    | `bmad-dev-story`    | Implémenter la story                 |
-| 3     | DEV   | `bmad-code-review`  | `bmad-code-review`  | Validation de qualité *(recommandé)* |
+| 3     | DEV   | `bmad-code-review`  | `bmad-code-review`  | Validation qualité *(recommandée)*   |
 
-Après avoir terminé toutes les stories d'un epic, invoquez **l’agent Développeur** (`bmad-agent-dev`), et exécutez `bmad-retrospective`.
+Après avoir terminé toutes les stories d’un epic, invoquez l'**agent Développeur** (`bmad-agent-dev`) et exécutez `bmad-retrospective` (`bmad-retrospective`).
 
 ## Ce que vous avez accompli
 
-Vous avez appris les fondamentaux de la construction avec BMad :
+Vous maîtrisez maintenant les bases du développement avec BMad :
 
-- Installé BMad et configuré pour votre IDE
-- Initialisé un projet avec votre voie de planification choisie
-- Créé des documents de planification (PRD, Architecture, Epics & Stories)
-- Compris le cycle de construction pour l'implémentation
+- Installation et configuration de BMad pour votre IDE
+- Initialisation d’un projet avec la voie de planification choisie
+- Création des documents de planification (PRD, Architecture, Epics & Stories)
+- Compréhension du cycle de développement pour l’implémentation
 
-Votre projet contient maintenant :
+Votre projet contient désormais :
 
 ```text
 your-project/
 ├── _bmad/                                   # Configuration BMad
 ├── _bmad-output/
 │   ├── planning-artifacts/
-│   │   ├── PRD.md                           # Votre document d'exigences
+│   │   ├── PRD.md                           # Document d'exigences
 │   │   ├── architecture.md                  # Décisions techniques
 │   │   └── epics/                           # Fichiers epic et story
 │   ├── implementation-artifacts/
@@ -224,12 +238,12 @@ your-project/
 
 | Workflow                              | Commande                              | Agent     | Objectif                                                        |
 |---------------------------------------|---------------------------------------|-----------|-----------------------------------------------------------------|
-| **`bmad-help`** ⭐                    | `bmad-help`                           | Tous      | **Votre guide intelligent — posez n'importe quelle question !** |
-| `bmad-create-prd`                     | `bmad-create-prd`                     | PM        | Créer le document d'exigences produit                           |
-| `bmad-create-architecture`            | `bmad-create-architecture`            | Architect | Créer le document d'architecture                                |
+| **`bmad-help`** ⭐                    | `bmad-help`                           | Tous      | **Votre guide intelligent — posez n’importe quelle question !**  |
+| `bmad-prd`                            | `bmad-prd`                            | Tous      | Créer, mettre à jour ou valider un PRD                          |
+| `bmad-create-architecture`            | `bmad-create-architecture`            | Architect | Créer le document d’architecture                                |
 | `bmad-generate-project-context`       | `bmad-generate-project-context`       | Analyst   | Créer le fichier de contexte projet                             |
 | `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`       | PM        | Décomposer le PRD en epics                                      |
-| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Valider la cohérence de planification                           |
+| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Valider la cohérence de la planification                        |
 | `bmad-sprint-planning`                | `bmad-sprint-planning`                | DEV       | Initialiser le suivi de sprint                                  |
 | `bmad-create-story`                   | `bmad-create-story`                   | DEV       | Créer un fichier story                                          |
 | `bmad-dev-story`                      | `bmad-dev-story`                      | DEV       | Implémenter une story                                           |
@@ -237,31 +251,32 @@ your-project/
 
 ## Questions fréquentes
 
-**Ai-je toujours besoin d'une architecture ?**
-Uniquement pour les voies méthode BMad et Enterprise. Quick Dev passe directement de la spécification technique (spec) à l'implémentation.
+**Ai-je toujours besoin d’une architecture ?**
+Seulement pour les voies BMad Method et Enterprise. Quick Dev passe directement de la spécification à l’implémentation.
 
-**Puis-je modifier mon plan plus tard ?**
-Oui. Utilisez `bmad-correct-course` pour gérer les changements de périmètre en cours d’implémentation.
+**Puis-je modifier mon plan en cours de route ?**
+Oui. Le workflow `bmad-correct-course` gère les changements de périmètre en cours d’implémentation.
 
-**Et si je veux d'abord faire du brainstorming ?**
-Invoquez l'agent Analyst (`bmad-agent-analyst`) et exécutez `bmad-brainstorming` (`bmad-brainstorming`) avant de commencer votre PRD.
+**Et si je veux d’abord brainstormer ?**
+Invoquez l’agent Analyste (`bmad-agent-analyst`) et exécutez `bmad-brainstorming` (`bmad-brainstorming`) avant de commencer votre PRD.
 
-**Dois-je suivre un ordre strict ?**
-Pas strictement. Une fois que vous maîtrisez le flux, vous pouvez exécuter les workflows directement en utilisant la référence rapide ci-dessus.
+**Dois-je suivre un ordre strict ?**
+Pas strictement. Une fois le flux maîtrisé, vous pouvez exécuter les workflows directement en vous référant au tableau ci-dessus.
 
-## Obtenir de l'aide
+## Obtenir de l’aide
 
-:::tip[Premier arrêt : BMad-Help]
-**Invoquez `bmad-help` à tout moment** — c'est le moyen le plus rapide de se débloquer. Posez n'importe quelle question :
-- « Que dois-je faire après l'installation ? »
-- « Je suis bloqué sur le workflow X »
-- « Quelles sont mes options pour Y ? »
-- « Montre-moi ce qui a été fait jusqu'ici »
+:::tip[Premier réflexe : BMad-Help]
+**Invoquez `bmad-help` à tout moment** — c’est le moyen le plus rapide de vous débloquer. Posez-lui n’importe quelle question :
 
-BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous dit exactement quoi faire ensuite.
+- « Que dois-je faire après l’installation ? »
+- « Je suis bloqué sur le workflow X »
+- « Quelles sont mes options pour Y ? »
+- « Montre-moi ce qui a été fait jusqu’ici »
+
+BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous indique exactement la prochaine étape.
 :::
 
-- **Pendant les workflows** — Les agents vous guident avec des questions et des explications
+- **Pendant les workflows** — Les agents vous guident à l’aide de questions et d’explications
 - **Communauté** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
 
 ## Points clés à retenir
@@ -269,16 +284,16 @@ BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous dit
 :::tip[Retenez ceci]
 - **Commencez par `bmad-help`** — Votre guide intelligent qui connaît votre projet et vos options
 - **Utilisez toujours de nouveaux chats** — Démarrez un nouveau chat pour chaque workflow
-- **La voie compte** — Quick Dev utilise `bmad-quick-dev` ; La méthode BMad/Enterprise nécessitent PRD et architecture
-- **BMad-Help s'exécute automatiquement** — Chaque workflow se termine par des conseils sur la prochaine étape
+- **Le choix de la voie est important** — Quick Dev utilise `bmad-quick-dev` ; BMad Method/Enterprise nécessitent un PRD et une architecture
+- **BMad-Help se lance automatiquement** — Chaque workflow se termine par des conseils sur la prochaine étape
 :::
 
-Prêt à commencer ? Installez BMad, invoquez `bmad-help`, et laissez votre guide intelligent vous montrer le chemin.
+Prêt à commencer ? Installez BMad, invoquez `bmad-help`, et laissez votre guide intelligent vous accompagner.
 
 ## Glossaire
 
-[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
+[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
 [^2]: Epic : grand ensemble de fonctionnalités ou de travaux qui peut être décomposé en plusieurs user stories.
-[^3]: Story (User Story) : description courte et simple d'une fonctionnalité du point de vue de l'utilisateur ou du client. Elle représente une unité de travail implémentable en un court délai.
-[^4]: UX (User Experience) : expérience utilisateur, englobant l'ensemble des interactions et perceptions d'un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d'utilisation.
-[^5]: Multi-tenant : architecture logicielle où une seule instance de l'application sert plusieurs clients (tenants) tout en maintenant leurs données isolées et sécurisées les unes des autres.
+[^3]: Story (User Story) : description courte et simple d’une fonctionnalité du point de vue de l’utilisateur ou du client. Elle représente une unité de travail implémentable en un court délai.
+[^4]: UX (User Experience) : expérience utilisateur, englobant l’ensemble des interactions et perceptions d’un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, des comportements et du contexte d’utilisation.
+[^5]: Multi-tenant : architecture logicielle où une seule instance de l’application sert plusieurs clients (tenants) tout en maintenant leurs données isolées et sécurisées les unes des autres.

docs/ko-kr/404.md

@@ -0,0 +1,8 @@
+---
+title: 페이지를 찾을 수 없음
+template: splash
+---
+
+찾으려는 페이지가 없거나 이동되었습니다.
+
+[홈으로 돌아가기](./index.md)

docs/ko-kr/_STYLE_GUIDE.md

@@ -0,0 +1,370 @@
+---
+title: "문서 스타일 가이드"
+description: Google 스타일과 Diataxis 구조를 바탕으로 한 프로젝트별 문서 작성 규칙
+---
+
+이 프로젝트는 [Google Developer 문서 스타일 가이드](https://developers.google.com/style)를 따르고 [Diataxis](https://diataxis.fr/)로 콘텐츠를 구조화합니다. 아래에는 프로젝트별 규칙만 정리합니다.
+
+## 프로젝트별 규칙
+
+| 규칙 | 사양 |
+| --- | --- |
+| 가로 구분선(`---`) 사용 금지 | 읽기 흐름을 끊습니다 |
+| `####` 헤더 사용 금지 | 대신 굵은 글씨나 알림 상자를 사용합니다 |
+| "관련 항목" 또는 "다음:" 섹션 금지 | 사이드바가 탐색을 담당합니다 |
+| 깊게 중첩된 목록 금지 | 섹션으로 나누세요 |
+| 코드가 아닌 내용에 코드 블록 사용 금지 | 대화 예시는 알림 상자를 사용합니다 |
+| 콜아웃용 굵은 문단 금지 | 대신 알림 상자를 사용합니다 |
+| 섹션당 알림 상자 1-2개까지 | 튜토리얼은 큰 섹션당 3-4개까지 허용합니다 |
+| 표 셀 / 목록 항목 | 최대 1-2문장 |
+| 헤더 예산 | 문서당 `##` 8-12개, 섹션당 `###` 2-3개 |
+
+## 알림 상자(Starlight 문법)
+
+```md
+:::tip[제목]
+단축키, 모범 사례
+:::
+
+:::note[제목]
+맥락, 정의, 예시, 필수 조건
+:::
+
+:::caution[제목]
+주의 사항, 잠재적 문제
+:::
+
+:::danger[제목]
+데이터 손실, 보안 문제 같은 중대한 경고에만 사용
+:::
+```
+
+### 표준 용도
+
+| 알림 상자 | 사용처 |
+| --- | --- |
+| `:::note[필수 조건]` | 시작 전 필요한 의존성 |
+| `:::tip[빠른 경로]` | 문서 상단의 짧은 요약 |
+| `:::caution[중요]` | 중요한 주의 사항 |
+| `:::note[예시]` | 명령/응답 예시 |
+
+## 표준 표 형식
+
+**단계:**
+
+```md
+| 단계 | 이름 | 내용 |
+| --- | --- | --- |
+| 1 | 분석 | 브레인스토밍, 리서치 *(선택 사항)* |
+| 2 | 계획 | 요구사항 - PRD 또는 사양 *(필수)* |
+```
+
+**스킬:**
+
+```md
+| 스킬 | 에이전트 | 목적 |
+| --- | --- | --- |
+| `bmad-brainstorming` | 분석가 | 새 프로젝트 브레인스토밍 |
+| `bmad-create-prd` | PM | 제품 요구사항 문서 생성 |
+```
+
+## 폴더 구조 블록
+
+"달성한 것" 섹션에서는 다음처럼 표시합니다.
+
+````md
+```
+your-project/
+├── _bmad/                                   # BMad 설정
+├── _bmad-output/
+│   ├── planning-artifacts/
+│   │   └── PRD.md                           # 요구사항 문서
+│   ├── implementation-artifacts/
+│   └── project-context.md                   # 구현 규칙 (선택 사항)
+└── ...
+```
+````
+
+## 튜토리얼 구조
+
+```text
+1. 제목 + 후킹 문장(결과를 설명하는 1-2문장)
+2. 버전/모듈 안내(정보 또는 경고 알림 상자, 선택)
+3. 배울 내용(결과 중심 글머리표 목록)
+4. 필수 조건(정보 알림 상자)
+5. 빠른 경로(tip 알림 상자 - 짧은 요약)
+6. [주제] 이해하기(단계 전 맥락 - 단계/에이전트 표)
+7. 설치(선택)
+8. 1단계: [첫 번째 주요 작업]
+9. 2단계: [두 번째 주요 작업]
+10. 3단계: [세 번째 주요 작업]
+11. 달성한 것(요약 + 폴더 구조)
+12. 빠른 참조(스킬 표)
+13. 자주 묻는 질문(FAQ 형식)
+14. 도움 받기(커뮤니티 링크)
+15. 핵심 요약(tip 알림 상자)
+```
+
+### 튜토리얼 체크리스트
+
+- [ ] 후킹 문장이 결과를 1-2문장으로 설명합니다
+- [ ] "배울 내용" 섹션이 있습니다
+- [ ] 필수 조건이 알림 상자에 있습니다
+- [ ] 상단에 빠른 경로 요약 알림 상자가 있습니다
+- [ ] 단계, 스킬, 에이전트를 표로 제시합니다
+- [ ] "달성한 것" 섹션이 있습니다
+- [ ] 빠른 참조 표가 있습니다
+- [ ] 자주 묻는 질문 섹션이 있습니다
+- [ ] 도움 받기 섹션이 있습니다
+- [ ] 마지막에 핵심 요약 알림 상자가 있습니다
+
+## 사용 가이드 구조
+
+```text
+1. 제목 + 후킹 문장("`X` 워크플로를 사용해..." 한 문장)
+2. 사용 시점(3-5개 글머리표 목록)
+3. 건너뛸 시점(선택)
+4. 필수 조건(note 알림 상자)
+5. 단계(번호가 붙은 ### 하위 섹션)
+6. 얻는 결과(생성되는 산출물)
+7. 예시(선택)
+8. 팁(선택)
+9. 다음 단계(선택)
+```
+
+### 사용 가이드 체크리스트
+
+- [ ] 후킹 문장이 "`X` 워크플로를 사용해..."로 시작합니다
+- [ ] "사용 시점"에 3-5개 글머리표가 있습니다
+- [ ] 필수 조건이 나열되어 있습니다
+- [ ] 단계는 동작 동사로 시작하는 번호가 붙은 `###` 하위 섹션입니다
+- [ ] "얻는 결과"가 산출물을 설명합니다
+
+## 개념 설명 구조
+
+### 유형
+
+| 유형 | 예시 |
+| --- | --- |
+| **인덱스/랜딩** | `core-concepts/index.md` |
+| **개념** | `what-are-agents.md` |
+| **기능** | `quick-dev.md` |
+| **철학** | `why-solutioning-matters.md` |
+| **FAQ** | `established-projects-faq.md` |
+
+### 일반 템플릿
+
+```text
+1. 제목 + 후킹 문장(1-2문장)
+2. 개요/정의(무엇이며 왜 중요한지)
+3. 핵심 개념(### 하위 섹션)
+4. 비교 표(선택)
+5. 사용할 때 / 사용하지 않을 때(선택)
+6. 다이어그램(선택 - mermaid, 문서당 최대 1개)
+7. 다음 단계(선택)
+```
+
+### 인덱스/랜딩 페이지
+
+```text
+1. 제목 + 후킹 문장(한 문장)
+2. 콘텐츠 표(설명이 있는 링크)
+3. 시작하기(번호 목록)
+4. 경로 선택(선택 - 의사결정 트리)
+```
+
+### 개념 설명 문서
+
+```text
+1. 제목 + 후킹 문장(무엇인지)
+2. 유형/범주(### 하위 섹션, 선택)
+3. 주요 차이 표
+4. 구성 요소/부분
+5. 무엇을 사용해야 하나요?
+6. 생성/커스터마이징(사용 가이드 링크)
+```
+
+### 기능 설명 문서
+
+```text
+1. 제목 + 후킹 문장(무엇을 하는지)
+2. 빠른 정보(선택 - "적합한 경우:", "소요 시간:")
+3. 사용할 때 / 사용하지 않을 때
+4. 작동 방식(mermaid 다이어그램 선택)
+5. 핵심 이점
+6. 비교 표(선택)
+7. 졸업/업그레이드 시점(선택)
+```
+
+### 철학/근거 문서
+
+```text
+1. 제목 + 후킹 문장(원칙)
+2. 문제
+3. 해결책
+4. 핵심 원칙(### 하위 섹션)
+5. 이점
+6. 적용 시점
+```
+
+### 개념 설명 체크리스트
+
+- [ ] 후킹 문장이 문서가 설명하는 내용을 말합니다
+- [ ] 스캔하기 쉬운 `##` 섹션으로 구성합니다
+- [ ] 3개 이상의 선택지가 있으면 비교 표를 사용합니다
+- [ ] 다이어그램에는 명확한 라벨이 있습니다
+- [ ] 절차적 질문에는 사용 가이드 링크를 제공합니다
+- [ ] 문서당 알림 상자는 최대 2-3개입니다
+
+## 참조 문서 구조
+
+### 유형
+
+| 유형 | 예시 |
+| --- | --- |
+| **인덱스/랜딩** | `workflows/index.md` |
+| **카탈로그** | `agents/index.md` |
+| **심층 설명** | `document-project.md` |
+| **설정** | `core-tasks.md` |
+| **용어집** | `glossary/index.md` |
+| **종합 가이드** | `bmgd-workflows.md` |
+
+### 참조 인덱스 페이지
+
+```text
+1. 제목 + 후킹 문장(한 문장)
+2. 콘텐츠 섹션(각 범주에 ## 사용)
+   - 링크와 설명이 있는 글머리표 목록
+```
+
+### 카탈로그 참조
+
+```text
+1. 제목 + 후킹 문장
+2. 항목(각 항목에 ## 사용)
+   - 짧은 설명(한 문장)
+   - **스킬:** 또는 **핵심 정보:** 형태의 평평한 목록
+3. 공통/공유 섹션(## 섹션, 선택)
+```
+
+### 항목 심층 참조
+
+```text
+1. 제목 + 후킹 문장(한 문장 목적)
+2. 빠른 정보(note 알림 상자, 선택)
+   - 모듈, 스킬, 입력, 출력 목록
+3. 목적/개요(## 섹션)
+4. 호출 방법(코드 블록)
+5. 핵심 섹션(각 측면에 ## 사용)
+   - 하위 선택지에는 ### 사용
+6. 참고/주의 사항(tip 또는 caution 알림 상자)
+```
+
+### 설정 참조
+
+```text
+1. 제목 + 후킹 문장
+2. 목차(항목이 4개 이상이면 점프 링크)
+3. 항목(각 설정/작업에 ## 사용)
+   - **굵은 요약** — 한 문장
+   - **사용 시점:** 글머리표 목록
+   - **작동 방식:** 번호 목록(최대 3-5개)
+   - **출력:** 예상 결과(선택)
+```
+
+### 종합 참조 가이드
+
+```text
+1. 제목 + 후킹 문장
+2. 개요(## 섹션)
+   - 구성을 보여주는 다이어그램 또는 표
+3. 주요 섹션(각 단계/범주에 ## 사용)
+   - 항목(각 항목에 ### 사용)
+   - 표준 필드: 스킬, 에이전트, 입력, 출력, 설명
+4. 다음 단계(선택)
+```
+
+### 참조 체크리스트
+
+- [ ] 후킹 문장이 문서가 참조하는 내용을 말합니다
+- [ ] 구조가 참조 유형에 맞습니다
+- [ ] 항목은 전체적으로 일관된 구조를 사용합니다
+- [ ] 구조화/비교 데이터에는 표를 사용합니다
+- [ ] 개념적 깊이가 필요한 곳에는 개념 설명 문서 링크를 둡니다
+- [ ] 알림 상자는 최대 1-2개입니다
+
+## 용어집 구조
+
+Starlight는 헤더에서 오른쪽 "이 페이지에서" 탐색을 생성합니다.
+
+- 범주는 `##` 헤더로 작성합니다. 오른쪽 탐색에 표시됩니다
+- 용어는 개별 헤더가 아니라 표 안의 간결한 행으로 작성합니다
+- 인라인 TOC는 사용하지 않습니다. 오른쪽 사이드바가 탐색을 담당합니다
+
+### 표 형식
+
+```md
+## 범주 이름
+
+| 용어 | 정의 |
+| --- | --- |
+| **에이전트** | 특정 전문성을 갖고 워크플로 전반에서 사용자를 안내하는 특화 AI 페르소나입니다. |
+| **워크플로** | 산출물을 만들기 위해 AI 에이전트 활동을 조율하는 여러 단계의 안내형 프로세스입니다. |
+```
+
+### 정의 규칙
+
+| 해야 할 것 | 하지 말 것 |
+| --- | --- |
+| 무엇인지 또는 무엇을 하는지로 시작합니다 | "이것은..." 또는 "이 용어는..."으로 시작합니다 |
+| 1-2문장으로 유지합니다 | 여러 문단으로 설명합니다 |
+| 셀 안의 용어명을 굵게 표시합니다 | 용어를 일반 텍스트로 둡니다 |
+
+### 컨텍스트 표시
+
+범위가 제한된 용어는 정의 시작에 이탤릭 컨텍스트를 추가합니다.
+
+- `*빠른 흐름 전용.*`
+- `*BMad Method/엔터프라이즈.*`
+- `*N단계.*`
+- `*BMGD.*`
+- `*기존 프로젝트.*`
+
+### 용어집 체크리스트
+
+- [ ] 용어는 개별 헤더가 아니라 표에 있습니다
+- [ ] 범주 안에서 용어를 사전순으로 정렬합니다
+- [ ] 정의는 1-2문장입니다
+- [ ] 컨텍스트 표시는 이탤릭입니다
+- [ ] 셀 안의 용어명은 굵게 표시합니다
+- [ ] "이것은..." 또는 "이 용어는..." 형태의 정의를 사용하지 않습니다
+
+## FAQ 섹션
+
+```md
+## 질문
+
+- [항상 아키텍처가 필요한가요?](#항상-아키텍처가-필요한가요)
+- [나중에 계획을 바꿀 수 있나요?](#나중에-계획을-바꿀-수-있나요)
+
+### 항상 아키텍처가 필요한가요?
+
+BMad Method와 엔터프라이즈 트랙에서만 필요합니다. 빠른 흐름은 구현으로 바로 넘어갑니다.
+
+### 나중에 계획을 바꿀 수 있나요?
+
+예. `bmad-correct-course` 워크플로가 구현 중 범위 변경을 처리합니다.
+
+**여기에 답이 없는 질문이 있나요?** [이슈를 열거나](...) [Discord](...)에서 물어보세요.
+```
+
+## 검증 명령
+
+문서 변경을 제출하기 전에 다음을 실행하세요.
+
+```bash
+npm run docs:fix-links            # 링크 형식 수정 미리보기
+npm run docs:fix-links -- --write # 수정 적용
+npm run docs:validate-links       # 링크 존재 여부 확인
+npm run docs:build                # 빌드 오류 없음 확인
+```

docs/ko-kr/explanation/advanced-elicitation.md

@@ -0,0 +1,49 @@
+---
+title: "고급 도출"
+description: 구조화된 추론 방법으로 LLM이 자신의 작업을 다시 생각하게 합니다
+sidebar:
+  order: 9
+---
+
+LLM이 방금 생성한 결과를 다시 검토하게 만드세요. 추론 방법을 선택하면 LLM이 그 방법을 자신의 출력에 적용하고, 사용자는 개선 사항을 유지할지 결정합니다.
+
+## 고급 도출이란?
+
+구조화된 두 번째 검토 단계입니다. AI에게 막연히 "다시 해봐" 또는 "더 좋게 만들어"라고 말하는 대신, 특정 추론 방법을 선택하고 AI가 그 렌즈를 통해 자신의 출력을 다시 살핍니다.
+
+이 차이는 중요합니다. 모호한 요청은 모호한 수정을 낳습니다. 이름 있는 방법은 특정한 검토 관점을 강제해 일반적인 재시도로는 놓칠 인사이트를 드러냅니다.
+
+## 사용 시점
+
+- 워크플로가 콘텐츠를 생성한 뒤 대안을 보고 싶을 때
+- 출력은 괜찮아 보이지만 더 깊이가 있을 것 같을 때
+- 가정을 스트레스 테스트하거나 약점을 찾고 싶을 때
+- 다시 생각하는 과정이 도움이 되는 중요도가 높은 콘텐츠일 때
+
+워크플로는 결정 지점에서 고급 도출을 제안합니다. LLM이 무언가를 생성한 뒤 실행할지 묻습니다.
+
+## 작동 방식
+
+1. LLM이 콘텐츠에 관련 있는 방법 5개를 제안합니다
+2. 하나를 고릅니다(또는 다른 선택지를 보려고 다시 섞습니다)
+3. 방법이 적용되고 개선 사항이 표시됩니다
+4. 수락하거나 버리고, 반복하거나 계속합니다
+
+## 내장 방법
+
+수십 가지 추론 방법을 사용할 수 있습니다. 예시는 다음과 같습니다.
+
+- **사전 실패 분석** - 프로젝트가 이미 실패했다고 가정하고 이유를 역추적합니다
+- **제1원칙 사고** - 가정을 걷어내고 근거 사실에서 다시 세웁니다
+- **역전 사고** - 실패를 보장하는 방법을 묻고, 그 일을 피합니다
+- **레드 팀 vs 블루 팀** - 자신의 작업을 공격한 뒤 방어합니다
+- **소크라테스식 질문** - 모든 주장에 "왜?"와 "어떻게 알아?"를 던집니다
+- **제약 제거** - 모든 제약을 제거해 무엇이 바뀌는지 보고, 선택적으로 다시 추가합니다
+- **이해관계자 매핑** - 각 이해관계자 관점에서 다시 평가합니다
+- **유추 추론** - 다른 도메인의 유사점을 찾아 그 교훈을 적용합니다
+
+그 밖에도 훨씬 많습니다. AI는 콘텐츠에 가장 관련 있는 선택지를 고르고, 사용자는 실행할 방법을 선택합니다.
+
+:::tip[시작점]
+사전 실패 분석은 어떤 사양이나 계획에도 좋은 첫 선택입니다. 표준 리뷰가 놓치는 공백을 꾸준히 찾아냅니다.
+:::

docs/ko-kr/explanation/adversarial-review.md

@@ -0,0 +1,59 @@
+---
+title: "적대적 리뷰"
+description: “괜찮아 보이네”라는 식의 대충 넘어가는 검토를 방지하는 논리적 추론 기법
+sidebar:
+  order: 8
+---
+
+문제를 반드시 찾게 만들어 더 깊은 분석을 강제합니다.
+
+## 적대적 리뷰란?
+
+리뷰어가 *반드시* 이슈를 찾아야 하는 리뷰 기법입니다. "좋아 보입니다"는 허용되지 않습니다. 리뷰어는 문제가 존재한다고 가정하고, 냉정한 태도로 그것을 찾아냅니다.
+
+부정적이 되자는 뜻이 아닙니다. 제출물을 도장 찍듯 승인하는 대충 훑기가 아니라 실제 분석을 강제하기 위한 것입니다.
+
+**핵심 규칙:** 이슈를 찾아야 합니다. 발견 항목이 0개면 중단하고 다시 분석하거나 이유를 설명합니다.
+
+## 왜 효과적인가
+
+일반 리뷰는 확증 편향에 취약합니다. 작업을 훑고, 눈에 띄는 것이 없으면 승인합니다. "문제를 찾아라"라는 요구는 이 패턴을 끊습니다.
+
+- **철저함을 강제** - 충분히 열심히 살펴 이슈를 찾기 전까지 승인할 수 없습니다
+- **빠진 것을 잡아냄** - "여기에 없는 것은 무엇인가?"가 자연스러운 질문이 됩니다
+- **신호 품질 향상** - 발견 사항이 막연한 우려가 아니라 구체적이고 실행 가능해집니다
+- **정보 비대칭** - 원래 의사결정 과정을 보지 않은 새 컨텍스트에서 검토해 의도가 아니라 산출물을 평가합니다
+
+## 사용 위치
+
+적대적 리뷰는 코드 리뷰, 구현 준비 상태 점검, 사양 검증 등 BMad 워크플로 전반에 나타납니다. 어떤 때는 필수 단계이고, 어떤 때는 고급 도출이나 파티 모드처럼 선택 사항입니다. 검토가 필요한 산출물에 맞춰 패턴이 적응합니다.
+
+## 사람의 필터링 필요
+
+AI는 문제를 찾도록 *지시*받았으므로 문제를 찾습니다. 실제로는 존재하지 않을 때도 그렇습니다. 사소한 지적을 이슈처럼 포장하거나, 의도를 오해하거나, 아예 환각성 발견 사항을 낼 수 있습니다.
+
+**무엇이 실제인지 사용자가 결정합니다.** 각 발견 사항을 검토하고 노이즈를 버리고 중요한 것을 고치세요.
+
+## 예시
+
+다음 대신:
+
+> "인증 구현은 괜찮아 보입니다. 승인합니다."
+
+적대적 리뷰는 다음처럼 나옵니다.
+
+> 1. **HIGH** - `login.ts:47` - 실패한 로그인 시도에 속도 제한 없음
+> 2. **HIGH** - 세션 토큰이 localStorage에 저장됨(XSS 취약)
+> 3. **MEDIUM** - 비밀번호 검증이 클라이언트 측에서만 수행됨
+> 4. **MEDIUM** - 실패한 로그인 시도에 대한 감사 로깅 없음
+> 5. **LOW** - 매직 넘버 `3600`은 `SESSION_TIMEOUT_SECONDS`가 되어야 함
+
+첫 번째 리뷰는 보안 취약점을 놓칠 수 있습니다. 두 번째는 네 가지를 잡았습니다.
+
+## 반복과 수확 체감
+
+발견 사항을 처리한 뒤 다시 실행하는 것도 고려하세요. 두 번째 실행은 대개 더 많은 것을 잡아냅니다. 세 번째도 항상 쓸모없지는 않습니다. 하지만 각 실행에는 시간이 들고, 언젠가는 사소한 지적과 거짓 발견 사항만 남는 수확 체감 구간에 들어갑니다.
+
+:::tip[더 나은 리뷰]
+문제가 존재한다고 가정하세요. 잘못된 것뿐 아니라 빠진 것을 찾으세요.
+:::

docs/ko-kr/explanation/analysis-phase.md

@@ -0,0 +1,70 @@
+---
+title: "분석 단계: 아이디어에서 기반까지"
+description: 브레인스토밍, 리서치, 제품 개요, PRFAQ가 무엇이며 언제 쓰는지 설명합니다
+sidebar:
+  order: 1
+---
+
+분석 단계(단계 1)는 제품을 만들기로 확정하기 전에 명확하게 생각하도록 돕습니다. 이 단계의 모든 도구는 선택 사항이지만, 분석을 완전히 건너뛰면 PRD가 인사이트가 아니라 가정 위에 세워집니다.
+
+## 왜 계획 전에 분석이 필요한가?
+
+PRD는 "무엇을 만들고 왜 만드는가?"에 답합니다. 모호한 생각을 넣으면 모호한 PRD가 나오고, 이후 모든 문서가 그 모호함을 상속합니다. 약한 PRD 위에 세운 아키텍처는 잘못된 기술적 베팅을 합니다. 약한 아키텍처에서 나온 스토리는 엣지 케이스를 놓칩니다. 비용은 누적됩니다.
+
+분석 도구는 PRD를 날카롭게 만들기 위해 존재합니다. 창의적 탐색, 시장 현실, 고객 명확성, 실행 가능성 등 서로 다른 각도에서 문제를 검토해 PM 에이전트와 마주 앉을 때 무엇을 누구를 위해 만드는지 알게 합니다.
+
+## 도구들
+
+### 브레인스토밍
+
+**무엇인가요.** 검증된 아이디어 발상 기법을 사용하는 안내형 창의 세션입니다. AI는 아이디어를 대신 생성하지 않고, 구조화된 연습으로 사용자 안의 아이디어를 끌어내는 코치 역할을 합니다.
+
+**왜 있나요.** 원석 같은 아이디어는 요구사항에 고정되기 전에 발전할 공간이 필요합니다. 브레인스토밍은 그 공간을 만듭니다. 문제 도메인은 있지만 명확한 해결책이 없거나, 확정하기 전에 여러 방향을 탐색하고 싶을 때 특히 유용합니다.
+
+**언제 쓰나요.** 만들고 싶은 것에 대한 막연한 감은 있지만 개념이 아직 굳지 않았을 때 사용합니다. 또는 개념은 있지만 대안과 비교해 압박 테스트하고 싶을 때 사용합니다.
+
+세션 작동 방식은 [브레인스토밍](./brainstorming.md)을 참고하세요.
+
+### 리서치(시장, 도메인, 기술)
+
+**무엇인가요.** 아이디어의 서로 다른 차원을 조사하는 세 가지 집중 연구 워크플로입니다. 시장 조사는 경쟁자, 트렌드, 사용자 반응을 봅니다. 도메인 조사는 주제 전문성과 용어를 쌓습니다. 기술 조사는 실현 가능성, 아키텍처 선택지, 구현 접근을 평가합니다.
+
+**왜 있나요.** 가정 위에 만드는 것은 아무도 필요로 하지 않는 것을 만드는 가장 빠른 길입니다. 리서치는 개념을 현실에 연결합니다. 이미 어떤 경쟁자가 있는지, 사용자가 실제로 무엇에 어려움을 겪는지, 기술적으로 가능한지, 산업별 제약이 무엇인지 확인합니다.
+
+**언제 쓰나요.** 낯선 도메인에 들어가거나, 경쟁자가 있을 것 같지만 아직 파악하지 않았거나, 검증하지 않은 기술 능력에 개념이 의존할 때 사용합니다. 하나만 실행해도, 둘을 조합해도, 세 가지를 모두 실행해도 됩니다. 각각 독립적으로 의미가 있습니다.
+
+### 제품 개요
+
+**무엇인가요.** 제품 개념의 1-2페이지 요약을 만드는 안내형 발견 세션입니다. AI는 협업형 비즈니스 분석가로서 비전, 대상 독자, 가치 제안, 범위를 표현하도록 돕습니다.
+
+**왜 있나요.** 제품 개요는 계획으로 들어가는 가벼운 경로입니다. 전략적 비전을 구조화된 형식으로 포착해 PRD 작성에 직접 공급합니다. 이미 개념에 확신이 있을 때 가장 잘 맞습니다. 고객, 문제, 대략 만들고 싶은 것을 알고 있을 때 제품 개요가 그 생각을 정리하고 날카롭게 합니다.
+
+**언제 쓰나요.** 개념이 비교적 명확하고 PRD를 만들기 전에 효율적으로 문서화하고 싶을 때 사용합니다. 방향에 확신이 있고 가정을 강하게 도전받을 필요가 없을 때 적합합니다.
+
+### PRFAQ Working Backwards(워킹 백워드)
+
+**무엇인가요.** Amazon의 워킹 백워드 방법론을 대화형 챌린지로 적용한 것입니다. 코드 한 줄이 존재하기 전에 완성된 제품을 발표하는 보도자료를 쓰고, 고객과 이해관계자가 물을 가장 어려운 질문에 답합니다. AI는 집요하지만 건설적인 제품 코치로 행동합니다.
+
+**왜 있나요.** PRFAQ는 계획으로 들어가는 엄격한 경로입니다. 모든 주장을 방어하게 만들어 고객 우선의 명확성을 강제합니다. 설득력 있는 보도자료를 쓸 수 없다면 제품은 준비되지 않은 것입니다. 고객 FAQ 답변이 공백을 드러내면, 그 공백은 구현 중 훨씬 늦고 비싸게 발견했을 것입니다. 이 관문은 약한 생각을 가장 싸게 고칠 수 있는 초기에 드러냅니다.
+
+**언제 쓰나요.** 리소스를 투입하기 전에 개념을 스트레스 테스트하고 싶을 때 사용합니다. 사용자가 실제로 관심을 가질지 확신이 없거나, 명확하고 방어 가능한 가치 제안을 말할 수 있는지 검증하고 싶을 때, 또는 워킹 백워드의 규율로 생각을 날카롭게 하고 싶을 때 적합합니다.
+
+## 무엇을 사용해야 하나요?
+
+| 상황 | 권장 도구 |
+| --- | --- |
+| "막연한 아이디어가 있는데 어디서 시작할지 모르겠어요" | 브레인스토밍 |
+| "결정하기 전에 시장을 이해해야 해요" | 리서치 |
+| "만들고 싶은 건 알아요. 문서화만 필요해요" | 제품 개요 |
+| "이 아이디어가 정말 만들 가치가 있는지 확인하고 싶어요" | PRFAQ |
+| "탐색하고, 검증하고, 문서화하고 싶어요" | 브레인스토밍 → 리서치 → PRFAQ 또는 제품 개요 |
+
+제품 개요와 PRFAQ는 둘 다 PRD 입력을 만듭니다. 얼마나 강한 챌린지를 원하는지에 따라 고르세요. 제품 개요는 협업형 발견 과정이고, PRFAQ는 더 엄격한 검증 관문입니다. 둘 다 같은 목적지로 가지만 PRFAQ는 그 개념이 그 단계로 갈 준비가 되었는지 시험합니다.
+
+:::tip[확실하지 않나요?]
+`bmad-help`를 실행하고 상황을 설명하세요. 이미 한 일과 달성하려는 것에 따라 적절한 시작점을 추천합니다.
+:::
+
+## 분석 후에는 무엇이 일어나나요?
+
+분석 출력은 단계 2(계획)로 직접 이어집니다. PRD 워크플로는 제품 개요, PRFAQ 문서, 리서치 발견 사항, 브레인스토밍 보고서를 입력으로 받아 사용자가 만든 모든 것을 구조화된 요구사항으로 종합합니다. 분석을 더 많이 할수록 PRD는 더 날카로워집니다.

docs/ko-kr/explanation/brainstorming.md

@@ -0,0 +1,33 @@
+---
+title: "브레인스토밍"
+description: 60가지 이상의 검증된 아이디어 도출 기법을 활용한 참여형 창의 세션
+sidebar:
+  order: 3
+---
+
+안내에 따라 직접 탐색하며 창의력을 마음껏 펼쳐보세요.
+
+## 브레인스토밍이란?
+
+`bmad-brainstorming`을 실행하면 아이디어를 대신 만들어 주는 AI가 아니라, 당신 안의 아이디어를 끌어내는 창의 촉진자를 얻게 됩니다. AI는 코치와 가이드로 행동하며 검증된 기법을 사용해 최고의 생각이 떠오를 조건을 만듭니다.
+
+**잘 맞는 경우:**
+
+- 창의적 막힘 돌파
+- 제품 또는 기능 아이디어 생성
+- 새로운 각도에서 문제 탐색
+- 날것의 개념을 실행 계획으로 발전
+
+## 작동 방식
+
+1. **준비** - 주제, 목표, 제약 정의
+2. **접근 방식 선택** - 직접 기법을 고르거나, AI 추천을 받거나, 무작위로 진행하거나, 점진적 흐름을 따릅니다
+3. **진행** - 탐색 질문과 협업형 코칭으로 기법을 진행합니다
+4. **정리** - 아이디어를 주제로 묶고 우선순위를 정합니다
+5. **실행** - 핵심 아이디어에 다음 단계와 성공 지표를 연결합니다
+
+모든 내용은 나중에 참고하거나 이해관계자와 공유할 수 있는 세션 문서에 기록됩니다.
+
+:::note[당신의 아이디어]
+모든 아이디어는 당신에게서 나옵니다. 워크플로는 통찰이 생기는 조건을 만들 뿐입니다. 출처는 당신입니다.
+:::

docs/ko-kr/explanation/checkpoint-preview.md

@@ -0,0 +1,92 @@
+---
+title: "체크포인트 미리보기"
+description: 목적에서 세부 사항에 이르기까지의 변경 과정을 단계별로 안내하는, LLM을 활용한 인간 중심 검토
+sidebar:
+  order: 5
+---
+
+`bmad-checkpoint-preview`는 LLM이 보조하는 대화형 human-in-the-loop 리뷰 워크플로입니다. 코드 변경을 목적과 컨텍스트에서 세부 사항까지 안내해, 출시할지, 다시 작업할지, 더 파고들지에 대해 충분한 정보를 바탕으로 판단할 수 있게 합니다.
+
+![체크포인트 미리보기 워크플로 다이어그램](/diagrams/checkpoint-preview-diagram.png)
+
+## 일반적인 흐름
+
+`bmad-quick-dev`를 실행합니다. 의도를 명확히 하고, 사양을 만들고, 변경을 구현합니다. 완료되면 사양 파일에 리뷰 경로를 붙이고 에디터에서 엽니다. 사양을 보니 여러 모듈에 걸쳐 20개 파일이 변경되었습니다.
+
+diff를 눈으로 훑을 수도 있습니다. 하지만 20개 파일쯤 되면 눈대중 리뷰가 흔들리기 시작합니다. 흐름을 놓치고, 떨어진 두 변경 사이의 연결을 놓치거나, 충분히 이해하지 못한 것을 승인할 수 있습니다. 그래서 "checkpoint"라고 말하면 LLM이 변경을 따라가게 해 줍니다.
+
+자율 구현에서 인간 판단으로 돌아오는 이 전환이 주된 사용 사례입니다. 빠른 개발은 최소 감독으로 오래 실행됩니다. 체크포인트 미리보기는 사용자가 다시 운전대를 잡는 지점입니다.
+
+## 왜 존재하나요?
+
+코드 리뷰에는 두 실패 모드가 있습니다. 하나는 리뷰어가 diff를 훑고 눈에 띄는 것이 없어 승인하는 경우입니다. 다른 하나는 모든 파일을 꼼꼼히 읽지만 흐름을 잃는 경우입니다. 나무는 보지만 숲을 놓칩니다. 둘 다 같은 결과를 낳습니다. 중요한 것을 잡지 못한 리뷰입니다.
+
+근본 문제는 순서입니다. 원시 diff는 파일 순서로 변경을 보여주지만, 이 순서는 이해가 쌓이는 순서와 거의 일치하지 않습니다. 왜 필요한지 알기 전에 도우미 함수를 보고, 어떤 기능을 지원하는지 알기 전에 스키마 변경을 봅니다. 리뷰어는 흩어진 단서에서 작성자의 의도를 재구성해야 하고, 그 재구성 과정에서 집중력이 무너집니다.
+
+체크포인트 미리보기는 재구성 작업을 LLM에게 맡겨 이 문제를 해결합니다. diff, 사양(있다면), 주변 코드베이스를 읽고 `git diff`가 아니라 이해를 위해 설계된 순서로 변경을 제시합니다.
+
+## 작동 방식
+
+워크플로는 다섯 단계입니다. 각 단계는 이전 단계 위에 쌓이며 "이게 뭐지?"에서 "출시해도 되나?"로 점진적으로 이동합니다.
+
+### 1. 방향 잡기
+
+워크플로는 변경(PR, 커밋, 브랜치, 사양 파일, 현재 Git 상태)을 식별하고 한 줄 의도 요약과 영역 통계를 생성합니다. 변경 파일 수, 건드린 모듈, 논리 줄 수, 경계 넘나듦, 새 공개 인터페이스 등입니다.
+
+이 단계는 "내가 보고 있는 게 맞나?"를 확인하는 순간입니다. 코드를 읽기 전에 리뷰어는 올바른 것을 보고 있는지 확인하고 범위 기대치를 맞춥니다.
+
+### 2. 둘러보기
+
+변경은 파일이 아니라 **관심사** 기준으로 구성됩니다. "입력 검증"이나 "API 계약" 같은 응집력 있는 설계 의도입니다. 각 관심사에는 왜 이 접근을 택했는지 짧은 설명과 리뷰어가 코드에서 따라갈 수 있는 클릭 가능한 `path:line` 지점이 붙습니다.
+
+이 단계는 설계 판단입니다. 리뷰어는 코드가 정확한지가 아니라 시스템에 맞는 접근인지 평가합니다. 관심사는 하향식으로 배치됩니다. 가장 높은 수준의 의도가 먼저 나오고 보조 구현이 뒤따릅니다. 리뷰어는 아직 보지 않은 것에 대한 참조를 만나지 않습니다.
+
+### 3. 상세 검토
+
+리뷰어가 설계를 이해한 뒤 워크플로는 실수했을 때 영향 범위가 가장 큰 2-5개 지점을 드러냅니다. 이들은 `[auth]`, `[schema]`, `[billing]`, `[public API]`, `[security]` 같은 위험 범주로 태그되고, 틀렸을 때 얼마나 많이 깨지는지 기준으로 정렬됩니다.
+
+이것은 버그 찾기가 아닙니다. 자동화 테스트와 CI가 정확성을 다룹니다. 상세 검토는 위험 인식을 활성화합니다. "틀렸을 때 비용이 가장 큰 곳은 여기입니다." 특정 영역을 더 깊게 보고 싶다면 "이 영역을 더 파고들어 줘"라고 말해 정확성에 초점을 맞춘 재리뷰를 요청할 수 있습니다.
+
+사양이 적대적 리뷰 루프를 거쳤다면 그 발견 사항도 여기서 드러납니다. 고쳐진 버그가 아니라, 리뷰 루프가 리뷰어가 알아야 한다고 표시한 결정입니다.
+
+### 4. 테스트
+
+변경이 작동하는 것을 수동으로 관찰하는 방법 2-5개를 제안합니다. 자동화 테스트 명령이 아니라 어떤 테스트 모음도 주지 못하는 확신을 만드는 수동 관찰입니다. 시도할 UI 상호작용, 실행할 CLI 명령, 보낼 API 요청과 각 예상 결과가 포함됩니다.
+
+사용자에게 보이는 동작이 없다면 그렇다고 말합니다. 가짜 확인 작업은 만들지 않습니다.
+
+### 5. 마무리
+
+리뷰어가 결정을 내립니다. 승인, 재작업, 계속 논의 중 하나입니다. PR을 승인한다면 워크플로가 `gh pr review --approve`를 도울 수 있습니다. 재작업한다면 문제가 접근 방식, 사양, 구현 중 어디에서 왔는지 진단하고 특정 코드 위치와 연결된 실행 가능한 피드백 초안을 돕습니다.
+
+## 보고서가 아니라 대화입니다
+
+워크플로는 각 단계를 최종 답이 아니라 출발점으로 제시합니다. 단계 사이 또는 단계 도중에도 LLM과 대화하고, 질문하고, 구성 방식에 이의를 제기하고, 다른 스킬을 불러 다른 관점을 얻을 수 있습니다.
+
+- **"오류 처리를 고급 도출로 다시 검토해 줘"** - 특정 영역 분석을 다시 생각하고 다듬게 합니다
+- **"이 스키마 마이그레이션이 안전한지 파티 모드로 토론해 줘"** - 집중 토론에 여러 에이전트 관점을 불러옵니다
+- **"코드 리뷰 실행"** - 적대적 리뷰와 엣지 케이스 분석을 포함한 구조화된 에이전트 기반 발견 사항을 생성합니다
+
+체크포인트 워크플로는 선형 경로에 가두지 않습니다. 구조가 필요할 때는 구조를 주고, 탐색하고 싶을 때는 여지를 남깁니다. 다섯 단계는 전체 그림을 보게 하기 위한 것이지만, 각 단계에서 얼마나 깊게 들어갈지와 어떤 도구를 가져올지는 전적으로 사용자에게 달려 있습니다.
+
+## 리뷰 경로
+
+둘러보기 단계는 **권장 리뷰 순서**가 있을 때 가장 잘 작동합니다. 이는 사양 작성자가 리뷰어를 변경으로 안내하기 위해 쓴 지점 목록입니다. 사양에 이 정보가 있으면 워크플로가 그대로 사용합니다.
+
+작성자가 만든 경로가 없으면 워크플로가 diff와 코드베이스 컨텍스트에서 생성합니다. 생성된 경로는 작성자가 만든 경로보다 품질이 낮지만, 파일 순서로 변경을 읽는 것보다는 훨씬 낫습니다.
+
+## 사용 시점
+
+주요 시나리오는 `bmad-quick-dev`에서의 인계입니다. 구현이 끝났고, 리뷰 경로가 붙은 사양 파일이 에디터에 열려 있으며, 출시 여부를 결정해야 합니다. "checkpoint"라고 말하면 됩니다.
+
+단독으로도 동작합니다.
+
+- **PR 리뷰** - 특히 몇 개 파일을 넘거나 여러 영역에 걸친 변경이 있을 때
+- **변경 온보딩** - 직접 작성하지 않은 브랜치에서 무슨 일이 있었는지 이해해야 할 때
+- **스프린트 리뷰** - 스프린트 상태 파일에서 `review`로 표시된 스토리를 집어올 수 있습니다
+
+"checkpoint" 또는 "이 변경을 따라가며 설명해 줘"라고 호출하세요. 어떤 터미널에서도 작동하지만 IDE(VS Code, Cursor 등) 안에서 더 편하게 사용할 수 있습니다. 워크플로가 모든 단계에서 `path:line` 참조를 생성하고, IDE 내장 터미널에서는 이들이 클릭 가능하므로 리뷰 경로를 따라 파일 사이를 이동할 수 있습니다.
+
+## 아닌 것
+
+체크포인트 미리보기는 자동화 리뷰의 대체물이 아닙니다. 린터, 타입 검사기, 테스트 모음을 실행하지 않습니다. 심각도 점수를 붙이거나 통과/실패 결정을 만들지 않습니다. 사람이 가장 중요한 곳에 판단을 적용하도록 돕는 읽기 가이드입니다.

docs/ko-kr/explanation/established-projects-faq.md

@@ -0,0 +1,51 @@
+---
+title: "기존 프로젝트 FAQ"
+description: 기존 프로젝트에서 BMad Method를 사용할 때의 일반 질문
+sidebar:
+  order: 13
+---
+
+BMad Method(BMM)로 기존 프로젝트에서 작업할 때 자주 묻는 질문에 빠르게 답합니다.
+
+## 질문
+
+- [프로젝트 문서화를 먼저 실행해야 하나요?](#프로젝트-문서화를-먼저-실행해야-하나요)
+- [프로젝트 문서화 실행을 잊었다면 어떻게 하나요?](#프로젝트-문서화-실행을-잊었다면-어떻게-하나요)
+- [기존 프로젝트에 빠른 흐름을 사용할 수 있나요?](#기존-프로젝트에-빠른-흐름을-사용할-수-있나요)
+- [기존 코드가 모범 사례를 따르지 않으면 어떻게 하나요?](#기존-코드가-모범-사례를-따르지-않으면-어떻게-하나요)
+
+### 프로젝트 문서화를 먼저 실행해야 하나요?
+
+특히 다음 상황에서는 강력히 권장합니다.
+
+- 기존 문서가 없습니다
+- 문서가 오래되었습니다
+- AI 에이전트가 기존 코드에 대한 컨텍스트가 필요합니다
+
+`docs/index.md`를 포함한 포괄적이고 최신 문서가 있거나, 에이전트가 기존 시스템을 바탕으로 작업할 만큼 다른 도구나 기법으로 충분한 발견 과정을 제공할 예정이라면 건너뛸 수 있습니다.
+
+### 프로젝트 문서화 실행을 잊었다면 어떻게 하나요?
+
+걱정하지 마세요. 언제든 실행할 수 있습니다. 프로젝트 도중이나 나중에 실행해 문서를 최신 상태로 유지할 수도 있습니다.
+
+### 기존 프로젝트에 빠른 흐름을 사용할 수 있나요?
+
+네. 빠른 흐름은 기존 프로젝트에서 잘 작동합니다. 다음을 수행합니다.
+
+- 기존 기술 스택 자동 감지
+- 기존 코드 패턴 분석
+- 관례 감지 및 확인 요청
+- 기존 코드를 존중하는, 맥락이 충분히 담긴 사양 생성
+
+기존 코드베이스의 버그 수정과 작은 기능에 특히 잘 맞습니다.
+
+### 기존 코드가 모범 사례를 따르지 않으면 어떻게 하나요?
+
+빠른 흐름은 관례를 감지하고 묻습니다. "이 기존 관례를 따를까요?" 사용자가 결정합니다.
+
+- **예** → 현재 코드베이스와의 일관성 유지
+- **아니요** → 새 표준 수립(사양에 이유를 문서화)
+
+BMM은 선택을 존중합니다. 현대화를 강제하지 않지만 필요한 제안은 합니다.
+
+**여기에 답이 없는 질문이 있나요?** [GitHub Issue](https://github.com/bmad-code-org/BMAD-METHOD/issues)를 열거나 [Discord](https://discord.gg/gk8jAdXWmj)에서 물어보세요. 추가하겠습니다.

docs/ko-kr/explanation/forensic-investigation.md

@@ -0,0 +1,94 @@
+---
+title: "포렌식 조사"
+description: bmad-investigate가 모든 이슈를 현장처럼 다루고, 증거를 등급화하며, 엔지니어가 바로 행동할 수 있는 구조화된 사례 파일을 만드는 방법
+sidebar:
+  order: 10
+---
+
+`bmad-investigate`에 충돌 로그, 스택 추적, 또는 단순히 "예전엔 됐는데 지금은 안 돼요"를 건네면, 스킬은 실행되는 동안 조사자의 규율을 적용합니다. 바로 고치기 시작하지 않습니다. 사례 파일을 엽니다.
+
+모든 발견 사항은 등급이 매겨집니다. 모든 가설은 상태를 가집니다. 잘못된 방향도 지우지 않고 남깁니다. 산출물은 다른 엔지니어가 아무 배경 없이 집어 들어도 이해할 수 있는 문서입니다.
+
+이 페이지는 조사가 왜 별도의 규율인지, 그리고 일반 개발 워크플로가 주지 못하는 것을 이 스킬이 어떤 방식으로 제공하는지 설명합니다.
+
+## "그냥 디버깅해"의 문제
+
+일반 디버깅은 세 가지를 섞습니다. 증거를 보고, 원인을 추론하고, 이론을 시험하기 위해 코드를 바꿉니다. 이것들이 섞이면 두 가지 실패 모드가 나타납니다.
+
+첫 번째는 **서사 고착**입니다. 처음 그럴듯한 이야기가 작업 가설이 되고, 모든 관찰이 거기에 맞춰 끼워집니다. 누군가 포기하고 처음부터 다시 시작할 때까지 버그는 고쳐지지 않습니다. 몇 시간 뒤에야 말입니다.
+
+두 번째는 **증거 망각**입니다. 무언가를 추적하고 배제했지만 왜 배제했는지 적지 않았습니다. 이틀 뒤 새로운 눈으로 같은 것을 다시 추적합니다. 더 나쁘게는 동료가 버그를 넘겨받아 이미 제거한 막다른 경로를 다시 실행합니다.
+
+이 스킬의 설계는 이 둘에 대한 직접적인 응답입니다.
+
+## 증거 등급화
+
+조사의 모든 발견 사항은 세 가지 중 하나입니다.
+
+- **Confirmed(확인됨).** 로그, 코드, 덤프에서 직접 관찰되었고 특정 참조(`path:line`, 로그 타임스탬프, 커밋 해시)로 인용됩니다. 누군가 "어떻게 알아?"라고 물으면 인용을 가리킵니다.
+- **Deduced(추론됨).** 확인된 증거에서 논리적으로 따릅니다. 추론 사슬이 표시됩니다. 사슬의 한 단계가 틀리면 추론도 틀리고, 어느 단계인지 볼 수 있습니다.
+- **Hypothesized(가설).** 그럴듯하지만 확인되지 않았습니다. 무엇이 확인하거나 반박할지와 무엇이 닫을지를 미리 선언합니다. 가설은 명시적으로 *사실이 아닙니다*.
+
+등급화는 겸손해 보이기 위한 것이 아닙니다. 사례 파일을 읽을 수 있게 만들기 위한 것입니다. 독자는 `Confirmed` 섹션에서 무엇이 사실인지, `Deduced` 섹션에서 무엇이 따라오는지, `Hypothesized` 섹션에서 무엇이 아직 열려 있는지 훑어볼 수 있습니다. 이 셋의 혼동이 조사가 빙빙 도는 가장 흔한 이유입니다.
+
+## 기준점 먼저 확보하기
+
+조사는 이론에서 시작하지 않습니다. 하나의 확인된 증거에서 시작해 바깥으로 확장합니다. 그 기준점은 특정 오류 메시지, 스택 프레임, 타임스탬프가 있는 로그 항목일 수 있습니다.
+
+이는 흔한 조사 방식과 반대입니다. 누군가 직감을 갖고 이론을 세운 뒤 그것을 지지하는 증거를 찾습니다. 직감이 맞을 수도 있지만, 그 *방법*은 확증 편향을 기본값으로 만들기 때문에 취약합니다.
+
+기준점은 추론이 흐려질 때 돌아갈 수 있는 사실입니다. 추론이 이상한 곳으로 가면 기준점까지 되돌아가 다른 갈래를 시도할 수 있습니다. 기준점이 없으면 어느 단계를 되돌려야 하는지 알 수 없습니다.
+
+증거가 부족하면 스킬은 그렇게 말하고 가설 주도 탐색으로 전환합니다. 가능한 것에서 가설을 만들고, 각각을 시험할 증거를 식별하며, 우선순위가 있는 데이터 수집 목록을 제시합니다. 빠진 증거 자체도 발견 사항입니다.
+
+## 가설 규율
+
+가설은 사례 파일에서 절대 삭제되지 않습니다. 증거가 확인하거나 반박하면 **Status** 필드가 `Open`에서 `Confirmed` 또는 `Refuted`로 바뀌고, 어떤 증거가 결론을 냈는지 **Resolution**이 설명합니다.
+
+이 규칙에는 비용이 있습니다. 사례 파일이 길어집니다. 하지만 이점도 큽니다. 전체 추론 이력이 산출물의 일부가 됩니다. 여섯 달 뒤 비슷한 버그가 나타나면 다음 조사자는 원래 사례 파일을 읽고 어떤 경로가 이미 제거되었고 왜 그런지 볼 수 있습니다. 그 이력이 없으면 새 조사자마다 같은 막다른 경로를 다시 실행합니다.
+
+현재의 조사자에게도 규율을 부여합니다. 틀린 가설을 지울 수 없다면, 인용된 증거로 반박해야 합니다. 불편해졌다고 조용히 떨어뜨리는 선택지는 사라집니다.
+
+## 전제에 도전하기
+
+사용자의 문제 설명은 사실이 아니라 가설입니다. "캐시가 깨졌다"는 사용자가 *믿는 것*입니다. 스킬은 그 전제를 중심으로 조사를 세우기 전에 기술적 주장을 독립적으로 검증합니다. 증거가 전제와 모순되면 보고서가 직접 그렇게 말합니다.
+
+이것이 포렌식 감각입니다. 목격자 진술은 데이터이지 진실이 아닙니다. 때로 보고된 버그는 진짜지만 이름표가 틀립니다. 때로 설명된 증상은 다른 원인의 파생 결과입니다. 전제를 절대적 진실로 받아들이는 조사는 잘못된 결함을 진단하고, 버그는 약간 다른 형태로 돌아옵니다.
+
+## 보정된 진행
+
+스킬은 두 가지 모드가 아니라 하나의 절차입니다. 입력이 요구하는 결함 추적과 영역 탐색의 비율을 계속 보정합니다.
+
+증상 기반 사례(티켓, 충돌, 오류 메시지, "예전엔 됐다")는 가설 추적, 타임라인 재구성, 수정 방향에 기울어집니다. 증상 없는 사례(만지기 전 모듈 이해, 재사용성 평가, 정신 모델 구축)는 I/O 매핑, 제어 흐름 필터링, 검증 계획에 기울어집니다. 실제 사례 대부분은 그 사이 어딘가에 있고, 사례 파일은 증거가 요구한 균형을 반영합니다.
+
+사례가 어디에 있든 원칙은 같습니다. 먼저 기준점 확보, 증거 등급화, 가설 추적, 절대 지우지 않기입니다. 출력은 항상 `{implementation_artifacts}/investigations/{slug}-investigation.md`이며, 해당 사례에 적용되지 않는 섹션은 비어 있거나 생략됩니다.
+
+깊은 버그가 더 넓은 하위 시스템 이해를 요구할 때 절차는 I/O 매핑, 제어 흐름 필터링, 출력에서 역추적하기, 구성 요소 간 경계 추적 기법을 한 흐름 안에 통합합니다. 영역 모델은 같은 사례 파일에 들어갑니다. 모드 전환은 없습니다.
+
+## 방법론은 스킬 안에 있습니다
+
+조사자의 원칙은 스킬 자체의 속성입니다. `bmad-investigate`를 호출한 사람은 실행되는 동안 방법론과 커뮤니케이션 스타일을 채택합니다. 냉정한 정확성, 증거 우선 언어, 회피 없는 표현, 사례 파일 중심의 구성입니다. 스킬이 끝나면 호출자는 이전 말투로 돌아갑니다. 페르소나 교체가 아니라 스킬 원칙에서 오는 말투 전환입니다.
+
+조사와 구현은 서로 다른 감각을 보상하기 때문에 중요합니다. 조사자는 느리고 정확합니다. 구현자는 빠르고 자신감 있습니다. 같은 세션에서 둘을 모두 하려 하면 둘 다 애매해지는 경향이 있습니다. 스킬은 별도 정체성으로 컨텍스트를 전환하지 않고, 진행 흐름 안에서 조사자의 태도를 적용합니다.
+
+## 얻는 것
+
+완성된 조사 파일:
+
+- `Confirmed` 발견 사항(인용 포함)을 `Deductions` 및 `Hypotheses`와 분리합니다
+- 형성된 모든 가설을 최종 `Status`와 `Resolution`과 함께 보존합니다
+- 여러 증거 소스에서 이벤트 타임라인을 재구성합니다
+- 데이터 공백과 그것이 무엇을 해결할지 식별합니다
+- 증거에 기반한 실행 가능한 결론을 제공합니다
+- 근본 원인이 식별되면 재현 계획을 포함합니다
+- 아직 탐색할 경로의 조사 백로그를 유지합니다
+
+그 자리에 없던 엔지니어에게 건네도 무슨 일이 있었고, 무엇을 알고 있으며, 무엇이 아직 불확실한지 이해해야 합니다. 기준은 그것입니다.
+
+## 더 큰 아이디어
+
+오늘날 대부분의 "AI 디버깅"은 증거, 추론, 코드 변경을 그럴듯한 텍스트의 한 흐름으로 섞습니다. 신호는 찾기 어렵고, 막다른 경로는 반복되며, 사례 파일이 있더라도 아무도 읽고 싶지 않은 채팅 로그처럼 보이는 경우가 많습니다.
+
+`bmad-investigate`는 조사를 고유한 산출물이 있는 규율로 다룹니다. 증거에는 등급이 있습니다. 가설에는 상태가 있습니다. 잘못된 방향은 지워지지 않고 문서화됩니다. 사례 파일은 세션보다 오래 살아남습니다.
+
+이미 본 적 있는 것처럼 보이는 다음 버그가 나타났을 때, 빈 프롬프트가 아니라 시작할 곳이 생깁니다.

docs/ko-kr/explanation/named-agents.md

@@ -0,0 +1,94 @@
+---
+title: "이름 있는 에이전트"
+description: BMad 에이전트가 이름, 페르소나, 커스터마이징 영역을 갖는 이유와 메뉴 기반 또는 프롬프트 기반 대안보다 무엇을 가능하게 하는지
+sidebar:
+  order: 2
+---
+
+"Mary, 브레인스토밍하자"라고 말하면 Mary가 활성화됩니다. 그녀는 설정한 언어로 당신의 이름을 부르고, 고유한 페르소나로 인사합니다. `bmad-help`가 언제나 가능하다고 알려줍니다. 그리고 의도가 명확했기 때문에 메뉴를 건너뛰고 바로 브레인스토밍으로 들어갑니다.
+
+이 페이지는 실제로 무엇이 일어나고 있고 왜 BMad가 이렇게 설계되었는지 설명합니다.
+
+## 세 축
+
+BMad의 에이전트 모델은 서로 조합되는 세 가지 기본 요소 위에 놓여 있습니다.
+
+| 기본 요소 | 제공하는 것 | 위치 |
+| --- | --- | --- |
+| **스킬** | 기능 - 어시스턴트가 할 수 있는 구체적인 일(브레인스토밍, PRD 초안 작성, 스토리 구현) | `.claude/skills/{skill-name}/SKILL.md` 또는 IDE별 동등 경로 |
+| **이름 있는 에이전트** | 페르소나의 연속성 - 일관된 목소리, 원칙, 시각적 단서로 관련 스킬 메뉴를 묶는 알아볼 수 있는 정체성 | 디렉터리가 `bmad-agent-*`로 시작하는 스킬 |
+| **커스터마이징** | 우리 방식으로 맞추기 - 에이전트 동작을 재구성하고, MCP 통합을 추가하고, 템플릿을 교체하고, 조직 관례를 겹쳐 적용하는 오버라이드 | `_bmad/custom/{skill-name}.toml`(팀 오버라이드) 및 `.user.toml`(개인, git에서 무시됨) |
+
+세 요소 중 하나라도 빠지면 경험이 무너집니다.
+
+- 에이전트 없는 스킬 → 사용자가 이름이나 코드로 탐색해야 하는 기능 목록
+- 스킬 없는 에이전트 → 할 일이 없는 페르소나
+- 커스터마이징 없음 → 모든 사용자가 같은 기본 제공 동작을 받고, 조직별 필요에는 포크를 강요받음
+
+## 이름 있는 에이전트가 주는 것
+
+BMad는 BMad Method의 단계에 맞춘 여섯 이름 있는 에이전트를 제공합니다.
+
+| 에이전트 | 단계 | 모듈 |
+| --- | --- | --- |
+| 📊 **Mary**, 비즈니스 분석가 | 분석 | 시장 조사, 브레인스토밍, 제품 개요, PRFAQ |
+| 📚 **Paige**, 기술 작성자 | 분석 | 프로젝트 문서화, 다이어그램, 문서 검증 |
+| 📋 **John**, 제품 관리자 | 계획 | PRD 작성, 에픽/스토리 분해, 구현 준비 상태 점검 |
+| 🎨 **Sally**, UX 디자이너 | 계획 | UX 설계 사양 |
+| 🏗️ **Winston**, 시스템 아키텍트 | 솔루션 설계 | 기술 아키텍처, 정렬 점검 |
+| 💻 **Amelia**, 시니어 엔지니어 | 구현 | 스토리 실행, 빠른 개발, 코드 리뷰, 스프린트 계획 |
+
+각 에이전트는 하드코딩된 정체성(이름, 역할명, 도메인)과 커스터마이즈 가능한 계층(역할, 원칙, 커뮤니케이션 스타일, 아이콘, 메뉴)을 가집니다. Mary의 원칙을 다시 쓰거나 메뉴 항목을 추가할 수는 있지만 이름을 바꿀 수는 없습니다. 이는 의도적입니다. 이름 인식은 커스터마이징 후에도 유지되므로, 팀이 Mary의 동작을 어떻게 조정했든 "Mary"는 항상 분석가를 활성화합니다.
+
+## 활성화 흐름
+
+이름 있는 에이전트를 호출하면 여덟 단계가 순서대로 실행됩니다.
+
+1. **에이전트 블록 해석** - 제공된 `customize.toml`을 팀 및 개인 오버라이드와 병합합니다. Python 병합 스크립트가 표준 라이브러리 `tomllib`을 사용합니다
+2. **사전 단계 실행** - 팀이 설정한 사전 동작
+3. **페르소나 채택** - 하드코딩된 정체성과 커스터마이즈된 역할, 커뮤니케이션 스타일, 원칙
+4. **지속 사실 로드** - 조직 규칙, 컴플라이언스 메모, `file:` 접두사로 로드되는 파일(예: `file:{project-root}/docs/project-context.md`)
+5. **설정 로드** - 사용자 이름, 커뮤니케이션 언어, 출력 언어, 산출물 경로
+6. **인사** - 설정 언어로 개인화된 인사를 하고, 누가 말하는지 한눈에 보이도록 에이전트 이모지 접두사를 포함합니다
+7. **추가 단계 실행** - 팀이 설정한 인사 후 설정
+8. **바로 실행 또는 메뉴 표시** - 첫 메시지가 메뉴 항목에 매핑되면 바로 이동하고, 아니면 메뉴를 보여주고 입력을 기다립니다
+
+8단계는 의도와 기능이 만나는 곳입니다. "Mary, 브레인스토밍하자"는 `bmad-brainstorming`이 Mary 메뉴의 `BP`와 명확히 맞으므로 메뉴 표시를 건너뜁니다. 모호하게 말하면 확인 절차가 아니라 한 번 짧게 묻습니다. 맞는 것이 없으면 일반 대화를 계속합니다.
+
+## 왜 그냥 메뉴가 아닌가요?
+
+메뉴는 사용자가 도구에 반쯤 맞춰야 합니다. 브레인스토밍이 PM 에이전트가 아니라 분석가 에이전트의 `BP` 코드 아래 있다는 것을 기억하고, 어떤 페르소나가 어떤 기능을 갖는지 알아야 합니다. 도구가 사용자에게 떠넘기는 인지 부담입니다.
+
+이름 있는 에이전트는 이를 뒤집습니다. 자연스러운 말로 원하는 것을 누구에게 할지 말합니다. 에이전트는 자신이 누구이고 무엇을 하는지 압니다. 의도가 충분히 명확하면 그냥 진행합니다.
+
+메뉴는 여전히 대체 경로로 있습니다. 탐색할 때는 보여주고, 필요 없을 때는 건너뜁니다.
+
+## 왜 그냥 빈 프롬프트가 아닌가요?
+
+빈 프롬프트는 사용자가 마법 단어를 안다고 가정합니다. "브레인스토밍을 도와줘"는 될 수 있지만 "내 SaaS 아이디어를 같이 발전시켜 보자"는 안 될 수 있고, 결과는 표현 방식에 의존합니다. 사용자가 프롬프트 엔지니어링을 책임지게 됩니다.
+
+이름 있는 에이전트는 자유를 닫지 않고 구조를 더합니다. 페르소나는 일관되고, 기능은 발견 가능하며, `bmad-help`는 항상 한 명령 거리에 있습니다. 에이전트가 무엇을 할 수 있는지 추측할 필요도, 사용 설명서가 필요하지도 않습니다.
+
+## 커스터마이징은 일급 기능입니다
+
+커스터마이징 모델이 있어야 이 방식이 개별 개발자를 넘어 확장됩니다.
+
+모든 에이전트는 합리적인 기본값이 담긴 `customize.toml`을 제공합니다. 팀은 `_bmad/custom/bmad-agent-{role}.toml`에 오버라이드를 커밋합니다. 개인은 `.user.toml`(git에서 무시됨)에 개인 선호를 겹쳐 적용할 수 있습니다. 병합 스크립트는 활성화 시점에 세 파일을 예측 가능한 구조 규칙으로 병합합니다.
+
+대부분의 사용자는 이 파일을 직접 작성하지 않습니다. `bmad-customize` 스킬은 대상을 고르고, 에이전트와 워크플로 중 범위를 선택하고, 오버라이드를 작성하고, 병합을 검증하는 과정을 안내합니다. 그래서 TOML에 익숙한 사람만이 아니라 자신의 의도를 이해하는 누구나 커스터마이징 영역에 접근할 수 있습니다.
+
+구체적 예: 팀이 Amelia에게 라이브러리 문서는 항상 Context7 MCP 도구를 사용하고 로컬 에픽 목록에 스토리가 없으면 Linear를 대체 경로로 사용하라고 하는 단일 파일을 커밋합니다. Amelia가 실행하는 모든 개발 워크플로(dev-story, quick-dev, create-story, code-review)가 소스 편집이나 워크플로별 중복 없이 이 동작을 상속합니다.
+
+교차 관심사를 위한 두 번째 커스터마이징 영역도 있습니다. 중앙 `_bmad/config.toml`과 `_bmad/config.user.toml`(둘 다 설치 프로그램 소유, 각 모듈의 `module.yaml`에서 재구성됨), 그리고 오버라이드용 `_bmad/custom/config.toml`(팀, 커밋됨)과 `_bmad/custom/config.user.toml`(개인, git에서 무시됨)입니다. 여기에 **에이전트 명단**이 있습니다. `bmad-party-mode`, `bmad-retrospective`, `bmad-advanced-elicitation`처럼 명단을 사용하는 스킬이 누가 가능하고 어떻게 표현될지 알기 위해 읽는 가벼운 설명자입니다. 팀 오버라이드로 에이전트를 조직 전체에서 다시 표현하고, `.user.toml` 오버라이드로 가상 목소리(Kirk, Spock, 도메인 전문가 페르소나)를 개인 실험으로 추가할 수 있습니다. 스킬 폴더를 건드리지 않습니다. 스킬별 파일은 Mary가 활성화될 때 *어떻게 행동하는지*를 조정하고, 중앙 설정은 다른 스킬이 명단에서 Mary를 *어떻게 보는지*를 조정합니다.
+
+전체 커스터마이징 영역과 작동 예시는 다음을 참고하세요.
+
+- [BMad 커스터마이징 방법](../how-to/customize-bmad.md) - 무엇을 커스터마이즈할 수 있고 병합이 어떻게 동작하는지의 참조
+- [조직을 위해 BMad 확장하기](../how-to/expand-bmad-for-your-org.md) - 에이전트 전반 규칙, 워크플로 관례, 외부 게시, 템플릿 교체, 에이전트 명단 커스터마이징을 다루는 실전 레시피
+- `bmad-customize` 스킬 - 의도를 올바른 위치의 검증된 오버라이드 파일로 바꿔 주는 안내형 작성 도우미
+
+## 더 큰 아이디어
+
+오늘날 대부분의 AI 어시스턴트는 메뉴이거나 프롬프트입니다. 둘 다 인지 부하를 사용자에게 넘깁니다. 이름 있는 에이전트와 커스터마이즈 가능한 스킬은 이미 일을 아는 팀원과 대화하게 해 주고, 조직이 포크 없이 그 팀원을 조정하게 합니다.
+
+다음에 "Mary, 브레인스토밍하자"라고 입력했을 때 그녀가 바로 진행한다면, 무엇이 일어나지 않았는지 보세요. 슬래시 명령도, 탐색해야 할 메뉴도, 그녀가 무엇을 할 수 있는지 어색하게 상기시키는 일도 없었습니다. 바로 그 부재가 설계의 핵심입니다.

docs/ko-kr/explanation/party-mode.md

@@ -0,0 +1,59 @@
+---
+title: "파티 모드"
+description: 다중 에이전트 협업 - 모든 AI 에이전트를 하나의 대화에 모읍니다
+sidebar:
+  order: 11
+---
+
+모든 AI 에이전트를 하나의 대화에 모으세요.
+
+## 파티 모드란?
+
+`bmad-party-mode`를 실행하면 PM, 아키텍트, 개발자, UX 디자이너 등 필요한 AI 팀 전체가 한 방에 모입니다. BMad Master가 조율하고 메시지마다 관련 에이전트를 선택합니다. 에이전트들은 각 페르소나에 맞게 답하고, 동의하거나 반대하며, 서로의 아이디어를 이어받아 발전시킵니다.
+
+대화는 원하는 만큼 계속됩니다. 후속 질문을 묻고, 답에 반박하고, 토론 방향을 바꿀 수 있습니다. 끝날 때까지 에이전트들과 실제 주고받는 대화를 합니다.
+
+**잘 맞는 경우:**
+
+- 절충이 필요한 큰 결정
+- 브레인스토밍 세션
+- 문제가 생겼을 때의 사후 분석
+- 스프린트 회고와 계획
+
+## 예시
+
+### 나쁜 아키텍처 지적하기
+
+**사용자:** "좋아요 팀, 지난 스프린트는 엉망이었어요. 인증 서비스가 세 번이나 내려갔습니다. 어디서 문제가 생겼나요?"
+
+**아키텍트:** "설계 자체는 건전했습니다. 분산 인증과 적절한 대체 경로가 있었죠. 구현이 사양에서 벗어났다면..."
+
+**개발자:** "저는 아키텍처 문서를 그대로 따랐습니다. 사양이 동시 세션 무효화 경쟁 조건을 다루지 않았어요."
+
+**PM:** "두 분 모두 더 큰 이슈를 놓쳤습니다. PRD에서 세션 관리 요구사항을 검증하지 않았어요. 그걸 잡지 못한 건 제 책임입니다."
+
+**TEA:** "통합 테스트에서 제가 잡았어야 했습니다. 테스트 시나리오가 동시 무효화를 다루지 않았어요."
+
+### 창의적 브레인스토밍
+
+**사용자:** "온보딩이 지루하지 않고 특별하게 느껴지게 하려면 어떻게 해야 할까요?"
+
+**UX 디자이너:** "점진적 공개부터 시작하세요. 기능을 튜토리얼에서 한꺼번에 보여주지 말고, 사용자가 필요로 할 때 드러내는 겁니다."
+
+**스토리텔러:** "온보딩이 하나의 이야기라면 어떨까요? 각 단계가 캐릭터의 여정을 드러내고, 사용자가 바로 그 주인공이 되는 겁니다."
+
+**게임 디자이너:** "그 아이디어를 이어가 보죠. 첫 번째 '퀘스트'가 실제 사용자 문제를 해결하는 일이라면 어떨까요? 사용자는 가치 있는 일을 해내며 배웁니다."
+
+### 기술 결정
+
+**사용자:** "MVP에는 모놀리스가 좋을까요, 마이크로서비스가 좋을까요?"
+
+**아키텍트:** "모놀리스로 시작하세요. 사용자 1,000명 규모에서는 마이크로서비스가 필요 없는 복잡성을 더합니다."
+
+**PM:** "동의합니다. 이론적인 확장성보다 출시 속도가 더 중요합니다."
+
+**개발자:** "명확한 모듈 경계를 둔 모놀리스가 좋겠습니다. 필요해지면 나중에 서비스를 분리할 수 있습니다."
+
+:::tip[더 나은 결정]
+다양한 관점을 통해 더 나은 결정을 내립니다. 파티 모드에 오신 것을 환영합니다.
+:::

docs/ko-kr/explanation/preventing-agent-conflicts.md

@@ -0,0 +1,121 @@
+---
+title: "에이전트 충돌 방지"
+description: 여러 에이전트가 시스템을 구현할 때 아키텍처가 충돌을 방지하는 방법
+sidebar:
+  order: 7
+---
+
+여러 AI 에이전트가 시스템의 서로 다른 부분을 구현하면 충돌하는 기술 결정을 내릴 수 있습니다. 아키텍처 문서화는 공유 표준을 세워 이를 방지합니다.
+
+## 일반적인 충돌 유형
+
+### API 스타일 충돌
+
+아키텍처가 없으면:
+
+- 에이전트 A는 REST와 `/users/{id}`를 사용합니다
+- 에이전트 B는 GraphQL 뮤테이션을 사용합니다
+- 결과: 일관되지 않은 API 패턴과 혼란스러운 API 사용 경험
+
+아키텍처가 있으면:
+
+- ADR이 명시합니다. "모든 클라이언트-서버 통신에는 GraphQL을 사용"
+- 모든 에이전트가 같은 패턴을 따릅니다
+
+### 데이터베이스 설계 충돌
+
+아키텍처가 없으면:
+
+- 에이전트 A는 snake_case 컬럼명을 사용합니다
+- 에이전트 B는 camelCase 컬럼명을 사용합니다
+- 결과: 일관되지 않은 스키마와 혼란스러운 쿼리
+
+아키텍처가 있으면:
+
+- 표준 문서가 이름 규칙을 명시합니다
+- 모든 에이전트가 같은 패턴을 따릅니다
+
+### 상태 관리 충돌
+
+아키텍처가 없으면:
+
+- 에이전트 A는 전역 상태에 Redux를 사용합니다
+- 에이전트 B는 React 컨텍스트를 사용합니다
+- 결과: 여러 상태 관리 방식과 복잡성
+
+아키텍처가 있으면:
+
+- ADR이 상태 관리 방식을 명시합니다
+- 모든 에이전트가 일관되게 구현합니다
+
+## 아키텍처가 충돌을 방지하는 방법
+
+### 1. ADR을 통한 명시적 결정
+
+모든 중요한 기술 선택은 다음과 함께 문서화됩니다.
+
+- 컨텍스트(왜 이 결정이 중요한가)
+- 고려한 대안(어떤 선택지가 있는가)
+- 결정(무엇을 선택했는가)
+- 근거(왜 선택했는가)
+- 결과(받아들인 절충)
+
+### 2. FR/NFR별 지침
+
+아키텍처는 각 기능 요구사항을 기술적 접근에 연결합니다.
+
+- FR-001: 사용자 관리 → GraphQL 뮤테이션
+- FR-002: 모바일 앱 → 최적화된 쿼리
+
+### 3. 표준과 관례
+
+다음을 명시적으로 문서화합니다.
+
+- 디렉터리 구조
+- 이름 규칙
+- 코드 구성
+- 테스트 패턴
+
+## 공유 컨텍스트로서의 아키텍처
+
+아키텍처를 구현 전 모든 에이전트가 읽는 공유 컨텍스트로 생각하세요.
+
+```text
+PRD: "무엇을 만들 것인가"
+     ↓
+아키텍처: "어떻게 만들 것인가"
+     ↓
+에이전트 A가 아키텍처를 읽음 → 에픽 1 구현
+에이전트 B가 아키텍처를 읽음 → 에픽 2 구현
+에이전트 C가 아키텍처를 읽음 → 에픽 3 구현
+     ↓
+결과: 일관된 구현
+```
+
+## 주요 ADR 주제
+
+충돌을 방지하는 일반적인 결정:
+
+| 주제 | 예시 결정 |
+| --- | --- |
+| API 스타일 | GraphQL vs REST vs gRPC |
+| 데이터베이스 | PostgreSQL vs MongoDB |
+| 인증 | JWT vs 세션 |
+| 상태 관리 | Redux vs 컨텍스트 vs Zustand |
+| 스타일링 | CSS Modules vs Tailwind vs Styled Components |
+| 테스트 | Jest + Playwright vs Vitest + Cypress |
+
+## 피해야 할 안티패턴
+
+:::caution[흔한 실수]
+- **암묵적 결정** - "API 스타일은 하면서 정하자"는 태도는 일관성 부족으로 이어집니다
+- **과도한 문서화** - 모든 사소한 선택을 문서화하면 분석 마비가 생깁니다
+- **오래된 아키텍처** - 한 번 쓰고 업데이트하지 않은 문서는 에이전트가 오래된 패턴을 따르게 합니다
+:::
+
+:::tip[올바른 접근]
+- 에픽 경계를 넘는 결정을 문서화하세요
+- 충돌이 생기기 쉬운 영역에 집중하세요
+- 배운 것을 반영해 아키텍처를 업데이트하세요
+- 중요한 변경에는 `bmad-correct-course`를 사용하세요
+:::

docs/ko-kr/explanation/project-context.md

@@ -0,0 +1,160 @@
+---
+title: "프로젝트 컨텍스트"
+description: project-context.md가 프로젝트 규칙과 선호도로 AI 에이전트를 안내하는 방법
+sidebar:
+  order: 12
+---
+
+`project-context.md` 파일은 AI 에이전트를 위한 프로젝트 구현 가이드입니다. 다른 개발 체계의 "헌장"처럼 모든 워크플로에서 일관된 코드 생성을 보장하는 규칙, 패턴, 선호 사항을 포착합니다.
+
+## 하는 일
+
+AI 에이전트는 구현 중 계속 결정을 내립니다. 어떤 패턴을 따를지, 코드를 어떻게 구조화할지, 어떤 관례를 사용할지 등입니다. 명확한 안내가 없으면 다음이 일어날 수 있습니다.
+
+- 코드베이스와 맞지 않는 범용 모범 사례를 따릅니다
+- 스토리마다 일관되지 않은 결정을 내립니다
+- 프로젝트별 요구사항이나 제약을 놓칩니다
+
+`project-context.md` 파일은 에이전트가 알아야 할 것을 간결하고 LLM에 최적화된 형식으로 문서화해 이 문제를 해결합니다.
+
+## 작동 방식
+
+모든 구현 워크플로는 `project-context.md`가 있으면 자동으로 로드합니다. 아키텍트 워크플로도 아키텍처를 설계할 때 기술 선호 사항을 존중하기 위해 이 파일을 로드합니다.
+
+**이 워크플로들이 로드합니다:**
+
+- `bmad-create-architecture` - 솔루션 설계 중 기술 선호 사항을 존중합니다
+- `bmad-create-story` - 프로젝트 패턴으로 스토리 작성을 안내합니다
+- `bmad-dev-story` - 구현 결정을 안내합니다
+- `bmad-code-review` - 프로젝트 표준과 비교해 검증합니다
+- `bmad-quick-dev` - 사양을 구현할 때 패턴을 적용합니다
+- `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` - 프로젝트 전반의 컨텍스트를 제공합니다
+
+## 언제 만들까요?
+
+`project-context.md` 파일은 프로젝트 어느 단계에서든 유용합니다.
+
+| 시나리오 | 만들 시점 | 목적 |
+| --- | --- | --- |
+| **새 프로젝트, 아키텍처 전** | `bmad-create-architecture` 전에 수동 작성 | 아키텍트가 기술 선호 사항을 존중하도록 문서화 |
+| **새 프로젝트, 아키텍처 후** | `bmad-generate-project-context` 또는 수동 작성 | 구현 에이전트를 위해 아키텍처 결정 포착 |
+| **기존 프로젝트** | `bmad-generate-project-context`로 생성 | 기존 패턴을 발견해 에이전트가 기존 관례를 따르게 함 |
+| **빠른 흐름 프로젝트** | `bmad-quick-dev` 전 또는 중 | 빠른 구현이 패턴을 존중하도록 보장 |
+
+:::tip[권장]
+새 프로젝트에서 강한 기술 선호 사항이 있다면 아키텍처 전에 수동으로 만드세요. 그렇지 않다면 아키텍처 후 생성해 그 결정을 포착하세요.
+:::
+
+## 무엇이 들어가나요?
+
+파일에는 두 주요 섹션이 있습니다.
+
+### 기술 스택과 버전
+
+프로젝트가 사용하는 프레임워크, 언어, 도구를 구체적 버전과 함께 문서화합니다.
+
+```markdown
+## 기술 스택과 버전
+
+- Node.js 20.x, TypeScript 5.3, React 18.2
+- 상태 관리: Zustand(Redux 아님)
+- 테스트: Vitest, Playwright, MSW
+- 스타일링: 커스텀 디자인 토큰을 사용하는 Tailwind CSS
+```
+
+### 중요한 구현 규칙
+
+에이전트가 놓칠 수 있는 패턴과 관례를 문서화합니다.
+
+```markdown
+## 중요한 구현 규칙
+
+**TypeScript 설정:**
+- 엄격 모드 사용 - 명시적 승인 없이 `any` 타입 금지
+- 공개 API에는 `interface`, 유니언/인터섹션에는 `type` 사용
+
+**코드 구성:**
+- 컴포넌트는 `/src/components/`에 두고 `.test.tsx`를 함께 배치
+- 재사용 가능한 순수 함수는 `/src/lib/` 유틸리티에 배치
+- API 호출은 `apiClient` 싱글턴 사용 - 직접 fetch 금지
+
+**테스트 패턴:**
+- 단위 테스트는 구현 세부사항이 아니라 비즈니스 로직에 집중
+- 통합 테스트는 MSW로 API 응답을 모킹
+- E2E 테스트는 중요한 사용자 여정만 다룸
+
+**프레임워크별 규칙:**
+- 모든 비동기 작업은 일관된 오류 처리를 위해 `handleError` 래퍼 사용
+- 기능 플래그는 `@/lib/flags`의 `featureFlag()`로 접근
+- 새 라우트는 `/src/app/`의 파일 기반 라우팅 패턴을 따름
+```
+
+코드 스니펫을 읽고 에이전트가 추론하지 못할 **겉으로 잘 드러나지 않는 것**에 집중하세요. 보편적으로 적용되는 표준 관행은 문서화하지 마세요.
+
+## 파일 만들기
+
+세 가지 선택지가 있습니다.
+
+### 수동 작성
+
+`_bmad-output/project-context.md`에 파일을 만들고 규칙을 추가합니다.
+
+```bash
+# 프로젝트 루트에서
+mkdir -p _bmad-output
+touch _bmad-output/project-context.md
+```
+
+기술 스택과 구현 규칙을 편집하세요. 아키텍트와 구현 워크플로가 자동으로 찾아 로드합니다.
+
+### 아키텍처 후 생성
+
+아키텍처를 완료한 뒤 `bmad-generate-project-context` 워크플로를 실행합니다.
+
+```bash
+bmad-generate-project-context
+```
+
+이 워크플로는 아키텍처 문서와 프로젝트 파일을 스캔해 내려진 결정을 담은 컨텍스트 파일을 생성합니다.
+
+### 기존 프로젝트용 생성
+
+기존 프로젝트에서는 `bmad-generate-project-context`를 실행해 기존 패턴을 발견합니다.
+
+```bash
+bmad-generate-project-context
+```
+
+워크플로가 코드베이스를 분석해 관례를 식별한 뒤 검토하고 다듬을 수 있는 컨텍스트 파일을 생성합니다.
+
+## 왜 중요한가
+
+`project-context.md`가 없으면 에이전트는 프로젝트에 맞지 않는 가정을 할 수 있습니다.
+
+| 컨텍스트 없음 | 컨텍스트 있음 |
+| --- | --- |
+| 일반 패턴 사용 | 기존 관례 따름 |
+| 스토리마다 일관되지 않은 스타일 | 일관된 구현 |
+| 프로젝트별 제약을 놓칠 수 있음 | 모든 기술 요구사항 존중 |
+| 각 에이전트가 독립적으로 결정 | 모든 에이전트가 같은 규칙에 맞춰 동작 |
+
+특히 다음에 중요합니다.
+
+- **빠른 흐름** - PRD와 아키텍처를 건너뛰므로 컨텍스트 파일이 공백을 채웁니다
+- **팀 프로젝트** - 모든 에이전트가 같은 표준을 따르게 합니다
+- **기존 프로젝트** - 기존 패턴을 깨뜨리지 않게 합니다
+
+## 편집과 업데이트
+
+`project-context.md` 파일은 살아 있는 문서입니다. 다음 때 업데이트하세요.
+
+- 아키텍처 결정이 바뀝니다
+- 새 관례가 확립됩니다
+- 구현 중 패턴이 진화합니다
+- 에이전트 동작에서 공백을 발견합니다
+
+언제든 수동으로 편집하거나, 큰 변경 후 `bmad-generate-project-context`를 다시 실행해 업데이트할 수 있습니다.
+
+:::note[파일 위치]
+기본 위치는 `_bmad-output/project-context.md`입니다. 워크플로는 그곳을 검색하고, 프로젝트 어디에 있든 `**/project-context.md`도 확인합니다.
+:::

docs/ko-kr/explanation/quick-dev.md

@@ -0,0 +1,73 @@
+---
+title: "빠른 개발"
+description: 출력 품질을 보호하는 체크포인트를 포기하지 않고 사람이 개입하는 검토의 마찰을 줄입니다
+sidebar:
+  order: 4
+---
+
+의도를 넣으면 코드 변경이 나오고, 사람이 개입하는 검토 단계는 가능한 한 적게 사용합니다. 품질은 희생하지 않습니다.
+
+모델이 체크포인트 사이에서 더 오래 실행되게 한 뒤, 작업이 인간 판단 없이 안전하게 계속될 수 없거나 최종 결과를 리뷰할 때만 사람을 다시 불러옵니다.
+
+![빠른 개발 워크플로 다이어그램](/diagrams/quick-dev-diagram.png)
+
+## 왜 존재하나요?
+
+사람이 개입하는 검토 단계는 필요하지만 비용이 큽니다.
+
+현재 LLM은 여전히 예측 가능한 방식으로 실패합니다. 의도를 잘못 읽고, 공백을 자신 있게 추측으로 채우고, 관련 없는 작업으로 흐름이 새며, 잡음 많은 리뷰 출력을 만듭니다. 동시에 지속적인 인간 개입은 개발 속도를 제한합니다. 사람의 주의력이 병목이 됩니다.
+
+`bmad-quick-dev`는 이 절충점을 다시 조정합니다. 워크플로가 안전을 위한 충분히 강한 경계를 만든 뒤에는 모델이 더 긴 구간을 감독 없이 실행하도록 신뢰합니다.
+
+## 핵심 설계
+
+### 1. 먼저 의도를 압축합니다
+
+워크플로는 사람과 모델이 요청을 하나의 일관된 목표로 압축하는 것에서 시작합니다. 입력은 거친 의도 표현일 수 있지만, 워크플로가 자율적으로 실행되기 전에는 실행 가능한 만큼 작고, 명확하고, 모순이 없어야 합니다.
+
+의도는 다양한 형태로 올 수 있습니다. 몇 문구, 버그 추적기 링크, 계획 모드 출력, 채팅 세션에서 복사한 텍스트, 또는 BMAD의 `epics.md`에 있는 스토리 번호일 수 있습니다. 마지막 경우 워크플로는 BMAD 스토리 추적 규칙을 이해하지는 않지만, 스토리 자체를 가져와 실행할 수 있습니다.
+
+이 워크플로는 인간 통제를 없애지 않습니다. 통제를 소수의 가치가 큰 순간으로 옮깁니다.
+
+- **의도 명확화** - 정돈되지 않은 요청을 숨은 모순 없는 하나의 일관된 목표로 바꿉니다
+- **사양 승인** - 고정된 이해가 만들 올바른 것인지 확인합니다
+- **최종 결과 검토** - 최종 결과를 받아들일 수 있는지 사람이 결정하는 핵심 체크포인트입니다
+
+### 2. 가장 작은 안전한 경로를 선택합니다
+
+목표가 명확해지면 워크플로는 정말 한 번에 처리 가능한 변경인지, 더 완전한 경로가 필요한지 결정합니다. 작고 영향 범위가 거의 없는 변경은 바로 구현으로 갈 수 있습니다. 그 밖의 모든 것은 모델이 더 오래 혼자 실행되기 전에 더 강한 경계를 갖도록 계획을 거칩니다.
+
+### 3. 더 적은 감독으로 더 오래 실행합니다
+
+경로 결정 이후 모델은 더 많은 작업을 스스로 수행할 수 있습니다. 더 완전한 경로에서는 승인된 사양이 모델이 적은 감독으로 실행하는 경계가 되며, 이것이 설계의 핵심입니다.
+
+### 4. 올바른 계층에서 실패를 진단합니다
+
+의도가 틀려 구현이 틀렸다면 코드 패치는 잘못된 수정입니다. 사양이 약해서 코드가 틀렸다면 diff 패치도 잘못된 수정입니다. 워크플로는 실패가 시스템에 들어온 계층을 진단하고, 그 계층으로 돌아가 다시 생성하도록 설계되었습니다.
+
+리뷰 발견 사항은 문제가 의도, 사양 생성, 로컬 구현 중 어디에서 왔는지 결정하는 데 쓰입니다. 정말 로컬 문제만 로컬 패치를 받습니다.
+
+### 5. 필요할 때만 사람을 다시 부릅니다
+
+의도 인터뷰는 사람이 개입하는 과정이지만 반복 체크포인트와는 다른 중단입니다. 워크플로는 반복 체크포인트를 최소화하려 합니다. 초기 구체화 이후 사람은 워크플로가 판단 없이 안전하게 계속할 수 없을 때와 마지막 리뷰 시점에 주로 돌아옵니다.
+
+- **의도 공백 해소** - 리뷰가 워크플로가 의도를 안전하게 추론할 수 없었음을 보여줄 때 다시 들어옵니다
+
+나머지는 더 긴 자율 실행 후보입니다. 이 절충은 의도적입니다. 오래된 패턴은 지속적인 감독에 더 많은 사람의 주의력을 씁니다. 빠른 개발은 모델에 더 많은 신뢰를 주지만, 사람의 판단이 가장 큰 효과를 내는 순간을 위해 주의력을 아낍니다.
+
+## 리뷰 시스템이 중요한 이유
+
+리뷰 단계는 버그를 찾기 위해서만 있는 것이 아닙니다. 추진력을 잃지 않고 수정을 올바른 경로로 보내기 위해 있습니다.
+
+이 워크플로는 하위 에이전트를 생성할 수 있거나, 적어도 명령줄로 다른 LLM을 호출하고 결과를 기다릴 수 있는 플랫폼에서 가장 잘 동작합니다. 플랫폼이 기본으로 지원하지 않는다면 이를 수행하는 스킬을 추가할 수 있습니다. 컨텍스트 없는 하위 에이전트는 리뷰 설계의 핵심입니다.
+
+에이전트 기반 리뷰는 보통 두 방식으로 잘못됩니다.
+
+- 발견 사항이 너무 많아 사람이 노이즈를 걸러야 합니다.
+- 관련 없는 이슈를 끌어들여 현재 변경의 흐름을 깨고, 모든 실행을 즉석 정리 작업으로 바꿉니다.
+
+빠른 개발은 리뷰를 분류 작업으로 다뤄 둘 다 해결합니다.
+
+어떤 발견 사항은 현재 변경에 속합니다. 어떤 발견 사항은 그렇지 않습니다. 발견 사항이 현재 작업과 인과적으로 연결되지 않은 부수적 이슈라면, 워크플로는 즉시 처리하도록 강제하지 않고 미룰 수 있습니다. 이렇게 하면 실행이 집중되고 무작위 곁가지가 주의력 예산을 소비하지 않습니다.
+
+분류는 때때로 완벽하지 않습니다. 괜찮습니다. 수천 개의 낮은 가치 리뷰 댓글로 사람을 압도하는 것보다 일부 발견 사항을 잘못 판단하는 편이 보통 낫습니다. 이 시스템은 모든 이슈를 빠짐없이 회수하는 것보다 신호 품질을 최적화합니다.

docs/ko-kr/explanation/why-solutioning-matters.md

@@ -0,0 +1,77 @@
+---
+title: "솔루션 설계가 중요한 이유"
+description: 다중 에픽 프로젝트에서 솔루션 설계 단계가 중요한 이유
+sidebar:
+  order: 6
+---
+
+단계 3(솔루션 설계)은 계획 단계의 **무엇을** 만들지를 **어떻게** 만들지로 바꿉니다. 구현이 시작되기 전에 아키텍처 결정을 문서화해 다중 에픽 프로젝트에서 에이전트 충돌을 방지합니다.
+
+## 솔루션 설계가 없을 때의 문제
+
+```text
+에이전트 1은 에픽 1을 REST API로 구현
+에이전트 2는 에픽 2를 GraphQL로 구현
+결과: 일관되지 않은 API 설계와 통합 난이도 증가
+```
+
+여러 에이전트가 공유 아키텍처 지침 없이 시스템의 서로 다른 부분을 구현하면 서로 충돌하는 독립적 기술 결정을 내릴 수 있습니다.
+
+## 솔루션 설계가 있을 때의 해결책
+
+```text
+아키텍처 워크플로가 결정: "모든 API에 GraphQL 사용"
+모든 에이전트가 아키텍처 결정을 따름
+결과: 일관된 구현, 충돌 없음
+```
+
+기술 결정을 명시적으로 문서화하면 모든 에이전트가 일관되게 구현하고 통합이 단순해집니다.
+
+## 솔루션 설계 vs 계획
+
+| 측면 | 계획 (단계 2) | 솔루션 설계 (단계 3) |
+| --- | --- | --- |
+| 질문 | 무엇을, 왜? | 어떻게? 그리고 어떤 작업 단위로? |
+| 출력 | FRs/NFRs(요구사항) | 아키텍처 + 에픽/스토리 |
+| 에이전트 | PM | 아키텍트 → PM |
+| 대상 | 이해관계자 | 개발자 |
+| 문서 | PRD(기능/비기능 요구사항) | 아키텍처 + 에픽 파일 |
+| 수준 | 비즈니스 로직 | 기술 설계 + 작업 분해 |
+
+## 핵심 원칙
+
+**기술 결정을 명시적으로 문서화**해 모든 에이전트가 일관되게 구현하도록 합니다.
+
+이것은 다음을 방지합니다.
+
+- API 스타일 충돌(REST vs GraphQL)
+- 데이터베이스 설계 불일치
+- 상태 관리 방식 차이
+- 이름 규칙 불일치
+- 보안 접근 방식 차이
+
+## 솔루션 설계가 필요한 때
+
+| 트랙 | 솔루션 설계 필요 여부 |
+| --- | --- |
+| 빠른 흐름 | 아니요 - 완전히 건너뜁니다 |
+| BMad Method 단순 | 선택 사항 |
+| BMad Method 복잡 | 예 |
+| 엔터프라이즈 | 예 |
+
+:::tip[경험칙]
+서로 다른 에이전트가 구현할 수 있는 여러 에픽이 있다면 솔루션 설계가 필요합니다.
+:::
+
+## 건너뛸 때의 비용
+
+복잡한 프로젝트에서 솔루션 설계를 건너뛰면 다음으로 이어집니다.
+
+- 스프린트 중 발견되는 **통합 이슈**
+- 충돌하는 구현으로 인한 **재작업**
+- 전체적으로 **더 긴 개발 시간**
+- 일관되지 않은 패턴에서 생기는 **기술 부채**
+
+:::caution[비용 배율]
+방향이 어긋나는 문제를 솔루션 설계에서 잡는 것이 구현 중 발견하는 것보다 10배 빠릅니다.
+:::

docs/ko-kr/how-to/customize-bmad.md

@@ -0,0 +1,387 @@
+---
+title: 'BMad 커스터마이징 방법'
+description: 업데이트 호환성을 유지하면서 에이전트와 워크플로를 커스터마이징합니다
+sidebar:
+  order: 8
+---
+
+설치된 파일을 수정하지 않고 에이전트 페르소나를 조정하고, 도메인 컨텍스트를 주입하고, 기능을 추가하고, 워크플로 동작을 설정하세요. 커스터마이징은 업데이트 후에도 유지됩니다.
+
+:::tip[TOML을 직접 쓰고 싶지 않나요? `bmad-customize`를 사용하세요]
+`bmad-customize` 스킬은 이 문서에서 설명하는 **스킬별 에이전트/워크플로 오버라이드 영역**을 안내형으로 작성해 주는 도우미입니다. 설치된 항목 중 무엇을 커스터마이즈할 수 있는지 스캔하고, 의도에 맞는 영역(에이전트 또는 워크플로)을 고르게 하고, 오버라이드 파일을 작성하고, 병합이 적용되었는지 검증합니다. 중앙 설정 오버라이드(`_bmad/custom/config.toml`)는 v1 범위 밖이므로 아래 중앙 설정 섹션에 따라 직접 작성해야 합니다.
+:::
+
+## 사용 시점
+
+- 에이전트의 성격이나 커뮤니케이션 스타일을 바꾸고 싶습니다
+- 에이전트가 계속 기억할 사실이 필요합니다(예: "우리 조직은 AWS만 사용")
+- 매 세션 시작 시 에이전트가 반드시 수행해야 하는 절차적 단계를 추가하고 싶습니다
+- 자체 스킬이나 프롬프트를 실행하는 커스텀 메뉴 항목을 추가하고 싶습니다
+- 팀 공통 커스터마이징은 git에 커밋하고, 개인 선호는 그 위에 덧씌우고 싶습니다
+
+:::note[필수 조건]
+
+- 프로젝트에 BMad 설치([BMad 설치 방법](./install-bmad.md) 참고)
+- PATH의 Python 3.11+(병합 스크립트용, stdlib `tomllib`만 사용하며 `pip install`, `uv`, virtualenv 불필요)
+- TOML 파일을 편집할 텍스트 에디터
+:::
+
+## 작동 방식
+
+커스터마이즈 가능한 모든 스킬은 기본값이 들어 있는 `customize.toml` 파일을 제공합니다. 이 파일은 스킬의 전체 커스터마이징 영역을 정의합니다. 무엇을 바꿀 수 있는지 보려면 이 파일을 읽으세요. 이 파일은 직접 편집하지 않습니다. 대신 바꾸려는 필드만 담은 오버라이드 파일을 만듭니다.
+
+### 3계층 오버라이드 모델
+
+```text
+우선순위 1(승리): _bmad/custom/{skill-name}.user.toml  (개인, git 무시)
+우선순위 2:        _bmad/custom/{skill-name}.toml        (팀/조직, 커밋)
+우선순위 3(마지막): 스킬 자체 customize.toml              (기본값)
+```
+
+`_bmad/custom/` 폴더는 처음엔 비어 있습니다. 누군가 실제로 커스터마이즈할 때만 파일이 생깁니다.
+
+### 병합 규칙(필드명이 아니라 모양 기준)
+
+병합 스크립트는 네 가지 구조 규칙을 적용합니다. 필드명은 특별 취급되지 않습니다. 값의 구조가 동작을 결정합니다.
+
+| 모양 | 규칙 |
+| --- | --- |
+| 스칼라 값(문자열, 정수, 불리언, 실수) | 오버라이드가 이깁니다 |
+| 테이블 | 깊은 병합(재귀적으로 이 규칙을 적용) |
+| 모든 항목이 **같은** 식별자 필드(`code` 또는 `id`)를 공유하는 테이블 배열 | 해당 키로 병합합니다. 같은 키는 **제자리에서 교체**, 새 키는 **추가**됩니다 |
+| 그 밖의 배열(스칼라 값, 식별자가 없는 테이블, `code`와 `id`가 섞인 배열) | **추가**됩니다. 기본값, 팀, 사용자 순서입니다 |
+
+**삭제 메커니즘은 없습니다.** 오버라이드는 기본값 항목을 지울 수 없습니다. 기본 메뉴 항목을 숨겨야 한다면 같은 `code`로 동작 없는 설명이나 프롬프트를 넣어 덮어쓰세요. 배열을 더 깊게 재구성해야 한다면 스킬을 포크하세요.
+
+**`code` / `id` 관례.** BMad는 테이블 배열의 병합 키로 `code`(예: `"BP"`, `"R1"` 같은 짧은 식별자)와 `id`(더 긴 안정 식별자)를 사용합니다. 직접 만든 테이블 배열이 추가 전용이 아니라 키로 교체 가능해야 한다면 한 가지 관례만 고르고 전체 배열에서 일관되게 사용하세요. 일부 항목은 `code`, 일부 항목은 `id`를 쓰면 키 병합 대신 추가 방식으로 처리됩니다.
+
+### 일부 에이전트 필드는 읽기 전용입니다
+
+`agent.name`과 `agent.title`은 기준 메타데이터로 `customize.toml`에 있지만, 에이전트의 SKILL.md는 런타임에 이를 읽지 않습니다. 정체성은 하드코딩되어 있습니다. 오버라이드 파일에 `name = "Bob"`을 넣어도 효과가 없습니다. 정말 다른 이름의 에이전트가 필요하다면 스킬 폴더를 복사해 이름을 바꾸고 커스텀 스킬로 배포하세요.
+
+## 단계
+
+### 1. 스킬의 커스터마이징 영역 찾기
+
+설치된 디렉터리에서 스킬의 `customize.toml`을 확인합니다. PM 에이전트 예:
+
+```text
+.claude/skills/bmad-agent-pm/customize.toml
+```
+
+경로는 IDE별로 다릅니다. Cursor는 `.cursor/skills/`, Cline은 `.cline/skills/`를 사용합니다.
+
+이 파일이 기준 스키마입니다. 읽기 전용 정체성 필드를 제외하고 보이는 모든 필드는 커스터마이즈할 수 있습니다.
+
+### 2. 오버라이드 파일 만들기
+
+프로젝트 루트에 `_bmad/custom/` 디렉터리가 없다면 만듭니다. 그런 다음 스킬 이름을 딴 파일을 만듭니다.
+
+```text
+_bmad/custom/
+  bmad-agent-pm.toml        # 팀 오버라이드(git에 커밋)
+  bmad-agent-pm.user.toml   # 개인 선호(git에서 무시)
+```
+
+:::caution[전체 `customize.toml`을 복사하지 마세요]
+오버라이드 파일은 **희소**입니다. 바꾸는 필드만 포함하세요. 생략한 필드는 아래 계층(팀은 기본값에서, 사용자는 팀 또는 기본값에서) 자동 상속됩니다.
+
+전체 `customize.toml`을 오버라이드로 복사하면 해롭습니다. 다음 업데이트가 새 기본값을 제공해도 오버라이드 파일이 옛 값을 고정하기 때문에 릴리스마다 조용히 어긋납니다.
+:::
+
+**예시 - 아이콘을 바꾸고 원칙 하나 추가:**
+
+```toml
+# _bmad/custom/bmad-agent-pm.toml
+# 바꾸는 필드만 둡니다. 나머지는 모두 상속됩니다.
+
+[agent]
+icon = "🏥"
+principles = [
+  "FDA 감사를 통과할 수 없는 것은 출시하지 않습니다.",
+]
+```
+
+이 설정은 새 원칙을 기본값에 추가하고(제공된 원칙은 그대로 유지), 아이콘을 교체합니다. 나머지 필드는 제공된 값으로 남습니다.
+
+### 3. 필요한 항목 커스터마이즈하기
+
+아래 예시는 BMad의 평면 에이전트 스키마를 가정합니다. 필드는 `[agent]` 아래에 직접 위치하며 중첩된 `metadata`나 `persona` 하위 테이블은 없습니다.
+
+**스칼라 값(icon, 역할, 정체성, communication_style).** 스칼라 값 오버라이드가 이깁니다. 바꾸는 필드만 설정하면 됩니다.
+
+```toml
+# _bmad/custom/bmad-agent-pm.toml
+
+[agent]
+icon = "🏥"
+role = "규제 대상 헬스케어 도메인의 제품 발견을 이끕니다."
+communication_style = "정밀하고 규제를 의식하며, 초반부터 컴플라이언스 관점의 질문을 던집니다."
+```
+
+**영구 사실, 원칙, 활성화 후크(추가 배열).** 아래 네 배열은 추가 전용입니다. 팀 항목은 기본값 뒤에 실행되고, 사용자 항목은 마지막에 실행됩니다.
+
+```toml
+[agent]
+# 에이전트가 세션 내내 염두에 둘 정적 사실입니다. 조직 규칙, 도메인
+# 상수, 사용자 선호 등이 여기에 들어갑니다. 런타임 메모리 사이드카와는 다릅니다.
+#
+# 각 항목은 문장 그대로이거나, 내용을 사실로 로드하는 `file:` 참조입니다
+# glob 패턴도 지원합니다.
+persistent_facts = [
+  "우리 조직은 AWS만 사용합니다. GCP나 Azure를 제안하지 마세요.",
+  "모든 PRD는 엔지니어링 착수 전에 법무 승인을 받아야 합니다.",
+  "대상 사용자는 환자가 아니라 임상의입니다. 예시도 그에 맞춰 구성하세요.",
+  "file:{project-root}/docs/compliance/hipaa-overview.md",
+  "file:{project-root}/_bmad/custom/company-glossary.md",
+]
+
+# 에이전트의 가치 체계에 추가합니다
+principles = [
+  "FDA 감사를 통과할 수 없는 것은 출시하지 않습니다.",
+  "사용자 가치를 먼저, 컴플라이언스는 항상 지킵니다.",
+]
+
+# 표준 활성화(페르소나, persistent_facts, 설정, 인사) 전에 실행합니다.
+activation_steps_prepend = [
+  "{project-root}/docs/compliance/를 스캔하고 HIPAA 관련 문서를 컨텍스트로 로드하세요.",
+]
+
+# 인사 후, 메뉴 전에 실행합니다.
+activation_steps_append = [
+  "{project-root}/_bmad/custom/company-glossary.md가 있으면 읽으세요.",
+]
+```
+
+두 후크는 역할이 다릅니다. Prepend는 인사 전에 실행되어 인사 자체를 개인화하는 데 필요한 컨텍스트를 로드할 수 있습니다. Append는 인사 후 실행되어 무거운 스캔이 끝날 때까지 사용자가 빈 화면만 보지 않게 합니다.
+
+**메뉴 커스터마이징(`code`로 병합).** 메뉴는 테이블 배열입니다. 각 항목에는 `code` 필드가 있으므로 병합 스크립트는 코드로 병합합니다. 같은 코드는 제자리에서 교체되고, 새 코드는 추가됩니다.
+
+TOML 테이블 배열 문법은 항목마다 `[[agent.menu]]`를 사용합니다.
+
+```toml
+# 기존 CE 항목을 커스텀 스킬로 교체
+[[agent.menu]]
+code = "CE"
+description = "우리 전달 프레임워크로 에픽 생성"
+skill = "custom-create-epics"
+
+# 새 항목 추가(기본값에는 RC 코드가 없음)
+[[agent.menu]]
+code = "RC"
+description = "컴플라이언스 사전 점검 실행"
+prompt = """
+{project-root}/_bmad/custom/compliance-checklist.md를 읽고
+{planning_artifacts}의 모든 문서를 그 기준에 맞춰 스캔하세요.
+공백이 있으면 관련 규제 조항을 인용해 보고하세요.
+"""
+```
+
+각 메뉴 항목은 `skill`(등록된 스킬 호출) 또는 `prompt`(텍스트 직접 실행) 중 정확히 하나를 가집니다. 오버라이드에 나열하지 않은 항목은 기본값을 유지합니다.
+
+**파일 참조.** `persistent_facts`, `activation_steps_prepend`/`activation_steps_append`, 메뉴 항목의 `prompt`처럼 텍스트가 파일을 가리켜야 할 때는 `{project-root}`를 기준으로 한 전체 경로를 사용하세요. 파일이 `_bmad/custom/`에서 오버라이드 옆에 있더라도 `{project-root}/_bmad/custom/info.md`처럼 전체 경로를 적습니다.
+
+### 4. 개인 vs 팀
+
+**팀 파일**(`bmad-agent-pm.toml`): git에 커밋합니다. 조직 전체에 공유됩니다. 컴플라이언스 규칙, 회사 페르소나, 커스텀 기능에 사용합니다.
+
+**개인 파일**(`bmad-agent-pm.user.toml`): 자동으로 git에서 무시됩니다. 말투 조정, 개인 워크플로 선호 사항, 에이전트가 기억해야 하는 개인 사실에 사용합니다.
+
+```toml
+# _bmad/custom/bmad-agent-pm.user.toml
+
+[agent]
+persistent_facts = [
+  "선택지를 제시할 때 항상 대략적인 복잡도 추정(낮음/중간/높음)을 포함하세요.",
+]
+```
+
+## 해석이 작동하는 방식
+
+활성화 시 에이전트의 SKILL.md가 공유 Python 스크립트를 실행해 3계층 병합을 수행하고 해석된 블록을 JSON으로 반환합니다. 스크립트는 Python 표준 라이브러리의 `tomllib`만 사용하므로 기본 `python3`이면 충분합니다.
+
+```bash
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill {skill-root} \
+  --key agent
+```
+
+**요구사항**: Python 3.11+(이전 버전에는 `tomllib`이 없습니다). `pip install`, `uv`, virtualenv는 필요 없습니다. `python3 --version`으로 확인하세요. Homebrew 없는 macOS나 Ubuntu 22.04 같은 플랫폼은 기본 `python3`이 3.10 이하일 수 있으므로 3.11+를 별도 설치해야 할 수 있습니다.
+
+`--skill`은 스킬이 설치된 디렉터리(`customize.toml`이 있는 위치)를 가리킵니다. 스킬 이름은 디렉터리의 basename에서 파생되며, 스크립트는 `_bmad/custom/{skill-name}.toml`과 `{skill-name}.user.toml`을 자동으로 찾습니다.
+
+유용한 호출:
+
+```bash
+# 전체 에이전트 블록 해석
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /abs/path/to/bmad-agent-pm \
+  --key agent
+
+# 단일 필드 해석
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /abs/path/to/bmad-agent-pm \
+  --key agent.icon
+
+# 전체 덤프
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /abs/path/to/bmad-agent-pm
+```
+
+출력은 항상 JSON입니다. 특정 플랫폼에서 스크립트를 사용할 수 없다면 SKILL.md는 에이전트에게 세 TOML 파일을 직접 읽고 같은 병합 규칙을 적용하라고 지시합니다.
+
+## 워크플로 커스터마이징
+
+`bmad-product-brief`처럼 여러 단계 프로세스를 구동하는 워크플로(스킬)도 에이전트와 같은 오버라이드 메커니즘을 공유합니다. 커스터마이즈 가능한 영역은 `[agent]` 대신 `[workflow]` 아래에 있습니다.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+activation_steps_prepend = [
+  "Load {project-root}/docs/product/north-star-principles.md as context.",
+]
+
+activation_steps_append = []
+
+persistent_facts = [
+  "모든 개요에는 명시적인 규제 위험 섹션이 포함되어야 합니다.",
+  "file:{project-root}/docs/compliance/product-brief-checklist.md",
+]
+
+on_complete = "개요를 세 개의 글머리표로 요약하고 gws-gmail-send 스킬로 이메일 발송을 제안하세요."
+```
+
+동일한 필드 관례가 에이전트/워크플로 경계를 넘습니다. `activation_steps_prepend`/`activation_steps_append`, `persistent_facts`(`file:` 참조 포함), 그리고 키 기반 병합용 `code`/`id`가 있는 메뉴 스타일 `[[...]]` 테이블이 모두 같은 방식으로 동작합니다. 병합 스크립트는 최상위 키와 관계없이 네 구조 규칙을 적용합니다. SKILL.md 참조는 네임스페이스를 따릅니다: `{workflow.activation_steps_prepend}`, `{workflow.persistent_facts}`, `{workflow.on_complete}`. 워크플로가 노출하는 추가 필드(출력 경로, 토글, 리뷰 설정, 단계 플래그 등)도 같은 구조 기반 병합 규칙을 따릅니다. 무엇을 커스터마이즈할 수 있는지는 워크플로의 `customize.toml`을 읽으세요.
+
+### 활성화 순서
+
+커스터마이즈 가능한 워크플로는 후크가 언제 실행되는지 알 수 있도록 고정된 순서로 활성화됩니다.
+
+1. `[workflow]` 블록 해석(기본값 → 팀 → 사용자 병합)
+2. `activation_steps_prepend`를 순서대로 실행
+3. 실행의 기반 컨텍스트로 `persistent_facts` 로드
+4. 설정(`_bmad/bmm/config.yaml`) 로드 및 표준 변수(프로젝트 이름, 언어, 경로, 날짜) 해석
+5. 사용자에게 인사
+6. `activation_steps_append`를 순서대로 실행
+
+6단계 이후 워크플로 본문이 시작됩니다. 인사를 개인화하기 전에 컨텍스트가 필요하면 `activation_steps_prepend`를 사용하고, 설정이 무거워 사용자에게 인사를 먼저 보여주고 싶다면 `activation_steps_append`를 사용하세요.
+
+### 현재 초기 단계의 범위
+
+커스터마이징은 점진적으로 출시됩니다. 위에서 문서화한 `activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`는 모든 커스터마이즈 가능한 워크플로가 노출하는 **기준 영역**이며 버전 간 안정적으로 유지됩니다. 오늘 당장 사전/사후 단계 주입, 기반 컨텍스트 고정, 후속 작업 트리거 같은 큰 단위의 제어를 제공합니다.
+
+시간이 지나면 개별 워크플로가 실제로 하는 일에 맞춘 **더 세밀한 커스터마이징 지점**을 노출할 것입니다. 단계별 토글, 단계 플래그, 출력 템플릿 경로, 리뷰 게이트 같은 것들입니다. 그런 항목이 추가되면 기준 필드를 대체하지 않고 그 위에 쌓이므로 오늘 작성한 커스터마이징은 계속 동작합니다.
+
+아직 노출되지 않은 세밀한 조절점이 필요하다면 `activation_steps_*`와 `persistent_facts`로 동작을 조정하거나, 원하는 커스터마이징 지점을 구체적으로 설명하는 이슈를 열어 주세요.
+
+## 중앙 설정
+
+스킬별 `customize.toml`은 **깊은 동작**(후크, 메뉴, persistent_facts, 단일 에이전트/워크플로의 페르소나 오버라이드)을 다룹니다. 별도 영역은 **공유 상태**를 다룹니다. 설치 답변과 `bmad-party-mode`, `bmad-retrospective`, `bmad-advanced-elicitation` 같은 외부 스킬이 사용하는 에이전트 명단입니다. 이 영역은 프로젝트 루트의 네 TOML 파일에 있습니다.
+
+```text
+_bmad/config.toml               (설치 프로그램 소유)  팀 범위:     설치 답변 + 에이전트 명단
+_bmad/config.user.toml          (설치 프로그램 소유)  사용자 범위: user_name, 언어, 스킬 수준
+_bmad/custom/config.toml        (사람이 작성)         팀 오버라이드(git에 커밋)
+_bmad/custom/config.user.toml   (사람이 작성)         개인 오버라이드(git에서 무시)
+```
+
+### 4계층 병합
+
+```text
+우선순위 1(승리): _bmad/custom/config.user.toml
+우선순위 2:        _bmad/custom/config.toml
+우선순위 3:        _bmad/config.user.toml
+우선순위 4(기반):  _bmad/config.toml
+```
+
+스킬별 커스터마이즈와 같은 구조 규칙을 사용합니다. 스칼라 값 오버라이드, 테이블 깊은 병합, `code`/`id` 키 기반 배열 병합, 그 밖의 배열 추가입니다.
+
+### 무엇이 어디에 있나요?
+
+설치 프로그램은 `module.yaml`의 각 프롬프트에 선언된 `scope:`에 따라 답변을 나눕니다.
+
+- `[core]`와 `[modules.<code>]` 섹션 - 설치 답변입니다. `team` 범위는 `_bmad/config.toml`에, `user` 범위는 `_bmad/config.user.toml`에 들어갑니다.
+- `[agents.<code>]` - 각 모듈의 `module.yaml` `agents:` 블록에서 추출한 에이전트 핵심 정보(코드, 이름, 직함, 아이콘, 설명, 팀)입니다. 항상 팀 범위입니다.
+
+### 편집 규칙
+
+- `_bmad/config.toml`과 `_bmad/config.user.toml`은 **설치할 때마다 재생성**됩니다. 읽기 전용 출력으로 취급하세요. 직접 수정하면 다음 설치에서 덮어쓰입니다. 설치 답변을 지속적으로 바꾸려면 설치 프로그램을 다시 실행하거나 `_bmad/custom/config.toml`에서 값을 덮어쓰세요.
+- `_bmad/custom/config.toml`과 `_bmad/custom/config.user.toml`은 설치 프로그램이 **절대 건드리지 않습니다**. 커스텀 에이전트, 에이전트 설명자 오버라이드, 팀 강제 설정, 설치 답변과 무관하게 고정하려는 값을 넣는 올바른 영역입니다.
+
+### 예시 - 에이전트 리브랜딩
+
+```toml
+# _bmad/custom/config.toml (git에 커밋, 모든 개발자에게 적용)
+
+[agents.bmad-agent-pm]
+description = "헬스케어 PM - 규제를 의식하고 이해관계자 중심이며, FDA 관점의 질문을 먼저 던집니다."
+icon = "🏥"
+```
+
+병합 스크립트가 설치 프로그램이 작성한 `[agents.bmad-agent-pm]` 위로 병합합니다. `bmad-party-mode`와 명단을 사용하는 스킬은 새 설명을 자동으로 사용합니다.
+
+### 예시 - 가상 에이전트 추가
+
+```toml
+# _bmad/custom/config.user.toml (개인용, git에서 무시)
+
+[agents.kirk]
+team = "startrek"
+name = "Captain James T. Kirk"
+title = "우주선 선장"
+icon = "🖖"
+description = "대담하고 규칙을 굽힐 줄 아는 지휘관입니다. 극적인 쉼표를 두고 말하며 지휘의 무게를 소리 내어 생각합니다."
+```
+
+스킬 폴더가 없어도 핵심 정보만으로 파티 모드가 Kirk를 하나의 목소리로 생성할 수 있습니다. `team` 필드로 필터링해 엔터프라이즈 승무원만 라운드테이블에 초대할 수 있습니다.
+
+### 예시 - 모듈 설치 설정 오버라이드
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "/shared/org-planning-artifacts"
+```
+
+오버라이드는 각 개발자가 로컬 설치 중 답한 값보다 우선합니다. 팀 관례를 고정할 때 유용합니다.
+
+### 어떤 영역을 사용할까요?
+
+| 필요 | 사용 |
+| --- | --- |
+| 모든 개발 워크플로에 MCP 도구 호출 추가 | 스킬별: `_bmad/custom/bmad-agent-dev.toml` `persistent_facts` |
+| 에이전트에 메뉴 항목 추가 | 스킬별: `_bmad/custom/bmad-agent-{role}.toml` `[[agent.menu]]` |
+| 워크플로의 출력 템플릿 교체 | 스킬별: `_bmad/custom/{workflow}.toml` 스칼라 값 오버라이드 |
+| 에이전트 공개 설명자 리브랜딩 | **중앙**: `_bmad/custom/config.toml` `[agents.<code>]` |
+| 커스텀 또는 가상 에이전트를 명단에 추가 | **중앙**: `_bmad/custom/config.*.toml` 새 `[agents.<code>]` 항목 |
+| 팀 강제 설치 설정 고정 | **중앙**: `_bmad/custom/config.toml` `[modules.<code>]` 또는 `[core]` |
+
+필요에 따라 한 프로젝트에서 두 영역을 함께 사용하세요.
+
+## 실전 예시
+
+에이전트가 실행하는 모든 워크플로에 걸친 동작 조정, 조직 관례 강제, Confluence와 Jira로 출력 게시, 에이전트 명단 커스터마이즈, 출력 템플릿 교체 같은 엔터프라이즈 지향 레시피는 [조직을 위해 BMad 확장하기](./expand-bmad-for-your-org.md)를 참고하세요.
+
+## 문제 해결
+
+**커스터마이징이 보이지 않나요?**
+
+- 파일이 `_bmad/custom/`에 올바른 스킬 이름으로 있는지 확인하세요
+- TOML 문법을 확인하세요. 문자열은 따옴표가 필요하고, 테이블 헤더는 `[section]`, 테이블 배열은 `[[section]]`입니다. 테이블의 스칼라 값 또는 배열 키는 해당 테이블의 `[[subtables]]`보다 먼저 와야 합니다
+- 에이전트의 경우 커스터마이징은 `[agent]` 아래에 있습니다. 그 헤더 아래에 쓴 필드는 다른 테이블 헤더가 시작될 때까지 `agent`에 속합니다
+- `agent.name`과 `agent.title`은 읽기 전용입니다. 오버라이드해도 효과가 없습니다
+
+**업데이트가 커스터마이징을 망가뜨렸나요?**
+
+- 전체 `customize.toml`을 오버라이드 파일에 복사했나요? **하지 마세요.** 오버라이드 파일은 바꾸는 필드만 포함해야 합니다. 전체 복사는 옛 기본값을 고정하고 릴리스마다 조용히 어긋납니다. 오버라이드를 변경분만 남기도록 줄이세요.
+
+**무엇을 커스터마이즈할 수 있는지 봐야 하나요?**
+
+- `bmad-customize` 스킬을 실행하세요. 프로젝트에 설치된 모든 커스터마이즈 가능한 스킬을 열거하고, 이미 오버라이드가 있는 항목을 보여주며, 추가 또는 업데이트 과정을 안내합니다
+- 또는 스킬의 `customize.toml`을 직접 읽으세요. `name`과 `title`을 제외하고 모든 필드가 커스터마이즈 가능합니다
+
+**초기화가 필요하나요?**
+
+- `_bmad/custom/`에서 오버라이드 파일을 삭제하세요. 스킬은 내장 기본값으로 돌아갑니다

docs/ko-kr/how-to/established-projects.md

@@ -0,0 +1,119 @@
+---
+title: '기존 프로젝트'
+description: 기존 코드베이스에서 BMad Method를 사용하는 방법
+sidebar:
+  order: 7
+---
+
+기존 프로젝트와 레거시 코드베이스에서 작업할 때 BMad Method를 효과적으로 사용하세요.
+
+이 가이드는 BMad Method로 기존 프로젝트에 적응하는 핵심 워크플로를 다룹니다.
+
+:::note[필수 조건]
+
+- BMad Method 설치(`npx bmad-method install`)
+- 작업하려는 기존 코드베이스
+- AI 기반 IDE(Claude Code 또는 Cursor) 접근 권한
+:::
+
+## 1단계: 완료된 계획 산출물 정리
+
+BMad 과정으로 모든 PRD 에픽과 스토리를 완료했다면 해당 파일을 정리하세요. 필요하다면 보관하거나 삭제하거나 버전 기록에 의존하세요. 다음 위치에 이 파일들을 계속 두지 마세요.
+
+- `docs/`
+- `_bmad-output/planning-artifacts/`
+- `_bmad-output/implementation-artifacts/`
+
+## 2단계: 프로젝트 컨텍스트 만들기
+
+:::tip[기존 프로젝트에 권장]
+`project-context.md`를 생성해 기존 코드베이스의 패턴과 규칙을 포착하세요. 이렇게 하면 변경을 구현할 때 AI 에이전트가 이미 자리 잡은 관례를 따릅니다.
+:::
+
+프로젝트 컨텍스트 생성 워크플로를 실행합니다.
+
+```bash
+bmad-generate-project-context
+```
+
+이 워크플로는 코드베이스를 스캔해 다음을 식별합니다.
+
+- 기술 스택과 버전
+- 코드 구성 패턴
+- 명명 규칙
+- 테스트 접근 방식
+- 프레임워크별 패턴
+
+생성된 파일을 검토하고 다듬거나, 원한다면 `_bmad-output/project-context.md`에 직접 만들 수 있습니다.
+
+[프로젝트 컨텍스트 자세히 알아보기](../explanation/project-context.md)
+
+## 3단계: 품질 높은 프로젝트 문서 유지
+
+`docs/` 폴더에는 프로젝트를 정확하게 나타내는 간결하고 잘 구성된 문서가 있어야 합니다.
+
+- 의도와 비즈니스 근거
+- 비즈니스 규칙
+- 아키텍처
+- 그 밖의 관련 프로젝트 정보
+
+복잡한 프로젝트라면 `bmad-document-project` 워크플로 사용을 고려하세요. 전체 프로젝트를 스캔하고 실제 현재 상태를 문서화하는 실행 시 선택 가능한 변형을 제공합니다.
+
+## 4단계: 도움 받기
+
+### BMad 도움말: 시작점
+
+**다음에 무엇을 해야 할지 확실하지 않을 때 언제든 `bmad-help`를 실행하세요.** 이 지능형 가이드는 다음을 수행합니다.
+
+- 프로젝트를 검사해 이미 완료된 작업을 확인합니다
+- 설치된 모듈을 기준으로 선택지를 보여줍니다
+- 자연어 질문을 이해합니다
+
+```
+bmad-help 기존 Rails 앱이 있는데 어디서 시작하면 좋나요?
+bmad-help 빠른 흐름과 전체 BMad Method는 무엇이 다른가요?
+bmad-help 사용할 수 있는 워크플로를 보여 주세요
+```
+
+BMad 도움말은 **모든 워크플로 끝에서 자동으로 실행되어** 다음에 무엇을 해야 할지 명확히 안내합니다.
+
+### 접근 방식 선택
+
+변경 범위에 따라 두 가지 주요 선택지가 있습니다.
+
+| 범위 | 권장 접근 방식 |
+| --- | --- |
+| **작은 업데이트나 추가** | `bmad-quick-dev`를 실행해 의도 정리, 계획, 구현, 리뷰를 하나의 워크플로에서 처리합니다. 전체 4단계 BMad Method는 과할 가능성이 큽니다. |
+| **큰 변경이나 추가** | 필요한 만큼만 엄격하게 적용하면서 BMad Method로 시작합니다. |
+
+### PRD 작성 중
+
+제품 개요를 만들거나 바로 PRD로 들어갈 때 에이전트가 다음을 하도록 확인하세요.
+
+- 기존 프로젝트 문서를 찾고 분석합니다
+- 현재 시스템에 대한 적절한 컨텍스트를 읽습니다
+
+에이전트를 명시적으로 안내할 수 있지만 목표는 새 기능이 기존 시스템과 잘 통합되게 하는 것입니다.
+
+### UX 고려 사항
+
+UX 작업은 선택 사항입니다. 결정 기준은 프로젝트에 UX가 있는지가 아니라 다음입니다.
+
+- UX 변경을 작업할 예정인지
+- 의미 있는 새 UX 디자인이나 패턴이 필요한지
+
+만족스러운 기존 화면을 단순히 업데이트하는 정도라면 전체 UX 과정은 필요하지 않습니다.
+
+### 아키텍처 고려 사항
+
+아키텍처를 진행할 때 아키텍트가 다음을 하도록 확인하세요.
+
+- 적절한 문서 파일을 사용합니다
+- 기존 코드베이스를 스캔합니다
+
+여기서는 특히 주의하세요. 이미 있는 것을 다시 만들거나 기존 아키텍처와 어긋나는 결정을 방지해야 합니다.
+
+## 더 보기
+
+- **[빠른 수정](./quick-fixes.md)** - 버그 수정과 임시 변경
+- **[기존 프로젝트 FAQ](../explanation/established-projects-faq.md)** - 기존 프로젝트 작업에 대한 일반 질문

docs/ko-kr/how-to/expand-bmad-for-your-org.md

@@ -0,0 +1,332 @@
+---
+title: '조직을 위해 BMad 확장하기'
+description: 포크 없이 BMad를 재구성하는 여섯 가지 커스터마이징 패턴 - 에이전트 전반 규칙, 워크플로 관례, 외부 게시, 템플릿 교체, 에이전트 명단 변경, 고급 통합 패턴
+sidebar:
+  order: 9
+---
+
+BMad의 커스터마이징 영역을 사용하면 설치된 파일을 수정하거나 스킬을 포크하지 않고도 조직에 맞게 동작을 바꿀 수 있습니다. 이 가이드는 대부분의 엔터프라이즈 요구를 다루는 여섯 가지 레시피를 소개합니다.
+
+:::note[필수 조건]
+
+- 프로젝트에 BMad 설치([BMad 설치 방법](./install-bmad.md) 참고)
+- 커스터마이징 모델 이해([BMad 커스터마이징 방법](./customize-bmad.md) 참고)
+- PATH의 Python 3.11+(병합 스크립트용, stdlib만 사용하며 `pip install` 불필요)
+:::
+
+:::tip[이 레시피 적용하기]
+아래 **스킬별 레시피**(레시피 1-4)는 `bmad-customize` 스킬을 실행하고 의도를 설명해 적용할 수 있습니다. 스킬이 적절한 영역을 고르고 오버라이드 파일을 작성하고 병합을 검증합니다. 레시피 5(에이전트 명단에 대한 중앙 설정 오버라이드)는 v1 스킬 범위 밖이라 직접 작성해야 합니다. 이 문서의 레시피는 *무엇을* 오버라이드할지의 참고 기준이고, `bmad-customize`는 에이전트/워크플로 영역의 *방법*을 처리합니다.
+:::
+
+## 3계층 모델
+
+레시피를 고르기 전에 오버라이드가 어디에 들어가는지 알아두세요.
+
+| 계층 | 오버라이드 위치 | 범위 |
+| --- | --- | --- |
+| **에이전트**(예: Amelia, Mary, John) | `_bmad/custom/bmad-agent-{role}.toml`의 `[agent]` 섹션 | 에이전트를 통해 실행되는 **모든 워크플로**에 페르소나와 함께 이동 |
+| **워크플로**(예: 제품 개요, PRD 생성) | `_bmad/custom/{workflow-name}.toml`의 `[workflow]` 섹션 | 해당 워크플로 실행에만 적용 |
+| **중앙 설정** | `_bmad/custom/config.toml`의 `[agents.*]`, `[core]`, `[modules.*]` | 에이전트 명단(파티 모드, 회고, 도출에서 누가 가능한지), 조직 전체로 고정된 설치 시 설정 |
+
+경험칙: 규칙이 엔지니어의 모든 개발 작업에 적용되어야 한다면 **개발자 에이전트**를 커스터마이즈하세요. 제품 개요를 쓸 때만 적용된다면 **제품 개요 워크플로**를 커스터마이즈하세요. *방에 누가 있는지*를 바꾸는 일(에이전트 이름 변경, 커스텀 목소리 추가, 공유 산출물 경로 강제)은 **중앙 설정**을 편집하세요.
+
+## 레시피 1: 에이전트가 실행하는 모든 워크플로에 규칙 적용
+
+**사용 사례:** 에이전트를 통해 실행되는 모든 워크플로가 같은 도구 사용과 외부 시스템 통합 규칙을 상속하도록 표준화합니다. 가장 영향력이 큰 패턴입니다.
+
+**예시: Amelia 개발자 에이전트가 라이브러리 문서는 항상 Context7을 사용하고, 에픽 목록에 스토리가 없으면 Linear를 대체 경로로 사용합니다.**
+
+```toml
+# _bmad/custom/bmad-agent-dev.toml
+
+[agent]
+
+# 모든 활성화에 적용됩니다. Amelia가 실행하는 모든 스킬
+# 스토리 구현, 빠른 개발, 스토리 생성, 코드 리뷰, QA 생성으로 이어집니다.
+persistent_facts = [
+  "라이브러리 문서(React, TypeScript, Zod, Prisma 등)를 찾을 때는 학습 데이터 지식에 의존하기 전에 context7 MCP 도구(`mcp__context7__resolve_library_id`, 이후 `mcp__context7__get_library_docs`)를 호출하세요. 최신 문서가 기억된 API보다 우선합니다.",
+  "스토리 참조를 {planning_artifacts}/epics-and-stories.md에서 찾을 수 없으면 사용자에게 확인을 요청하기 전에 스토리 ID나 제목으로 Linear의 `mcp__linear__search_issues`를 검색하세요. Linear가 일치 항목을 반환하면 권위 있는 스토리 소스로 취급하세요.",
+]
+```
+
+**왜 동작하나요:** 두 문장이 조직의 모든 개발 워크플로를 재구성합니다. 워크플로마다 반복하지 않아도 되고 소스 변경도 없습니다. 저장소를 가져오는 모든 새 엔지니어가 자동으로 관례를 상속합니다.
+
+**팀 파일 vs 개인 파일:**
+
+- `bmad-agent-dev.toml`: git에 커밋하고 팀 전체에 적용합니다
+- `bmad-agent-dev.user.toml`: git에서 무시되며 개인 선호를 위에 덧씌웁니다
+
+## 레시피 2: 특정 워크플로 안에서 조직 관례 강제
+
+**사용 사례:** 워크플로 출력의 *내용*이 컴플라이언스, 감사, 후속 사용자의 요구를 만족하도록 만듭니다.
+
+**예시: 모든 제품 개요에 컴플라이언스 필드가 포함되고 에이전트가 조직의 게시 관례를 압니다.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+persistent_facts = [
+  "모든 개요에는 '소유자', '대상 릴리스', '보안 리뷰 상태' 필드가 포함되어야 합니다.",
+  "비상업용 개요(내부 도구, 리서치 프로젝트)도 사용자 가치 섹션은 포함해야 하지만 시장 차별화는 생략할 수 있습니다.",
+  "file:{project-root}/docs/enterprise/brief-publishing-conventions.md",
+]
+```
+
+**일어나는 일:** 사실 목록은 워크플로 활성화 3단계에서 로드됩니다. 에이전트가 제품 개요를 작성할 때 필수 필드와 엔터프라이즈 관례 문서를 알고 있습니다. 기본값(`file:{project-root}/**/project-context.md`)도 추가 방식이므로 계속 로드됩니다.
+
+## 레시피 3: 완료된 출력을 외부 시스템에 게시
+
+**사용 사례:** 워크플로가 출력을 만든 뒤 엔터프라이즈 기록 시스템(Confluence, Notion, SharePoint)에 자동 게시하고 후속 작업(Jira, Linear, Asana)을 엽니다.
+
+**예시: 제품 개요를 Confluence에 자동 게시하고 선택적으로 Jira 에픽 생성을 제안합니다.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+# 종료 후크입니다. 스칼라 값 오버라이드는 빈 기본값 전체를 교체합니다.
+on_complete = """
+게시하고 후속 작업을 제안하세요:
+
+1. 이전 단계에서 확정된 개요 파일 경로를 읽습니다.
+2. 다음 인자로 `mcp__atlassian__confluence_create_page`를 호출합니다:
+   - space: "PRODUCT"
+   - parent: "Product Briefs"
+   - title: 개요 제목
+   - body: 개요의 Markdown 내용
+   반환된 페이지 URL을 기록합니다.
+3. 사용자에게 "개요가 Confluence에 게시되었습니다: <url>"이라고 알립니다.
+4. "이 개요에 대한 Jira 에픽을 지금 만들까요?"라고 묻습니다.
+5. 사용자가 동의하면 다음 인자로 `mcp__atlassian__jira_create_issue`를 호출합니다:
+   - type: "Epic"
+   - project: "PROD"
+   - summary: 개요 제목
+   - description: 짧은 요약과 Confluence 페이지 링크
+   에픽 키와 URL을 보고합니다.
+6. 동의하지 않으면 깔끔하게 종료합니다.
+
+어느 MCP 도구든 실패하면 실패를 보고하고 개요 경로를 출력한 뒤
+사용자에게 수동 게시를 요청하세요.
+"""
+```
+
+**왜 `activation_steps_append`가 아니라 `on_complete`인가요:** `on_complete`는 워크플로의 주 출력이 작성된 뒤 마지막 단계에서 정확히 한 번 실행됩니다. 산출물 게시에는 이 시점이 맞습니다. `activation_steps_append`는 워크플로가 일을 시작하기 전에 매 활성화마다 실행됩니다.
+
+**절충점:**
+
+- **Confluence 게시 작업은 비파괴적**이며 완료 시 항상 실행됩니다
+- **Jira 에픽 생성은 팀 전체에 보이고 스프린트 계획 신호를 만들기 때문에** 사용자 확인으로 통제합니다
+- **안전한 대체 경로:** MCP 도구가 실패하면 조용히 출력을 버리지 말고 사용자에게 맡깁니다
+
+## 레시피 4: 자체 출력 템플릿으로 교체
+
+**사용 사례:** 기본 출력 구조가 조직의 예상 형식과 맞지 않거나, 같은 저장소의 서로 다른 조직이 다른 템플릿을 필요로 합니다.
+
+**예시: product-brief 워크플로가 엔터프라이즈 소유 템플릿을 보게 합니다.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+```
+
+**작동 방식:** 워크플로의 `customize.toml`은 `brief_template = "resources/brief-template.md"`(스킬 루트 기준 경로)를 제공합니다. 오버라이드는 `{project-root}` 아래 파일을 가리키므로 에이전트가 제공된 템플릿 대신 당신의 템플릿을 4단계에서 읽습니다.
+
+**템플릿 작성 팁:**
+
+- 템플릿은 `{project-root}/docs/` 또는 `{project-root}/_bmad/custom/templates/`에 두어 오버라이드 파일과 함께 버전 관리합니다
+- 제공된 템플릿과 같은 구조 관례(섹션 헤딩, 프런트매터)를 사용하세요. 에이전트는 그 구조에 적응합니다
+- 다중 조직 저장소에서는 `.user.toml`로 개별 팀이 커밋된 팀 파일을 건드리지 않고 자체 템플릿을 가리키게 할 수 있습니다
+
+## 레시피 5: 에이전트 명단 커스터마이즈
+
+**사용 사례:** 소스를 수정하거나 포크하지 않고 `bmad-party-mode`, `bmad-retrospective`, `bmad-advanced-elicitation` 같은 명단 기반 스킬에서 *방에 누가 있는지* 바꿉니다. 세 가지 흔한 변형은 다음과 같습니다.
+
+### 5a. BMad 에이전트를 조직 전체에서 리브랜딩
+
+실제 에이전트마다 설치 프로그램이 `module.yaml`에서 합성한 설명자가 있습니다. 이를 오버라이드하면 명단을 사용하는 모든 스킬에서 목소리와 표현 방식을 바꿀 수 있습니다.
+
+```toml
+# _bmad/custom/config.toml (커밋됨 - 모든 개발자에게 적용)
+
+[agents.bmad-agent-analyst]
+description = "규제를 의식하는 비즈니스 분석가 Mary - Porter와 Minto의 사고법을 따르지만 FDA 감사 추적을 중시합니다. 사건 파일을 제시하는 포렌식 조사관처럼 말합니다."
+```
+
+파티 모드는 새 설명으로 Mary를 생성합니다. 분석가 활성화 자체는 Mary의 동작이 스킬별 `customize.toml`에 있으므로 정상 동작합니다. 이 오버라이드는 **외부 스킬이 Mary를 어떻게 인식하고 소개하는지**를 바꾸며, 내부 작업 방식은 바꾸지 않습니다.
+
+### 5b. 가상 또는 커스텀 에이전트 추가
+
+스킬 폴더 없이 전체 설명자만으로 명단 기반 기능에 충분합니다. 파티 모드나 브레인스토밍 세션에서 페르소나 다양성을 줄 때 유용합니다.
+
+```toml
+# _bmad/custom/config.user.toml (개인용 - git에서 무시)
+
+[agents.spock]
+team = "startrek"
+name = "스팍 사령관"
+title = "과학 장교"
+icon = "🖖"
+description = "논리를 우선하고 감정을 억제합니다. 관찰을 '흥미롭군요.'로 시작합니다. 절대 올림하지 않습니다. 직감에 의존하는 주장에 반대 관점을 제공합니다."
+
+[agents.mccoy]
+team = "startrek"
+name = "레너드 맥코이 박사"
+title = "수석 의무관"
+icon = "⚕️"
+description = "시골 의사의 따뜻함과 짧은 인내심을 지녔습니다. '제기랄 짐, 난 ___가 아니라 의사라고.' 윤리 중심으로 스팍의 균형을 잡습니다."
+```
+
+파티 모드에 "엔터프라이즈 승무원을 초대해 줘"라고 요청하면 `team = "startrek"`으로 필터링하고 스팍과 맥코이를 생성합니다. 요청하면 실제 BMad 에이전트(Mary, Amelia)도 같은 테이블에 앉을 수 있습니다.
+
+### 5c. 팀 설치 설정 고정
+
+설치 프로그램은 각 개발자에게 `planning_artifacts` 경로 같은 값을 묻습니다. 조직이 팀 전체에 하나의 답을 강제해야 한다면 중앙 설정에 고정하세요. 각 개발자의 로컬 프롬프트 답변은 해석 시점에 오버라이드됩니다.
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "{project-root}/shared/planning"
+implementation_artifacts = "{project-root}/shared/implementation"
+
+[core]
+document_output_language = "English"
+```
+
+`user_name`, `communication_language`, `user_skill_level` 같은 개인 설정은 각 개발자의 `_bmad/config.user.toml` 아래에 둡니다. 팀 파일은 이를 건드리지 않는 것이 좋습니다.
+
+**왜 중앙 설정인가요:** 에이전트별 파일은 *하나의* 에이전트가 활성화될 때 동작을 조정합니다. 중앙 설정은 명단을 사용하는 스킬이 명단을 조회할 때 *무엇을 보게 되는지*를 조정합니다. 어떤 에이전트가 존재하는지, 무엇이라고 불리는지, 어떤 팀에 속하는지, 저장소가 합의한 공유 설치 설정이 무엇인지입니다.
+
+## IDE 세션 파일에 전역 규칙 보강
+
+BMad 커스터마이징은 스킬이 활성화될 때 로드됩니다. 많은 IDE 도구는 스킬이 실행되기 전 **모든 세션 시작 시** 전역 지침 파일도 로드합니다(`CLAUDE.md`, `AGENTS.md`, `.cursor/rules/`, `.github/copilot-instructions.md` 등). BMad 스킬 밖에서도 지켜져야 하는 규칙은 거기에도 핵심만 반복하세요.
+
+**중복해 둘 때:**
+
+- 일반 채팅 대화(활성 스킬 없음)에서도 지켜야 할 만큼 중요한 규칙입니다
+- 학습 데이터 기반 기본값이 모델을 다른 방향으로 끌 수 있어 이중 안전장치가 필요합니다
+- 세션 파일을 부풀리지 않을 만큼 간결한 규칙입니다
+
+**예시: 레시피 1의 dev 에이전트 규칙을 저장소의 `CLAUDE.md`에 한 줄로 보강.**
+
+```markdown
+<!-- 라이브러리 문서를 읽을 때는 학습 데이터 지식에 의존하기 전에
+context7 MCP 도구(`mcp__context7__resolve_library_id` 이후
+`mcp__context7__get_library_docs`)를 거칩니다. -->
+```
+
+한 문장이 매 세션에 로드됩니다. `bmad-agent-dev.toml` 커스터마이징과 짝을 이뤄 Amelia의 워크플로 안과 어시스턴트와의 임시 채팅 모두에 규칙을 적용합니다.
+
+| 계층 | 범위 | 사용처 |
+| --- | --- | --- |
+| IDE 세션 파일(`CLAUDE.md` / `AGENTS.md`) | 모든 세션, 스킬 활성화 전 | BMad 밖에서도 살아야 하는 짧은 보편 규칙 |
+| BMad 에이전트 커스터마이징 | 에이전트가 실행하는 모든 워크플로 | 에이전트 페르소나별 동작 |
+| BMad 워크플로 커스터마이징 | 하나의 워크플로 실행 | 워크플로별 출력 형태, 게시 후크, 템플릿 |
+| BMad 중앙 설정 | 에이전트 명단 + 공유 설치 설정 | 방에 누가 있고 팀이 어떤 공유 경로를 쓰는지 |
+
+IDE 파일은 **간결하게** 유지하세요. 잘 고른 열두 줄이 긴 목록보다 효과적입니다. 모델은 이를 매 턴 읽고, 노이즈는 신호를 밀어냅니다.
+
+## 레시피 6: 고급 통합 패턴
+
+몇몇 BMad 워크플로는 레시피 1-5에서 다룬 기본을 넘어 더 풍부한 설정 영역을 노출합니다. 온디맨드 지식 소스, 자동 출력 게시, 완료 시점 문서 표준, 교체 가능한 템플릿 같은 패턴은 여러 워크플로에 걸쳐 나타납니다. 어떤 필드를 노출하는지는 워크플로의 `customize.toml`을 확인하세요. 아래 예시는 모든 필드를 노출하는 `bmad-prd`를 사용하지만, 같은 패턴은 해당 필드가 있는 어디서나 적용됩니다.
+
+### 온디맨드 지식 소스(`external_sources`)
+
+워크플로를 내부 지식 베이스, 경쟁사 데이터베이스, 컴플라이언스 참조에 연결합니다. 에이전트는 대화에서 일치하는 필요가 나타날 때만 온디맨드로 참조하고 선제적으로 호출하지 않습니다.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (external_sources를 노출하는 모든 워크플로에서 같은 패턴 사용)
+
+[workflow]
+external_sources = [
+  "사용자가 경쟁사나 시장 세그먼트를 언급하면 차별화 섹션 초안을 작성하기 전에 corp:competitive_db(category={project_name})를 조회하세요.",
+  "규제 도메인(헬스케어, 핀테크, 교육)에서는 도메인별 섹션 초안을 작성하기 전에 corp:compliance_reference를 참고하세요.",
+]
+```
+
+각 항목은 MCP 도구 이름, 트리거 조건, 도구에 필요한 필드를 자연어로 지정합니다. 런타임에 도구가 없으면 워크플로는 표준 동작으로 돌아가고 공백을 알립니다.
+
+### 자동 출력 게시(`external_handoffs`)
+
+워크플로가 완료된 뒤 완성된 산출물을 외부 기록 시스템으로 보냅니다. 레시피 3의 `on_complete`와 달리 `external_handoffs`는 전용 추가 배열입니다. 팀 항목이 쌓이고 각 전달 작업은 도구가 없을 때 점진적 기능 저하와 함께 독립 실행됩니다.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (external_handoffs를 노출하는 모든 워크플로에서 같은 패턴 사용)
+
+[workflow]
+external_handoffs = [
+  "완료 후 corp:confluence_upload(space_key='PROD', parent_page='PRDs', label='prd', author={user_name})로 prd.md와 addendum.md를 Confluence에 업로드하세요. 반환된 페이지 URL을 기록하고 보여 주세요.",
+  "notion:create_page(database_id='abc123', title='PRD: ' + {project_name})로 Notion에도 복제하세요.",
+]
+```
+
+지정된 도구가 없으면 전달 작업은 건너뛰고 표시됩니다. 로컬 파일은 항상 존재합니다.
+
+### 완료 시점 문서 표준(`doc_standards`)
+
+사람이 읽을 문서에 조직 작성 표준을 완료 시점에 적용합니다. 내용이 완료된 후, 사용자가 출력을 보기 전입니다. 각 항목은 `skill:`, `file:`, 일반 텍스트 지시문일 수 있으며 각 검토 단계는 병렬 서브에이전트로 실행됩니다.
+
+```toml
+# _bmad/custom/bmad-prd.toml  (doc_standards를 노출하는 모든 워크플로에서 같은 패턴 사용)
+
+[workflow]
+doc_standards = [
+  "file:{project-root}/docs/enterprise/voice-and-tone.md",
+  "모든 날짜는 ISO 8601 형식(YYYY-MM-DD)을 사용해야 합니다.",
+  "'활용'을 사용한 곳은 모두 '사용'으로 바꾸세요.",
+]
+```
+
+`doc_standards`는 추가 배열입니다. 팀 항목은 워크플로가 제공하는 기본값 위에 쌓입니다. 넓은 구조 검토가 좁은 문장 검토보다 먼저 와야 합니다.
+
+### 교체 가능한 템플릿과 체크리스트
+
+구조화된 문서를 만드는 워크플로는 일반적으로 템플릿과 체크리스트 경로를 오버라이드 가능한 스칼라 값으로 노출합니다. `{project-root}` 아래 조직 소유 파일을 가리키면 소스를 수정하지 않고 다른 구조를 강제할 수 있습니다.
+
+```toml
+# _bmad/custom/bmad-prd.toml
+
+[workflow]
+# 규제 산업용 PRD 구조
+prd_template = "{project-root}/docs/enterprise/prd-template-hipaa.md"
+
+# 조직별 검증 기준
+validation_checklist = "{project-root}/docs/enterprise/prd-checklist-regulated.md"
+```
+
+에이전트는 템플릿이 정의한 구조에 적응합니다. 템플릿은 `{project-root}/docs/` 또는 `{project-root}/_bmad/custom/templates/` 아래에 두어 오버라이드 파일과 함께 버전 관리하세요. 다중 조직 저장소에서는 `.user.toml`로 개별 팀이 커밋된 팀 파일을 건드리지 않고 자체 템플릿을 가리키게 할 수 있습니다.
+
+## 레시피 조합
+
+여섯 레시피는 모두 조합됩니다. 현실적인 엔터프라이즈용 `bmad-product-brief` 오버라이드는 한 파일에서 `persistent_facts`(레시피 2), `on_complete`(레시피 3), `brief_template`(레시피 4)을 설정할 수 있습니다. 에이전트 수준 규칙(레시피 1)은 에이전트 이름의 별도 파일에 있고, 중앙 설정(레시피 5)은 공유 명단과 팀 설정을 고정하며, 고급 통합 패턴(레시피 6)은 외부 소스와 전달 작업을 설정합니다. 모든 계층은 나란히 적용됩니다.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml (워크플로 수준)
+
+[workflow]
+persistent_facts = ["..."]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+on_complete = """ ... """
+```
+
+```toml
+# _bmad/custom/bmad-agent-analyst.toml (에이전트 수준 - Mary가 product-brief를 실행)
+
+[agent]
+persistent_facts = ["도메인이 헬스케어, 금융, 아동 데이터와 관련되면 항상 '규제 검토' 섹션을 포함하세요."]
+```
+
+결과: Mary는 페르소나 활성화에서 규제 리뷰 규칙을 로드합니다. 사용자가 제품 개요 메뉴 항목을 선택하면 워크플로는 자체 관례를 그 위에 로드하고 엔터프라이즈 템플릿에 작성한 뒤 완료 시 Confluence에 게시합니다. 모든 계층이 함께 작동하며 BMad 소스는 수정하지 않습니다.
+
+## 문제 해결
+
+**오버라이드가 적용되지 않나요?** 파일이 `_bmad/custom/` 아래 정확한 스킬 디렉터리 이름으로 있는지 확인하세요(예: `bmad-agent-dev.toml`, `bmad-dev.toml` 아님). [BMad 커스터마이징 방법](./customize-bmad.md)을 참고하세요.
+
+**MCP 도구 이름을 모르겠나요?** 현재 세션에서 MCP 서버가 노출하는 정확한 이름을 사용하세요. 확실하지 않다면 Claude Code에 사용 가능한 MCP 도구 목록을 보여달라고 요청하세요. `persistent_facts`나 `on_complete`에 하드코딩한 이름은 MCP 서버가 연결되어 있지 않으면 동작하지 않습니다.
+
+**패턴이 내 설정에 맞지 않나요?** 위 레시피는 예시입니다. 기반 메커니즘(3계층 병합, 구조 규칙, 에이전트가 여러 워크플로에 걸쳐 동작하는 방식)은 훨씬 많은 패턴을 지원합니다. 필요에 맞게 조합하세요.

docs/ko-kr/how-to/get-answers-about-bmad.md

@@ -0,0 +1,81 @@
+---
+title: 'BMad에 대한 답을 얻는 방법'
+description: LLM을 사용해 BMad 관련 질문에 빠르게 답하기
+sidebar:
+  order: 5
+---
+
+BMad의 내장 도움말, 소스 문서, 커뮤니티를 사용해 답을 얻으세요. 가장 빠른 방법부터 가장 꼼꼼한 방법까지 순서대로 소개합니다.
+
+## 1. BMad 도움말에게 묻기
+
+답을 얻는 가장 빠른 방법입니다. `bmad-help` 스킬은 AI 세션에서 바로 사용할 수 있으며 질문의 80% 이상을 처리합니다. 프로젝트를 검사하고 완료한 작업을 확인한 뒤 다음에 무엇을 해야 할지 알려줍니다.
+
+```
+bmad-help SaaS 아이디어가 있고 기능도 모두 알고 있습니다. 어디서 시작하나요?
+bmad-help UX 설계에는 어떤 선택지가 있나요?
+bmad-help PRD 워크플로에서 막혔어요
+```
+
+:::tip
+플랫폼에 따라 `/bmad-help` 또는 `$bmad-help`도 사용할 수 있지만, 대부분은 `bmad-help`만으로 동작합니다.
+:::
+
+## 2. 소스로 더 깊게 들어가기
+
+BMad 도움말은 설치된 설정을 바탕으로 답합니다. BMad의 내부 구조, 역사, 아키텍처에 대한 질문이 있거나 설치 전에 BMad를 조사하고 있다면 AI가 소스를 직접 보게 하세요.
+
+[BMAD-METHOD 저장소](https://github.com/bmad-code-org/BMAD-METHOD)를 복제하거나 열고 AI에게 질문하세요. 에이전트 기능이 있는 도구(Claude Code, Cursor, Windsurf 등)는 소스를 읽고 직접 답할 수 있습니다.
+
+:::note[예시]
+**Q:** "BMad로 무언가를 가장 빠르게 만드는 방법을 알려줘"
+
+**A:** 빠른 흐름을 사용하세요. `bmad-quick-dev`를 실행하면 의도를 명확히 하고, 계획하고, 구현하고, 리뷰하고, 결과를 하나의 워크플로에서 제시합니다. 전체 계획 단계를 건너뜁니다.
+:::
+
+**더 좋은 답을 위한 팁:**
+
+- **구체적으로 묻기** - "PRD 워크플로 3단계가 무엇을 하나요?"가 "PRD는 어떻게 작동하나요?"보다 좋습니다
+- **놀라운 주장은 확인하기** - LLM은 가끔 틀립니다. 소스 파일을 확인하거나 Discord에서 물어보세요
+
+### 에이전트를 쓰지 않는다면 문서 사이트 사용
+
+AI가 로컬 파일을 읽을 수 없다면(ChatGPT, Claude.ai 등), 세션에 [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt)를 가져오세요. BMad 문서의 단일 파일 스냅샷입니다.
+
+## 3. 사람에게 묻기
+
+BMad 도움말이나 소스로도 답을 얻지 못했다면, 이제 훨씬 더 좋은 질문을 갖게 된 것입니다.
+
+| 채널 | 사용처 |
+| --- | --- |
+| `help-requests` 포럼 | 질문 |
+| `#suggestions-feedback` | 아이디어와 기능 요청 |
+
+**Discord:** [discord.gg/gk8jAdXWmj](https://discord.gg/gk8jAdXWmj)
+
+**GitHub Issues:** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
+
+_당신이_
+_막힌 채_
+_줄 서서_
+_기다린다면_
+_누구를 기다리나요?_
+
+_소스는_
+_이미 거기_
+_눈앞에 있습니다._
+
+_당신의_
+_기계를 가리키고._
+_풀어 주세요._
+
+_읽고._
+_말합니다._
+_물어보세요._
+
+_내일을_
+_기다릴 이유가 있나요_
+_오늘 이미_
+_할 수 있는데?_
+
+_—Claude_

docs/ko-kr/how-to/install-bmad.md

@@ -0,0 +1,266 @@
+---
+title: 'BMad 설치 방법'
+description: 로컬 개발, 팀, CI를 위해 BMad를 설치, 업데이트, 고정합니다
+sidebar:
+  order: 1
+---
+
+프로젝트에 BMad를 설정하려면 `npx bmad-method install`을 사용하세요. 하나의 명령으로 최초 설치, 업그레이드, 채널 전환, 스크립트 기반 CI 실행을 처리합니다. 이 페이지에서 그 전체를 다룹니다.
+
+## 사용 시점
+
+- BMad로 새 프로젝트를 시작합니다
+- 기존 설치에 모듈을 추가하거나 제거합니다
+- 모듈을 main 브랜치 최신 커밋으로 전환하거나 특정 릴리스에 고정합니다
+- CI 파이프라인, Dockerfile, 엔터프라이즈 배포를 위해 설치를 스크립트화합니다
+
+:::note[필수 조건]
+
+- **Node.js** 20+ (설치 프로그램에 필요)
+- **Git** (외부 모듈 복제용)
+- Claude Code 또는 Cursor 같은 **AI 도구**(지원 도구 목록은 `npx bmad-method install --list-tools`로 확인)
+
+:::
+
+## 최초 설치(빠른 경로)
+
+```bash
+npx bmad-method install
+```
+
+대화형 흐름은 다섯 가지를 묻습니다.
+
+1. 설치 디렉터리(기본값은 현재 작업 디렉터리)
+2. 설치할 모듈(core, bmm, bmb, cis, gds, tea 체크박스)
+3. **"Ready to install (all stable)?"** - **Yes**를 선택하면 모든 외부 모듈의 최신 릴리스 태그를 사용합니다
+4. 연동할 AI 도구/IDE(`claude-code`, `cursor` 등)
+5. 모듈별 설정(이름, 언어, 출력 폴더)
+
+기본값을 받아들이면 선택한 도구에 맞게 설정된 각 모듈의 최신 안정 릴리스가 설치됩니다.
+
+:::tip[최신 사전 릴리스만 원하나요?]
+
+```bash
+npx bmad-method@next install
+```
+
+core와 bmm의 더 새로운 스냅샷이 포함된 사전 릴리스 설치 프로그램을 실행합니다. 변화는 더 잦지만 개발과 릴리스 사이의 지연이 줄어듭니다.
+:::
+
+## 특정 버전 선택
+
+디스크에 무엇이 설치되는지는 두 개의 독립 축으로 제어됩니다.
+
+### 축 1: 외부 모듈 채널
+
+bmb, cis, gds, tea, 커뮤니티 모듈 등 모든 외부 모듈은 세 채널 중 하나로 설치됩니다.
+
+| 채널 | 설치되는 것 | 누가 선택하나 |
+| --- | --- | --- |
+| `stable`(기본값) | 가장 높은 시맨틱 버전 릴리스 태그. `v2.0.0-alpha.1` 같은 사전 릴리스는 제외됩니다. | 대부분의 사용자 |
+| `next` | 설치 시점의 main 브랜치 최신 커밋 | 기여자, 초기 채택자 |
+| `pinned` | 지정한 특정 태그 | 엔터프라이즈 설치, CI 재현성 |
+
+채널은 모듈마다 정할 수 있습니다. bmb는 `next`로 두고 cis는 `stable`로 둘 수 있습니다. 아래 플래그로 자유롭게 섞을 수 있습니다.
+
+### 축 2: 설치 프로그램 바이너리 버전
+
+`bmad-method` npm 패키지 자체에는 두 npm 배포 태그(dist-tag)가 있습니다.
+
+| 명령 | 받는 것 |
+| --- | --- |
+| `npx bmad-method install`(`@latest`) | 최신 안정 설치 프로그램 릴리스 |
+| `npx bmad-method@next install` | main에 푸시될 때마다 자동 배포되는 최신 사전 릴리스 설치 프로그램 |
+
+**설치 프로그램 바이너리가 core와 bmm 버전을 결정합니다.** 이 두 모듈은 별도 저장소에서 복제되지 않고 설치 프로그램 패키지 안에 번들됩니다.
+
+### core와 bmm에 자체 채널이 없는 이유
+
+두 모듈은 실행한 설치 프로그램 바이너리에 묶여 있습니다.
+
+- `npx bmad-method install` → 최신 안정 core 및 bmm
+- `npx bmad-method@next install` → 사전 릴리스 core 및 bmm
+- `node /path/to/local-checkout/tools/installer/bmad-cli.js install` → 로컬 체크아웃의 내용
+
+`--pin bmm=v6.3.0`과 `--next=bmm`은 번들 모듈에는 효과가 없고, 시도하면 설치 프로그램이 경고합니다. 향후 릴리스에서 bmm가 설치 프로그램 패키지에서 분리되면 bmb처럼 적절한 채널 선택기를 갖게 됩니다.
+
+## 기존 설치 업데이트
+
+이미 `_bmad/`가 있는 디렉터리에서 `npx bmad-method install`을 실행하면 메뉴가 나타납니다.
+
+| 실제 메뉴 선택 | 하는 일 |
+| --- | --- |
+| **Quick Update** | 기존 설정으로 설치를 다시 실행합니다. 파일을 새로 고치고, 안정 채널의 패치와 마이너 업그레이드를 적용하며, 메이저 업그레이드는 거부합니다. 빠르고 비대화형입니다. |
+| **Modify Install** | 전체 대화형 흐름입니다. 모듈을 추가/제거하고, 설정을 다시 구성하고, 기존 모듈 채널을 검토하고 전환할 수 있습니다. |
+
+### 업그레이드 프롬프트
+
+`Modify`가 `stable`에 설치된 모듈의 새 안정 태그를 감지하면 변경 폭을 분류하고 그에 맞게 묻습니다.
+
+| 업그레이드 유형 | 예시 | 기본값 |
+| --- | --- | --- |
+| 패치 | v1.7.0 → v1.7.1 | `Y` |
+| 마이너 | v1.7.0 → v1.8.0 | `Y` |
+| 메이저 | v1.7.0 → v2.0.0 | **`N`** |
+
+메이저 업그레이드는 호환성 깨짐이 예상치 못한 "불안정"으로 나타나는 경우가 많기 때문에 기본값이 `N`입니다. 프롬프트에는 변경 내용을 읽을 수 있는 GitHub 릴리스 노트 URL이 포함됩니다.
+
+`--yes`에서는 패치와 마이너 업그레이드가 자동 적용됩니다. 메이저 업그레이드는 고정된 채로 유지됩니다. 비대화형으로 수락하려면 `--pin <code>=<new-tag>`를 전달하세요.
+
+### 모듈 채널 전환
+
+**대화형:** **Modify**를 선택하고 `"Review channel assignments?"`에 **Yes**로 답한 뒤, 각 외부 모듈에서 Keep, Switch to stable, Switch to next, Pin to a tag 중 하나를 선택합니다.
+
+**플래그로:** 다음 섹션의 레시피가 일반적인 경우를 다룹니다.
+
+## Headless CI
+
+### 플래그 참조
+
+| 플래그 | 목적 |
+| --- | --- |
+| `--yes`, `-y` | 모든 프롬프트를 건너뛰고 플래그 값과 기본값을 수락합니다 |
+| `--directory <path>` | 이 디렉터리에 설치합니다(기본값: 현재 작업 디렉터리) |
+| `--modules <a,b,c>` | 정확한 모듈 집합입니다. core는 자동 추가됩니다. 증분 목록이 아니므로 유지하려는 모든 것을 나열하세요 |
+| `--tools <a,b>` | IDE/도구 선택입니다. 새 `--yes` 설치에는 필수입니다. 유효 ID는 `--list-tools`로 확인하세요 |
+| `--list-tools` | 지원되는 모든 도구/IDE ID와 대상 디렉터리를 출력하고 종료합니다 |
+| `--action <type>` | `install`, `update`, `quick-update`. 기본값은 기존 설치 상태에 따라 달라집니다 |
+| `--custom-source <urls>` | Git URL 또는 로컬 경로에서 커스텀 모듈을 설치합니다 |
+| `--channel <stable\|next>` | 모든 외부 모듈에 적용합니다(`--all-stable` / `--all-next` 별칭) |
+| `--all-stable` | `--channel=stable` 별칭 |
+| `--all-next` | `--channel=next` 별칭 |
+| `--next=<code>` | 한 모듈을 next 채널에 둡니다. 반복 가능합니다 |
+| `--pin <code>=<tag>` | 한 모듈을 특정 태그에 고정합니다. 반복 가능합니다 |
+| `--set <module>.<key>=<value>` | 모듈 설정 옵션을 비대화형으로 설정합니다(권장, [모듈 설정 오버라이드](#모듈-설정-오버라이드) 참고). 반복 가능합니다 |
+| `--list-options [module]` | 내장 및 로컬 캐시된 공식 모듈의 모든 `--set` 키를 출력하고 종료합니다. 모듈 코드를 전달하면 범위를 좁힙니다 |
+| `--user-name`, `--communication-language`, `--document-output-language`, `--output-folder` | `--set core.<key>=<value>`와 동등한 레거시 단축 플래그입니다(계속 지원) |
+
+플래그가 겹칠 때 우선순위는 `--pin` > `--next=` > `--channel` / `--all-*` > 레지스트리 기본값(`stable`)입니다.
+
+:::note[해결 예시]
+`--all-next --pin cis=v0.2.0`은 bmb, gds, tea를 next에 두고 cis를 v0.2.0에 고정합니다.
+:::
+
+### 레시피
+
+**기본 설치 - 모든 것을 최신 안정 버전으로:**
+
+```bash
+npx bmad-method install --yes --modules bmm,bmb,cis --tools claude-code
+```
+
+**엔터프라이즈 고정 - 바이트 단위로 재현 가능:**
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm,bmb,cis \
+  --pin bmb=v1.7.0 --pin cis=v0.2.0 \
+  --tools claude-code
+```
+
+**최신 개발판 - 외부 모듈을 main 브랜치 최신 커밋으로:**
+
+```bash
+npx bmad-method install --yes --modules bmm,bmb --all-next --tools claude-code
+```
+
+**기존 설치에 모듈 추가**(나머지는 유지):
+
+```bash
+npx bmad-method install --yes --action update \
+  --modules bmm,bmb,gds
+```
+
+`--tools`는 의도적으로 생략했습니다. `--action update`는 최초 설치 때 설정한 도구를 재사용합니다.
+
+**채널 혼합 - bmb는 next, gds는 stable:**
+
+```bash
+npx bmad-method install --yes --action update \
+  --modules bmm,bmb,cis,gds \
+  --next=bmb
+```
+
+### 모듈 설정 오버라이드
+
+`--set <module>.<key>=<value>`는 모듈 설정 옵션을 비대화형으로 설정합니다. 반복 가능하고 앞으로 추가될 모듈에도 같은 방식으로 적용됩니다. 이 플래그는 설치 후 패치로 적용됩니다. 설치 프로그램이 정상 흐름을 먼저 실행한 뒤 `--set`이 각 값을 `_bmad/config.toml`(팀 범위) 또는 `_bmad/config.user.toml`(사용자 범위), 그리고 `_bmad/<module>/config.yaml`에 갱신 또는 삽입하여 선언된 값이 다음 설치로 이어지게 합니다.
+
+**예시 - 명시적 프로젝트 지식과 스킬 수준으로 bmm 설치:**
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm \
+  --tools claude-code \
+  --set bmm.project_knowledge=research \
+  --set bmm.user_skill_level=expert
+```
+
+**모듈에서 사용할 수 있는 키 찾기:**
+
+```bash
+npx bmad-method install --list-options bmm
+```
+
+`--list-options`(인자 없음)는 설치 프로그램이 로컬에서 찾을 수 있는 모든 키를 나열합니다. 내장 모듈(`core`, `bmm`)과 현재 캐시된 공식 모듈이 포함됩니다. 캐시는 머신별이고 지워질 수 있으므로, 이전에 설치한 공식 모듈도 새 체크아웃이나 임시 CI 작업자에서는 다시 설치되기 전까지 나타나지 않습니다. 커뮤니티 및 커스텀 모듈은 여기서 열거되지 않습니다. 모듈의 `module.yaml`을 직접 읽어 선언된 키를 확인하세요.
+
+**작동 방식:**
+
+- **경로 선택.** 패치 단계는 먼저 `config.user.toml`에서 `[modules.<module>] <key>`(또는 `[core] <key>`)를 찾고, 있으면 그 파일을 업데이트합니다. 그렇지 않으면 팀 범위 `config.toml`에 씁니다. 그래서 `core.user_name`, `bmm.user_skill_level` 같은 사용자 범위 키는 `config.user.toml`에, 팀 범위 키는 `config.toml`에 들어갑니다.
+- **그대로 쓰는 값.** 값은 제공한 그대로 기록됩니다. `result:` 템플릿 렌더링은 없습니다. 렌더링된 형태(예: `{project-root}/research`)를 원하면 명시적으로 전달하세요: `--set bmm.project_knowledge='{project-root}/research'`.
+- **다음 설치로 이어지는 선언된 키.** `module.yaml`에 선언된 키 값은 `_bmad/<module>/config.yaml`에도 쓰이므로 다음 설치 때 프롬프트 기본값으로 살아남습니다.
+- **다음 설치로 이어지지 않는 미선언 키.** 모듈 스키마가 선언하지 않은 키 값은 현재 설치의 `config.toml`에 들어가지만 다음 설치 때 다시 생성되지 않습니다(매니페스트 작성기의 엄격한 스키마 분리 단계가 알 수 없는 키를 떨어뜨립니다). 계속 유지해야 한다면 `--set`을 다시 전달하거나 `_bmad/config.toml`을 직접 수정하세요.
+- **검증 없음.** `single-select` 값은 허용 선택지와 대조하지 않고, 알 수 없는 키도 거부하지 않습니다. 지정한 값이 그대로 쓰입니다.
+- **`--modules`에 없는 모듈.** 포함하지 않은 모듈에 값을 설정하면 경고를 출력하고 값은 버려집니다(설치되지 않은 모듈용 파일은 생성되지 않습니다).
+
+레거시 core 단축 플래그(`--user-name`, `--output-folder` 등)은 하위 호환성을 위해 계속 동작하고 문서화되어 있지만, `--set core.user_name=...`과 동등합니다.
+
+:::note[quick-update와 함께 동작]
+`--set`은 설치 후 패치이므로 작업 유형과 관계없이 동일하게 적용됩니다. `bmad install --action quick-update` 또는 기존 설치에서 `--yes`(기본이 quick-update)로 실행해도 일반 설치처럼 마지막에 중앙 설정 파일을 패치합니다.
+:::
+
+:::caution[공유 IP의 요청 제한]
+익명 GitHub API 호출은 IP당 시간당 60회로 제한됩니다. 한 번의 설치는 안정 태그를 확인하기 위해 외부 모듈마다 API를 한 번 호출합니다. NAT 뒤의 사무실, CI 러너 풀, VPN은 함께 이 한도를 소진할 수 있습니다.
+
+환경 변수에 `GITHUB_TOKEN=<personal access token>`을 설정하면 계정당 시간당 5000회로 한도가 올라갑니다. 공개 저장소 읽기용 개인 액세스 토큰(PAT)이면 충분하며 범위는 필요 없습니다.
+:::
+
+## 설치된 내용
+
+설치 후 `_bmad/_config/manifest.yaml`은 디스크에 있는 내용을 정확히 기록합니다.
+
+```yaml
+modules:
+  - name: bmb
+    version: v1.7.0 # 태그 또는 next용 "main"
+    channel: stable # stable | next | pinned
+    sha: 86033fc9aeae2ca6d52c7cdb675c1f4bf17fc1c1
+    source: external
+    repoUrl: https://github.com/bmad-code-org/bmad-builder
+```
+
+`sha` 필드는 git 기반 모듈(외부, 커뮤니티, URL 기반 커스텀)에 기록됩니다. 번들 모듈(core, bmm)과 로컬 경로 커스텀 모듈에는 없습니다. 그 코드는 복제 가능한 참조가 아니라 설치 프로그램 바이너리 또는 파일시스템 상태에 따라 달라집니다.
+
+머신 간 재현성을 위해 같은 `--modules` 명령을 다시 실행하는 것에 의존하지 마세요. 안정 채널 설치는 **설치 시점**의 가장 높은 릴리스 태그로 해석되므로 나중에 다시 실행하면 그 사이 릴리스된 버전으로 설치됩니다. `manifest.yaml`의 기록된 태그를 대상 머신에서 명시적 `--pin` 플래그로 바꾸세요. 예:
+
+```bash
+npx bmad-method install --yes --modules bmb,cis \
+  --pin bmb=v1.7.0 --pin cis=v0.4.2 --tools claude-code
+```
+
+## 문제 해결
+
+### "Could not resolve stable tag" 또는 "API rate limit exceeded"
+
+GitHub의 익명 시간당 60회 한도에 도달했습니다. `GITHUB_TOKEN`을 설정하고 다시 시도하세요. 이미 토큰이 있다면 만료되었거나 해당 토큰 자체의 한도에 걸렸을 수 있습니다. 다른 토큰을 시도하거나 시간당 한도가 초기화될 때까지 기다리세요.
+
+### "Tag 'vX.Y.Z' not found"
+
+`--pin`에 전달한 태그가 모듈 저장소에 없습니다. GitHub의 저장소 릴리스 페이지에서 유효한 태그를 확인하세요.
+
+### 고정 설치가 계속 업그레이드됨
+
+고정 설치는 업그레이드되지 않습니다. `Quick Update`는 안정 채널의 패치와 마이너만 적용하며 `pinned`나 `next`는 건드리지 않습니다. 고정 설치가 바뀌었다면 `_bmad/_config/manifest.yaml`을 여세요. 명시적으로 플래그로 오버라이드하지 않는 한 `channel: pinned`와 고정된 `version`, `sha`가 실행 간 유지되어야 합니다.
+
+### `--pin bmm=X`가 아무 것도 하지 않음
+
+bmm은 번들 모듈입니다. `--pin`과 `--next=`가 적용되지 않습니다. 사전 릴리스 core/bmm을 원하면 `npx bmad-method@next install`을 사용하거나 bmad-bmm 저장소를 체크아웃하고 설치 프로그램을 로컬에서 실행해 아직 릴리스되지 않은 변경을 받으세요.

docs/ko-kr/how-to/install-custom-modules.md

@@ -0,0 +1,181 @@
+---
+title: '커스텀 및 커뮤니티 모듈 설치'
+description: 커뮤니티 레지스트리, Git 저장소, 로컬 경로에서 서드파티 모듈을 설치합니다
+sidebar:
+  order: 3
+---
+
+BMad 설치 프로그램을 사용해 커뮤니티 레지스트리, 서드파티 Git 저장소, 로컬 파일 경로에서 모듈을 추가하세요.
+
+## 사용 시점
+
+- BMad 레지스트리에서 커뮤니티 기여 모듈을 설치합니다
+- 서드파티 Git 저장소(GitHub, GitLab, Bitbucket, 자체 호스팅)에서 모듈을 설치합니다
+- BMad 빌더로 로컬에서 개발 중인 모듈을 테스트합니다
+- 비공개 또는 자체 호스팅 Git 서버에서 모듈을 설치합니다
+
+:::note[필수 조건]
+[Node.js](https://nodejs.org) v20+와 `npx`(npm에 포함)가 필요합니다. 커스텀 및 커뮤니티 모듈은 새 설치 중 선택하거나 기존 설치에 추가할 수 있습니다.
+:::
+
+## 커뮤니티 모듈
+
+커뮤니티 모듈은 [BMad 플러그인 마켓플레이스](https://github.com/bmad-code-org/bmad-plugins-marketplace)에서 선별됩니다. 카테고리별로 구성되고 안전을 위해 승인된 커밋에 고정됩니다.
+
+### 1. 설치 프로그램 실행
+
+```bash
+npx bmad-method install
+```
+
+### 2. 커뮤니티 카탈로그 둘러보기
+
+공식 모듈을 선택한 뒤 설치 프로그램이 묻습니다.
+
+```
+Would you like to browse community modules?
+```
+
+카탈로그 브라우저로 들어가려면 **Yes**를 선택하세요. 할 수 있는 일은 다음과 같습니다.
+
+- 카테고리별 탐색
+- 추천 모듈 보기
+- 사용 가능한 모든 모듈 보기
+- 키워드로 검색
+
+### 3. 모듈 선택
+
+어떤 카테고리에서든 모듈을 선택하세요. 설치 프로그램은 설명, 버전, 신뢰 등급을 보여줍니다. 이미 설치된 모듈은 업데이트 대상으로 미리 체크됩니다.
+
+### 4. 설치 계속
+
+커뮤니티 모듈을 선택하면 설치 프로그램은 커스텀 소스, 도구/IDE 설정, 나머지 설치 흐름으로 이어집니다.
+
+## 커스텀 소스(Git URL과 로컬 경로)
+
+커스텀 모듈은 어떤 Git 저장소나 로컬 디렉터리에서든 올 수 있습니다. 설치 프로그램은 소스를 해석하고 모듈 구조를 분석한 뒤 다른 모듈 옆에 설치합니다.
+
+### 대화형 설치
+
+설치 중 커뮤니티 모듈 단계 이후 설치 프로그램이 묻습니다.
+
+```
+Would you like to install from a custom source (Git URL or local path)?
+```
+
+**Yes**를 선택한 뒤 소스를 제공합니다.
+
+| 입력 유형 | 예시 |
+| --- | --- |
+| HTTPS URL(모든 호스트) | `https://github.com/org/repo` |
+| HTTP URL(모든 호스트) | `http://host/org/repo` |
+| 하위 디렉터리가 있는 HTTPS URL | `https://github.com/org/repo/tree/main/my-module` |
+| SSH URL | `git@github.com:org/repo.git` |
+| 로컬 경로 | `/Users/me/projects/my-module` |
+| 틸드가 있는 로컬 경로 | `~/projects/my-module` |
+
+설치 프로그램은 저장소를 복제(URL인 경우)하거나 디스크에서 직접 읽은 뒤(로컬 경로인 경우), 발견된 모듈을 선택할 수 있게 보여줍니다.
+
+### 비대화형 설치
+
+명령줄에서 커스텀 모듈을 설치하려면 `--custom-source` 플래그를 사용하세요.
+
+```bash
+npx bmad-method install \
+  --directory . \
+  --custom-source /path/to/my-module \
+  --tools claude-code \
+  --yes
+```
+
+`--modules` 없이 `--custom-source`를 제공하면 core와 커스텀 모듈만 설치됩니다. 공식 모듈도 포함하려면 `--modules`를 추가하세요.
+
+```bash
+npx bmad-method install \
+  --directory . \
+  --modules bmm \
+  --custom-source https://gitlab.com/myorg/my-module \
+  --tools claude-code \
+  --yes
+```
+
+여러 소스는 쉼표로 구분할 수 있습니다.
+
+```bash
+--custom-source /path/one,https://github.com/org/repo,/path/two
+```
+
+## 모듈 발견 방식
+
+설치 프로그램은 소스에서 설치 가능한 모듈을 찾기 위해 두 모드를 사용합니다.
+
+| 모드 | 트리거 | 동작 |
+| --- | --- | --- |
+| `Discovery` | 소스에 `.claude-plugin/marketplace.json`이 있습니다 | 매니페스트의 모든 플러그인을 나열하고 설치할 항목을 선택하게 합니다 |
+| `Direct` | marketplace.json이 없습니다 | 디렉터리에서 스킬(`SKILL.md`가 있는 하위 디렉터리)을 스캔하고 단일 모듈로 해석합니다 |
+
+`Discovery` 모드는 게시된 모듈에 일반적입니다. `Direct` 모드는 로컬 개발 중 스킬 디렉터리를 가리킬 때 편리합니다.
+
+:::note[`.claude-plugin/`에 대해]
+`.claude-plugin/marketplace.json` 경로는 여러 AI 도구 설치 프로그램에서 플러그인 발견을 위해 채택한 표준 관례입니다. Claude가 필요하지 않고 Claude API를 사용하지 않으며 어떤 AI 도구를 쓰는지에 영향을 주지 않습니다. 이 파일이 있는 모듈은 관례를 따르는 모든 설치 프로그램에서 발견될 수 있습니다.
+:::
+
+## 로컬 개발 워크플로
+
+[BMad 빌더](https://github.com/bmad-code-org/bmad-builder)로 모듈을 만들고 있다면 작업 디렉터리에서 직접 설치할 수 있습니다.
+
+```bash
+npx bmad-method install \
+  --directory ~/my-project \
+  --custom-source ~/my-module-repo/skills \
+  --tools claude-code \
+  --yes
+```
+
+로컬 소스는 캐시에 복사되지 않고 경로로 참조됩니다. 모듈 소스를 업데이트하고 다시 설치하면 설치 프로그램이 최신 변경을 가져옵니다.
+
+:::caution[소스 제거]
+설치 후 로컬 소스 디렉터리를 삭제해도 `_bmad/`에 설치된 모듈 파일은 보존됩니다. 소스 경로가 복원될 때까지 업데이트 중 해당 모듈은 건너뜁니다.
+:::
+
+## 얻는 결과
+
+설치 후 커스텀 모듈은 공식 모듈과 함께 `_bmad/`에 나타납니다.
+
+```
+your-project/
+├── _bmad/
+│   ├── core/              # 내장 core 모듈
+│   ├── bmm/               # 공식 모듈(선택한 경우)
+│   ├── my-module/         # 커스텀 모듈
+│   │   ├── my-skill/
+│   │   │   └── SKILL.md
+│   │   └── module-help.csv
+│   └── _config/
+│       └── manifest.yaml  # 모든 모듈, 버전, 소스를 추적
+└── ...
+```
+
+매니페스트는 각 커스텀 모듈의 소스(Git 소스는 `repoUrl`, 로컬 소스는 `localPath`)를 기록하여 `Quick Update`가 소스를 다시 찾을 수 있게 합니다.
+
+## 커스텀 모듈 업데이트
+
+커스텀 모듈도 일반 업데이트 흐름에 참여합니다.
+
+- **Quick Update**(`--action quick-update`): 모든 모듈을 원래 소스에서 새로 고칩니다. Git 기반 모듈은 다시 가져오고 로컬 모듈은 소스 경로에서 다시 읽힙니다.
+- **전체 업데이트**: 모듈 선택을 다시 실행해 커스텀 모듈을 추가하거나 제거할 수 있습니다.
+
+## 직접 모듈 만들기
+
+다른 사람이 설치할 수 있는 모듈을 만들려면 [BMad 빌더](https://github.com/bmad-code-org/bmad-builder)를 사용하세요.
+
+1. `bmad-module-builder`를 실행해 모듈 초기 구조를 생성합니다
+2. 여러 BMad 빌더 도구로 스킬, 에이전트, 워크플로를 추가합니다
+3. Git 저장소에 게시하거나 폴더 컬렉션을 공유합니다
+4. 다른 사용자는 `--custom-source <your-repo-url>`로 설치합니다
+
+모듈이 발견 모드를 지원하려면 저장소 루트에 `.claude-plugin/marketplace.json`을 포함하세요(Claude 전용이 아닌 도구 간 관례입니다). marketplace.json 형식은 [BMad 빌더 문서](https://github.com/bmad-code-org/bmad-builder)를 참고하세요.
+
+:::tip[먼저 로컬에서 테스트]
+개발 중에는 Git 저장소에 게시하기 전에 로컬 경로로 모듈을 설치해 빠르게 반복하세요.
+:::

docs/ko-kr/how-to/non-interactive-installation.md

@@ -0,0 +1,10 @@
+---
+title: 비대화형 설치
+description: 비대화형 / CI 설치 문서가 이동되었습니다
+sidebar:
+  order: 2
+---
+
+:::note[이 페이지는 이동되었습니다]
+비대화형 및 CI 설치 플래그, 채널 선택, 버전 고정은 통합된 [BMad 설치 방법](./install-bmad.md) 가이드로 이동했습니다. 플래그 참조와 바로 복사해 쓸 수 있는 예시는 [비대화형 CI](./install-bmad.md#headless-ci) 섹션에서 확인하세요.
+:::

docs/ko-kr/how-to/project-context.md

@@ -0,0 +1,132 @@
+---
+title: '프로젝트 컨텍스트 관리'
+description: AI 에이전트를 안내하는 project-context.md를 만들고 유지합니다
+sidebar:
+  order: 10
+---
+
+`project-context.md` 파일을 사용해 모든 워크플로에서 AI 에이전트가 프로젝트의 기술 선호도와 구현 규칙을 따르게 하세요. 이 파일을 항상 참고하게 하려면 도구 컨텍스트나 항상 적용되는 규칙 파일(예: `AGENTS.md`)에 `중요한 프로젝트 컨텍스트와 관례는 [프로젝트 컨텍스트 경로]/project-context.md에 있습니다`라는 줄을 추가할 수도 있습니다.
+
+:::note[필수 조건]
+
+- BMad Method 설치
+- 프로젝트의 기술 스택과 규칙에 대한 이해
+:::
+
+## 사용 시점
+
+- 아키텍처를 시작하기 전에 강한 기술 선호도가 있습니다
+- 아키텍처를 완료했고 구현 결정을 포착하고 싶습니다
+- 이미 확립된 패턴이 있는 기존 코드베이스에서 작업합니다
+- 스토리마다 에이전트가 일관되지 않은 결정을 내리는 문제가 보입니다
+
+## 1단계: 접근 방식 선택
+
+**수동 작성** - 문서화할 규칙을 정확히 알고 있을 때 가장 좋습니다
+
+**아키텍처 후 생성** - 솔루션 설계 중 내려진 결정을 포착할 때 가장 좋습니다
+
+**기존 프로젝트용 생성** - 기존 코드베이스의 패턴을 발견할 때 가장 좋습니다
+
+## 2단계: 파일 만들기
+
+### 옵션 A: 수동 작성
+
+`_bmad-output/project-context.md`에 파일을 만듭니다.
+
+```bash
+mkdir -p _bmad-output
+touch _bmad-output/project-context.md
+```
+
+기술 스택과 구현 규칙을 추가합니다.
+
+```markdown
+---
+project_name: '내프로젝트'
+user_name: '사용자이름'
+date: '2026-02-15'
+sections_completed: ['technology_stack', 'critical_rules']
+---
+
+# AI 에이전트용 프로젝트 컨텍스트
+
+## 기술 스택과 버전
+
+- Node.js 20.x, TypeScript 5.3, React 18.2
+- 상태 관리: Zustand
+- 테스트: Vitest, Playwright
+- 스타일링: Tailwind CSS
+
+## 중요한 구현 규칙
+
+**TypeScript:**
+
+- 엄격 모드 사용, `any` 타입 금지
+- 공개 API에는 `interface`, 유니언에는 `type` 사용
+
+**코드 구성:**
+
+- 컴포넌트는 `/src/components/`에 두고 테스트를 함께 배치
+- API 호출은 `apiClient` 싱글턴 사용 - 직접 fetch 금지
+
+**테스트:**
+
+- 단위 테스트는 비즈니스 로직에 집중
+- 통합 테스트는 MSW로 API를 모킹
+```
+
+### 옵션 B: 아키텍처 후 생성
+
+새 채팅에서 워크플로를 실행합니다.
+
+```bash
+bmad-generate-project-context
+```
+
+워크플로는 아키텍처 문서와 프로젝트 파일을 스캔해 내려진 결정을 담은 컨텍스트 파일을 생성합니다.
+
+### 옵션 C: 기존 프로젝트용 생성
+
+기존 프로젝트에서는 다음을 실행합니다.
+
+```bash
+bmad-generate-project-context
+```
+
+워크플로가 코드베이스를 분석해 규칙을 식별한 뒤 검토하고 다듬을 수 있는 컨텍스트 파일을 생성합니다.
+
+## 3단계: 내용 확인
+
+생성된 파일을 검토하고 다음이 담겨 있는지 확인하세요.
+
+- 올바른 기술 버전
+- 실제 관례(일반적인 모범 사례가 아님)
+- 흔한 실수를 예방하는 규칙
+- 프레임워크별 패턴
+
+누락된 내용은 수동으로 추가하고 부정확한 내용은 제거하세요.
+
+## 얻는 결과
+
+`project-context.md` 파일은 다음을 제공합니다.
+
+- 모든 에이전트가 같은 규칙을 따르게 합니다
+- 스토리 간 일관되지 않은 결정을 방지합니다
+- 구현을 위한 아키텍처 결정을 포착합니다
+- 프로젝트 패턴과 규칙의 참조 자료가 됩니다
+
+## 팁
+
+:::tip[모범 사례]
+
+- **겉으로 잘 드러나지 않는 것에 집중하세요** - "의미 있는 변수명을 사용하라" 같은 보편 규칙보다 "모든 공개 클래스에는 JSDoc을 사용하라"처럼 에이전트가 놓칠 수 있는 패턴을 문서화합니다.
+- **간결하게 유지하세요** - 이 파일은 모든 구현 워크플로에서 로드됩니다. 긴 파일은 컨텍스트를 낭비합니다. 좁은 범위나 특정 스토리에만 적용되는 내용은 제외하세요.
+- **필요할 때 업데이트하세요** - 패턴이 바뀌면 수동으로 수정하거나 큰 아키텍처 변경 후 다시 생성하세요.
+- 빠른 흐름과 전체 BMad Method 프로젝트 모두에 사용할 수 있습니다.
+:::
+
+## 다음 단계
+
+- [**프로젝트 컨텍스트 설명**](../explanation/project-context.md) - 작동 방식을 더 알아보기
+- [**워크플로 맵**](../reference/workflow-map.md) - 어떤 워크플로가 프로젝트 컨텍스트를 로드하는지 보기

docs/ko-kr/how-to/quick-fixes.md

@@ -0,0 +1,96 @@
+---
+title: '빠른 수정'
+description: 빠른 수정과 임시 변경을 수행하는 방법
+sidebar:
+  order: 6
+---
+
+전체 BMad Method가 필요하지 않은 버그 수정, 리팩터링, 작은 목표 변경에는 **빠른 개발**을 사용하세요.
+
+## 사용 시점
+
+- 원인이 명확하고 알려진 버그 수정
+- 몇 개 파일 안에 제한된 작은 리팩터링(이름 변경, 추출, 구조 변경)
+- 작은 기능 조정이나 설정 변경
+- 의존성 업데이트
+
+:::note[필수 조건]
+
+- BMad Method 설치(`npx bmad-method install`)
+- AI 기반 IDE(Claude Code, Cursor 또는 유사 도구)
+:::
+
+## 단계
+
+### 1. 새 채팅 시작
+
+AI IDE에서 **새 채팅 세션**을 엽니다. 이전 워크플로 세션을 재사용하면 컨텍스트 충돌이 생길 수 있습니다.
+
+### 2. 의도 전달
+
+빠른 개발은 호출 전, 호출과 함께, 또는 호출 후에 자유 형식 의도를 받을 수 있습니다. 예를 들면 다음과 같습니다.
+
+```text
+run quick-dev - 빈 비밀번호를 허용하는 로그인 검증 버그를 수정해 줘.
+```
+
+```text
+run quick-dev - https://github.com/org/repo/issues/42 를 수정해 줘
+```
+
+```text
+run quick-dev - _bmad-output/implementation-artifacts/my-intent.md의 의도를 구현해 줘
+```
+
+```text
+문제는 인증 미들웨어에 있는 것 같아요. 토큰 만료를 확인하지 않습니다.
+확인해 보니 src/auth/middleware.ts 47번째 줄에서 exp 확인을 완전히 건너뜁니다.
+run quick-dev
+```
+
+```text
+run quick-dev
+> 무엇을 하고 싶나요?
+UserService가 콜백 대신 async/await를 사용하도록 리팩터링해 줘.
+```
+
+일반 텍스트, 파일 경로, GitHub 이슈 URL, 버그 트래커 링크 등 LLM이 구체적 의도로 해석할 수 있는 것이면 됩니다.
+
+### 3. 질문에 답하고 승인
+
+빠른 개발은 구현 전에 명확화 질문을 하거나 짧은 사양을 제시해 승인을 요청할 수 있습니다. 질문에 답하고 계획이 만족스러우면 승인하세요.
+
+### 4. 리뷰하고 푸시
+
+빠른 개발이 변경을 구현하고, 자체 리뷰하고, 문제를 패치하고, 로컬에 커밋합니다. 완료되면 영향을 받은 파일을 에디터에서 엽니다.
+
+- diff를 훑어 변경이 의도와 맞는지 확인합니다
+- 이상한 점이 있으면 에이전트에게 수정할 내용을 말하세요. 같은 세션에서 반복할 수 있습니다
+
+만족하면 커밋을 푸시하세요. 빠른 개발이 푸시와 PR 생성을 제안합니다.
+
+:::caution[문제가 생기면]
+푸시한 변경이 예상치 못한 문제를 일으키면 `git revert HEAD`로 마지막 커밋을 깔끔하게 되돌리세요. 그런 다음 새 채팅을 시작하고 빠른 개발을 다시 실행해 다른 접근을 시도합니다.
+:::
+
+## 얻는 결과
+
+- 수정 또는 리팩터링이 적용된 소스 파일
+- 테스트 스위트가 있다면 통과하는 테스트
+- Conventional Commit 형식의 푸시 준비 완료 커밋
+
+## 보류 작업
+
+빠른 개발은 각 실행을 하나의 목표에 집중하게 합니다. 요청에 여러 독립 목표가 있거나 리뷰에서 변경과 무관한 기존 문제가 드러나면, 모든 것을 한 번에 처리하지 않고 구현 산출물 디렉터리의 `deferred-work.md` 파일에 따로 보류합니다.
+
+실행 후 이 파일을 확인하세요. 나중에 다시 볼 작업 백로그입니다. 각 보류 항목은 이후 새 빠른 개발 실행에 넣을 수 있습니다.
+
+## 정식 계획으로 업그레이드할 때
+
+다음과 같다면 전체 BMad Method 사용을 고려하세요.
+
+- 변경이 여러 시스템에 영향을 주거나 많은 파일의 조율된 업데이트가 필요합니다
+- 범위를 확신하지 못해 먼저 요구사항 발견이 필요합니다
+- 팀을 위해 문서나 아키텍처 결정을 기록해야 합니다
+
+빠른 개발이 BMad Method와 어떻게 맞물리는지는 [빠른 개발](../explanation/quick-dev.md)을 참고하세요.

docs/ko-kr/how-to/shard-large-documents.md

@@ -0,0 +1,78 @@
+---
+title: '문서 샤딩 가이드'
+description: 큰 Markdown 파일을 더 작고 정리된 파일로 나눠 컨텍스트 관리를 개선합니다
+sidebar:
+  order: 11
+---
+
+큰 Markdown 파일을 더 작고 정리된 파일로 나눠 컨텍스트 관리를 개선해야 한다면 `bmad-shard-doc` 도구를 사용하세요.
+
+:::caution[지원 중단]
+이 방식은 더 이상 권장되지 않습니다. 업데이트된 워크플로와 대부분의 주요 LLM 및 도구가 하위 프로세스를 지원하게 되면 곧 필요 없어질 것입니다.
+:::
+
+## 사용 시점
+
+선택한 도구/모델 조합이 필요한 모든 문서를 입력으로 로드하고 읽지 못한다는 것을 확인한 경우에만 사용하세요.
+
+## 문서 샤딩이란?
+
+문서 샤딩은 큰 Markdown 파일을 2단계 제목(`## 제목`)을 기준으로 더 작고 정리된 파일로 나눕니다.
+
+### 아키텍처
+
+```text
+샤딩 전:
+_bmad-output/planning-artifacts/
+└── PRD.md (큰 50k 토큰 파일)
+
+샤딩 후:
+_bmad-output/planning-artifacts/
+└── prd/
+    ├── index.md                    # 설명이 있는 목차
+    ├── overview.md                 # 섹션 1
+    ├── user-requirements.md        # 섹션 2
+    ├── technical-requirements.md   # 섹션 3
+    └── ...                         # 추가 섹션
+```
+
+## 단계
+
+### 1. 문서 샤딩 도구 실행
+
+```bash
+/bmad-shard-doc
+```
+
+### 2. 대화형 과정 따르기
+
+```text
+에이전트: 어떤 문서를 샤딩할까요?
+사용자: docs/PRD.md
+
+에이전트: 기본 대상: docs/prd/
+       기본값을 사용할까요? [y/n]
+사용자: y
+
+에이전트: PRD.md를 샤딩하는 중...
+       ✓ 섹션 파일 12개 생성
+       ✓ index.md 생성
+       ✓ 완료!
+```
+
+## 워크플로 발견 방식
+
+BMad 워크플로는 **이중 발견 시스템**을 사용합니다.
+
+1. **먼저 전체 문서 시도** - `document-name.md`를 찾습니다
+2. **샤딩된 버전 확인** - `document-name/index.md`를 찾습니다
+3. **우선순위 규칙** - 둘 다 있으면 전체 문서가 우선합니다. 샤딩된 버전을 사용하려면 전체 문서를 제거하세요
+
+## 워크플로 지원
+
+모든 BMM 워크플로는 두 형식을 모두 지원합니다.
+
+- 전체 문서
+- 샤딩된 문서
+- 자동 감지
+- 사용자에게 투명하게 동작

docs/ko-kr/how-to/upgrade-to-v6.md

@@ -0,0 +1,101 @@
+---
+title: 'v6로 업그레이드하는 방법'
+description: BMad v4에서 v6로 마이그레이션합니다
+sidebar:
+  order: 4
+---
+
+BMad 설치 프로그램을 사용해 v4에서 v6로 업그레이드하세요. 레거시 설치 자동 감지와 마이그레이션 지원이 포함되어 있습니다.
+
+## 사용 시점
+
+- BMad v4가 설치되어 있습니다(`.bmad-method` 폴더)
+- 새 v6 아키텍처로 마이그레이션하고 싶습니다
+- 보존해야 할 기존 계획 산출물이 있습니다
+
+:::note[필수 조건]
+
+- Node.js 20+
+- 기존 BMad v4 설치
+:::
+
+## 단계
+
+### 1. 설치 프로그램 실행
+
+[설치 프로그램 안내](./install-bmad.md)를 따르세요.
+
+### 2. 레거시 설치 처리
+
+v4가 감지되면 다음 중 선택할 수 있습니다.
+
+- 설치 프로그램이 `.bmad-method`를 백업하고 제거하게 합니다
+- 종료한 뒤 수동으로 정리합니다
+
+BMad Method 폴더 이름을 다르게 지정했다면 직접 폴더를 제거해야 합니다.
+
+### 3. IDE 스킬 정리
+
+레거시 v4 IDE 명령/스킬을 수동으로 제거하세요. 예를 들어 Claude Code를 사용한다면 bmad로 시작하는 중첩 폴더를 찾아 제거합니다.
+
+- `.claude/commands/`
+
+새 v6 스킬은 다음 위치에 설치됩니다.
+
+- `.claude/skills/`
+
+### 4. 계획 산출물 마이그레이션
+
+**계획 문서(제품 개요/PRD/UX/아키텍처)가 있다면:**
+
+설명적인 이름으로 `_bmad-output/planning-artifacts/`에 옮기세요.
+
+- PRD 문서는 파일명에 `PRD`를 포함합니다
+- 파일 유형에 맞게 `brief`, `architecture`, `ux-design`을 포함합니다
+- 샤딩된 문서는 이름 있는 하위 폴더에 둘 수 있습니다
+
+**계획 도중이라면:** v6 워크플로로 다시 시작하는 것을 고려하세요. 기존 문서를 입력으로 사용할 수 있습니다. 웹 검색과 IDE 계획 모드를 활용하는 새 점진적 발견 워크플로가 더 좋은 결과를 만듭니다.
+
+### 5. 진행 중인 개발 마이그레이션
+
+이미 생성 또는 구현된 스토리가 있다면:
+
+1. v6 설치를 완료합니다
+2. `epics.md` 또는 `epics/epic*.md`를 `_bmad-output/planning-artifacts/`에 둡니다
+3. 개발자의 `bmad-sprint-planning` 워크플로를 실행합니다
+4. 이미 완료된 에픽/스토리를 에이전트에게 알려줍니다
+
+## 얻는 결과
+
+**v6 통합 구조:**
+
+```text
+your-project/
+├── _bmad/               # 단일 설치 폴더
+│   ├── _config/         # 커스터마이징
+│   │   └── agents/      # 에이전트 커스터마이징 파일
+│   ├── core/            # 범용 core 프레임워크
+│   ├── bmm/             # BMad Method 모듈
+│   ├── bmb/             # BMad 빌더
+│   └── cis/             # 창의적 지능 제품군
+└── _bmad-output/        # 출력 폴더(v4의 문서 폴더)
+```
+
+## 모듈 마이그레이션
+
+| v4 모듈 | v6 상태 |
+| --- | --- |
+| `.bmad-2d-phaser-game-dev` | BMGD 모듈에 통합 |
+| `.bmad-2d-unity-game-dev` | BMGD 모듈에 통합 |
+| `.bmad-godot-game-dev` | BMGD 모듈에 통합 |
+| `.bmad-infrastructure-devops` | 지원 중단 - 새 DevOps 에이전트 예정 |
+| `.bmad-creative-writing` | 아직 적용되지 않음 - 새 v6 모듈 예정 |
+
+## 주요 변경 사항
+
+| 개념 | v4 | v6 |
+| --- | --- | --- |
+| **코어** | `_bmad-core`는 실제로 BMad Method였습니다 | `_bmad/core/`는 범용 프레임워크입니다 |
+| **메서드** | `_bmad-method` | `_bmad/bmm/` |
+| **설정** | 파일을 직접 수정 | 모듈별 `config.yaml` |
+| **문서** | 샤딩 또는 비샤딩 필수 설정 | 완전히 유연하며 자동 스캔 |

docs/ko-kr/index.md

@@ -0,0 +1,60 @@
+---
+title: BMad Method에 오신 것을 환영합니다
+description: 전문 에이전트, 안내형 워크플로, 지능형 계획을 제공하는 AI 기반 개발 프레임워크
+---
+
+BMad Method(**B**uild **M**ore **A**rchitect **D**reams)는 BMad Method 생태계에 속한 AI 기반 개발 프레임워크입니다. 아이디어 구상과 계획부터 에이전트 기반 구현까지 소프트웨어 개발 전 과정을 돕습니다. 버그 수정부터 엔터프라이즈 플랫폼 구축까지, 프로젝트 복잡도에 맞춰 전문 AI 에이전트, 안내형 워크플로, 지능형 계획을 제공합니다.
+
+Claude, Cursor, GitHub Copilot 같은 AI 코딩 어시스턴트로 작업하는 데 익숙하다면 바로 시작할 준비가 된 것입니다.
+
+:::note[V6가 출시되었습니다. 이제 시작입니다.]
+스킬 아키텍처, BMad Builder v1, Dev Loop Automation 등 훨씬 많은 기능이 준비 중입니다. [**로드맵 보기**](/ko-kr/roadmap/)
+:::
+
+## 처음이라면 튜토리얼부터 시작하세요
+
+BMad를 가장 빠르게 이해하는 방법은 직접 써보는 것입니다.
+
+- **[BMad 시작하기](./tutorials/getting-started.md)** - BMad를 설치하고 작동 방식을 이해합니다
+- **[워크플로 맵](./reference/workflow-map.md)** - BMM 단계, 워크플로, 컨텍스트 관리를 한눈에 보여줍니다
+
+:::tip[바로 시작하고 싶나요?]
+BMad를 설치하고 `bmad-help` 스킬을 사용하세요. 프로젝트와 설치된 모듈에 맞춰 모든 과정을 안내합니다.
+:::
+
+## 이 문서를 사용하는 방법
+
+이 문서는 하려는 일에 따라 네 가지 섹션으로 구성되어 있습니다.
+
+| 섹션 | 목적 |
+| --- | --- |
+| **튜토리얼** | 학습 중심입니다. 무언가를 만들어 보며 따라가는 단계별 가이드입니다. 처음이라면 여기서 시작하세요. |
+| **사용 가이드** | 작업 중심입니다. 특정 문제를 해결하기 위한 실용 가이드입니다. "에이전트를 어떻게 커스터마이즈하지?" 같은 질문을 여기서 다룹니다. |
+| **개념 설명** | 이해 중심입니다. 개념과 아키텍처를 깊게 설명합니다. *왜* 그런지 알고 싶을 때 읽으세요. |
+| **참조** | 정보 중심입니다. 에이전트, 워크플로, 설정에 대한 기술 사양입니다. |
+
+## 확장과 커스터마이징
+
+직접 만든 에이전트, 워크플로, 모듈로 BMad를 확장하고 싶나요? [**BMad Builder**](https://bmad-builder-docs.bmad-method.org/)는 BMad에 새 기능을 더하거나 완전히 새로운 모듈을 만들 수 있는 프레임워크와 도구를 제공합니다.
+
+## 필요한 것
+
+BMad는 커스텀 시스템 프롬프트나 프로젝트 컨텍스트를 지원하는 AI 코딩 어시스턴트라면 무엇이든 함께 사용할 수 있습니다. 널리 쓰이는 선택지는 다음과 같습니다.
+
+- **[Claude Code](https://code.claude.com)** - Anthropic의 CLI 도구(권장)
+- **[Cursor](https://cursor.sh)** - AI 우선 코드 에디터
+- **[Codex CLI](https://github.com/openai/codex)** - OpenAI의 터미널 코딩 에이전트
+
+버전 관리, 프로젝트 구조, 애자일 워크플로 같은 기본 소프트웨어 개발 개념에 익숙하면 좋습니다. BMad 스타일의 에이전트 시스템 경험은 없어도 됩니다. 이 문서가 그 시작점이 되어 줍니다.
+
+## 커뮤니티 참여
+
+도움을 받고, 만들고 있는 것을 공유하고, BMad에 기여하세요.
+
+- **[Discord](https://discord.gg/gk8jAdXWmj)** - 다른 BMad 사용자와 대화하고 질문하고 아이디어를 공유합니다
+- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** - 소스 코드, 이슈, 기여
+- **[YouTube](https://www.youtube.com/@BMadCode)** - 영상 튜토리얼과 워크스루
+
+## 다음 단계
+
+시작할 준비가 되었나요? [**BMad 시작하기**](./tutorials/getting-started.md)를 열고 첫 프로젝트를 만들어 보세요.

docs/ko-kr/reference/agents.md

@@ -0,0 +1,55 @@
+---
+title: 에이전트
+description: 기본 BMM 에이전트와 스킬 ID, 메뉴 트리거, 주요 워크플로
+sidebar:
+  order: 2
+---
+
+## 기본 에이전트
+
+이 페이지는 BMad Method와 함께 설치되는 기본 BMM(애자일 제품군) 에이전트를 스킬 ID, 메뉴 트리거, 주요 워크플로와 함께 나열합니다. 각 에이전트는 스킬로 호출됩니다.
+
+## 참고
+
+- 각 에이전트는 설치 프로그램이 생성하는 스킬로 제공됩니다. 스킬 ID(예: `bmad-dev`)를 사용해 에이전트를 호출합니다.
+- 트리거는 각 에이전트 메뉴에 표시되는 짧은 메뉴 코드(예: `CP`)와 유사 매칭 항목입니다.
+- QA 테스트 생성은 개발자 에이전트를 통해 사용할 수 있는 `bmad-qa-generate-e2e-tests` 워크플로 스킬이 처리합니다. 전체 테스트 설계자(TEA)는 별도 모듈에 있습니다.
+
+| 에이전트 | 스킬 ID | 트리거 | 주요 워크플로 |
+| --- | --- | --- | --- |
+| 분석가(Mary) | `bmad-analyst` | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | 브레인스토밍, 시장 리서치, 도메인 리서치, 기술 리서치, 개요 작성, PRFAQ 챌린지, 프로젝트 문서화 |
+| 제품 관리자(John) | `bmad-pm` | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | PRD 생성/검증/편집, 에픽과 스토리 생성, 구현 준비 상태, 경로 수정 |
+| 아키텍트(Winston) | `bmad-architect` | `CA`, `IR` | 아키텍처 생성, 구현 준비 상태 |
+| 개발자(Amelia) | `bmad-agent-dev` | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | 스토리 구현, 빠른 개발, QA 테스트 생성, 코드 리뷰, 스프린트 계획, 스토리 생성, 에픽 회고 |
+| UX 디자이너(Sally) | `bmad-ux-designer` | `CU` | UX 설계 생성 |
+| 기술 작성자(Paige) | `bmad-tech-writer` | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | 프로젝트 문서화, 문서 작성, 표준 업데이트, Mermaid 생성, 문서 검증, 개념 설명 |
+
+## 트리거 유형
+
+에이전트 메뉴 트리거는 두 가지 호출 방식을 사용합니다. 어떤 유형인지 알면 올바른 입력을 제공하기 쉽습니다.
+
+### 워크플로 트리거(인수 불필요)
+
+대부분의 트리거는 구조화된 워크플로 파일을 로드합니다. 트리거 코드를 입력하면 에이전트가 워크플로를 시작하고 각 단계에서 입력을 요청합니다.
+
+예: `CP`(PRD 생성), `DS`(스토리 구현), `CA`(아키텍처 생성), `QD`(빠른 개발)
+
+### 대화형 트리거(인수 필요)
+
+일부 트리거는 구조화된 워크플로 대신 자유 형식 대화를 시작합니다. 트리거 코드와 함께 필요한 내용을 설명해야 합니다.
+
+| 에이전트 | 트리거 | 제공할 내용 |
+| --- | --- | --- |
+| 기술 작성자(Paige) | `WD` | 작성할 문서 설명 |
+| 기술 작성자(Paige) | `US` | 표준에 추가할 선호 사항 또는 관례 |
+| 기술 작성자(Paige) | `MG` | 다이어그램 설명과 유형(시퀀스, 플로차트 등) |
+| 기술 작성자(Paige) | `VD` | 검증할 문서와 집중 영역 |
+| 기술 작성자(Paige) | `EC` | 설명할 개념 이름 |
+
+**예시:**
+
+```text
+WD 우리 Docker 설정에 대한 배포 가이드를 작성해 줘
+MG 인증 흐름을 보여 주는 시퀀스 다이어그램을 만들어 줘
+EC 모듈 시스템이 어떻게 작동하는지 설명해 줘
+```

docs/ko-kr/reference/commands.md

@@ -0,0 +1,135 @@
+---
+title: 스킬
+description: BMad 스킬의 정의, 작동 방식, 위치에 대한 참조
+sidebar:
+  order: 4
+---
+
+스킬은 IDE 안에서 에이전트를 로드하거나 워크플로를 실행하거나 작업을 처리하는 미리 작성된 프롬프트입니다. BMad 설치 프로그램은 설치 시 선택한 모듈에서 스킬을 생성합니다. 나중에 모듈을 추가, 제거, 변경했다면 설치 프로그램을 다시 실행해 스킬을 동기화하세요([문제 해결](#문제-해결) 참고).
+
+## 스킬 vs 에이전트 메뉴 트리거
+
+BMad는 작업을 시작하는 두 가지 방법을 제공하며 목적이 다릅니다.
+
+| 방식 | 호출 방법 | 일어나는 일 |
+| --- | --- | --- |
+| **스킬** | IDE에서 스킬 이름(예: `bmad-help`)을 입력 | 에이전트를 직접 로드하거나 워크플로를 실행하거나 작업을 처리 |
+| **에이전트 메뉴 트리거** | 에이전트를 먼저 로드한 뒤 짧은 코드(예: `DS`) 입력 | 에이전트가 페르소나를 유지한 채 코드를 해석하고 일치하는 워크플로를 시작 |
+
+에이전트 메뉴 트리거는 활성 에이전트 세션이 필요합니다. 어떤 워크플로를 원하는지 알고 있다면 스킬을 사용하세요. 이미 에이전트와 작업 중이고 대화를 떠나지 않고 작업을 바꾸고 싶다면 트리거를 사용하세요.
+
+## 스킬 생성 방식
+
+`npx bmad-method install`을 실행하면 설치 프로그램은 선택된 모든 모듈의 매니페스트를 읽고 에이전트, 워크플로, 작업, 도구마다 하나의 스킬을 작성합니다. 각 스킬은 AI에게 해당 소스 파일을 로드하고 지시를 따르라고 안내하는 `SKILL.md` 파일이 있는 폴더입니다.
+
+설치 프로그램은 스킬 유형별 템플릿을 사용합니다.
+
+| 스킬 유형 | 생성 파일의 역할 |
+| --- | --- |
+| **에이전트 실행기** | 에이전트 페르소나 파일을 로드하고 메뉴를 활성화하며 페르소나를 유지 |
+| **워크플로 스킬** | 워크플로 설정을 로드하고 단계를 따름 |
+| **작업 스킬** | 단독 실행 작업 파일을 로드하고 지시를 따름 |
+| **도구 스킬** | 단독 실행 도구 파일을 로드하고 지시를 따름 |
+
+:::note[설치 프로그램 다시 실행]
+모듈을 추가하거나 제거했다면 설치 프로그램을 다시 실행하세요. 현재 모듈 선택에 맞춰 모든 스킬 파일을 다시 생성합니다.
+:::
+
+## 스킬 파일 위치
+
+설치 프로그램은 프로젝트 안의 IDE별 디렉터리에 스킬 파일을 씁니다. 정확한 경로는 설치 중 선택한 IDE에 따라 달라집니다.
+
+| IDE / CLI | Skills 디렉터리 |
+| --- | --- |
+| Claude Code | `.claude/skills/` |
+| Cursor | `.cursor/skills/` |
+| Windsurf | `.windsurf/skills/` |
+| 기타 IDE | 대상 경로는 설치 프로그램 출력 참고 |
+
+각 스킬은 `SKILL.md` 파일을 포함하는 폴더입니다. Claude Code 설치 예시는 다음과 같습니다.
+
+```text
+.claude/skills/
+├── bmad-help/
+│   └── SKILL.md
+├── bmad-prd/
+│   └── SKILL.md
+├── bmad-agent-dev/
+│   └── SKILL.md
+└── ...
+```
+
+디렉터리 이름이 IDE에서의 스킬 이름을 결정합니다. 예를 들어 `bmad-agent-dev/` 디렉터리는 `bmad-agent-dev` 스킬을 등록합니다.
+
+## 스킬 찾기
+
+IDE에서 스킬 이름을 입력해 호출합니다. 일부 플랫폼은 스킬이 나타나기 전에 설정에서 활성화해야 합니다.
+
+다음 단계를 상황에 맞게 안내받으려면 `bmad-help`를 실행하세요.
+
+:::tip[빠른 탐색]
+프로젝트에 생성된 스킬 디렉터리가 기준 목록입니다. 파일 탐색기에서 열면 설명이 있는 모든 스킬을 볼 수 있습니다.
+:::
+
+## 스킬 범주
+
+### 에이전트 스킬
+
+에이전트 스킬은 정의된 역할, 커뮤니케이션 스타일, 워크플로 메뉴를 가진 전문 AI 페르소나를 로드합니다. 로드되면 에이전트는 페르소나를 유지하고 메뉴 트리거에 응답합니다.
+
+| 예시 스킬 | 에이전트 | 역할 |
+| --- | --- | --- |
+| `bmad-agent-dev` | Amelia(개발자) | 사양을 엄격히 준수해 스토리 구현 |
+| `bmad-pm` | John(제품 관리자) | PRD 생성 및 검증 |
+| `bmad-architect` | Winston(아키텍트) | 시스템 아키텍처 설계 |
+
+기본 에이전트와 트리거 전체 목록은 [에이전트](./agents.md)를 참고하세요.
+
+### 워크플로 스킬
+
+워크플로 스킬은 에이전트 페르소나를 먼저 로드하지 않고 구조화된 다단계 프로세스를 실행합니다. 워크플로 설정을 로드하고 단계를 따릅니다.
+
+| 예시 스킬 | 목적 |
+| --- | --- |
+| `bmad-product-brief` | 제품 개요 생성 또는 업데이트 - 개념이 명확할 때 안내형 발견 |
+| `bmad-prfaq` | 제품 개념을 스트레스 테스트하는 [워킹 백워드 PRFAQ](../explanation/analysis-phase.md#prfaq-working-backwards) 챌린지 |
+| `bmad-prd` | 제품 요구사항 문서(PRD) 생성, 업데이트, 검증 |
+| `bmad-create-architecture` | 시스템 아키텍처 설계 |
+| `bmad-create-epics-and-stories` | 에픽과 스토리 생성 |
+| `bmad-dev-story` | 스토리 구현 |
+| `bmad-code-review` | 코드 리뷰 실행 |
+| `bmad-quick-dev` | 통합 빠른 흐름 - 의도 정리, 계획, 구현, 리뷰, 발표 |
+
+단계별 전체 워크플로 참조는 [워크플로 맵](./workflow-map.md)을 참고하세요.
+
+### 작업과 도구 스킬
+
+작업과 도구는 에이전트나 워크플로 컨텍스트 없이 실행되는 단독 작업입니다.
+
+**BMad 도움말: 지능형 안내자**
+
+`bmad-help`는 다음에 무엇을 해야 할지 찾는 기본 인터페이스입니다. 프로젝트를 검사하고, 자연어 쿼리를 이해하며, 설치된 모듈을 기준으로 다음 필수 또는 선택 단계를 추천합니다.
+
+:::note[예시]
+```
+bmad-help
+bmad-help SaaS 아이디어가 있고 기능도 모두 알고 있습니다. 어디서 시작하나요?
+bmad-help UX 설계에는 어떤 선택지가 있나요?
+```
+:::
+
+**기타 핵심 작업과 도구**
+
+핵심 모듈에는 리뷰, 압축, 브레인스토밍, 문서 관리 등 11개의 내장 도구가 포함됩니다. 전체 참조는 [핵심 도구](./core-tools.md)를 참고하세요.
+
+## 이름 규칙
+
+모든 스킬은 `bmad-` 접두사 뒤에 설명적인 이름을 붙입니다(예: `bmad-agent-dev`, `bmad-prd`, `bmad-help`). 사용 가능한 모듈은 [모듈](./modules.md)을 참고하세요.
+
+## 문제 해결
+
+**설치 후 스킬이 보이지 않음.** 일부 플랫폼은 설정에서 스킬을 명시적으로 활성화해야 합니다. IDE 문서를 확인하거나 AI 어시스턴트에게 스킬 활성화 방법을 물어보세요. IDE 재시작 또는 창 새로고침이 필요할 수도 있습니다.
+
+**예상한 스킬이 없음.** 설치 프로그램은 선택한 모듈의 스킬만 생성합니다. `npx bmad-method install`을 다시 실행하고 모듈 선택을 확인하세요. 예상 디렉터리에 스킬 파일이 있는지 확인하세요.
+
+**제거한 모듈의 스킬이 계속 보임.** 설치 프로그램은 오래된 스킬 파일을 자동으로 삭제하지 않습니다. IDE 스킬 디렉터리에서 오래된 디렉터리를 제거하거나 전체 스킬 디렉터리를 삭제한 뒤 설치 프로그램을 다시 실행해 깨끗한 스킬 세트를 만드세요.

docs/ko-kr/reference/core-tools.md

@@ -0,0 +1,293 @@
+---
+title: 핵심 도구
+description: 추가 모듈 없이 모든 BMad 설치에서 사용할 수 있는 내장 작업과 워크플로 참조
+sidebar:
+  order: 3
+---
+
+모든 BMad 설치에는 어떤 작업을 하든 함께 사용할 수 있는 핵심 스킬 모음이 포함됩니다. 모든 프로젝트, 모든 모듈, 모든 단계에서 단독으로 실행할 수 있는 작업과 워크플로입니다. 어떤 선택 모듈을 설치했든 항상 사용할 수 있습니다.
+
+:::tip[빠른 경로]
+IDE에서 스킬 이름(예: `bmad-help`)을 입력해 어떤 핵심 도구든 실행하세요. 에이전트 세션은 필요 없습니다.
+:::
+
+## 개요
+
+| 도구 | 유형 | 목적 |
+| --- | --- | --- |
+| [`bmad-help`](#bmad-help) | 작업 | 다음에 무엇을 해야 할지 상황에 맞게 안내 |
+| [`bmad-brainstorming`](#bmad-brainstorming) | 워크플로 | 대화형 브레인스토밍 세션 진행 |
+| [`bmad-party-mode`](#bmad-party-mode) | 워크플로 | 다중 에이전트 그룹 토론 조율 |
+| [`bmad-distillator`](#bmad-distillator) | 작업 | 문서의 무손실 LLM 최적화 압축 |
+| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation) | 작업 | LLM 출력을 반복 개선 방식으로 끌어올림 |
+| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | 작업 | 빠진 것과 틀린 것을 찾는 비판적 리뷰 |
+| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter) | 작업 | 처리되지 않은 엣지 케이스를 찾기 위한 철저한 분기 경로 분석 |
+| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose) | 작업 | 전달 명확성을 위한 엄격한 문장 교정 |
+| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | 작업 | 구조 편집 - 삭제, 병합, 재구성 |
+| [`bmad-shard-doc`](#bmad-shard-doc) | 작업 | 큰 Markdown 파일을 정리된 섹션으로 분할 |
+| [`bmad-index-docs`](#bmad-index-docs) | 작업 | 폴더 내 모든 문서 색인 생성 또는 업데이트 |
+
+## bmad-help
+
+**다음에 무엇을 해야 할지 알려주는 지능형 안내자입니다.** 프로젝트 상태를 검사하고, 완료된 것을 감지하며, 다음 필수 또는 선택 단계를 추천합니다.
+
+**사용 시점:**
+
+- 워크플로를 끝냈고 다음 단계를 알고 싶습니다
+- BMad가 처음이라 방향 안내가 필요합니다
+- 막혀서 상황에 맞는 조언이 필요합니다
+- 새 모듈을 설치했고 사용할 수 있는 것을 보고 싶습니다
+
+**작동 방식:**
+
+1. 프로젝트에서 기존 산출물(PRD, 아키텍처, 스토리 등)를 스캔합니다
+2. 설치된 모듈과 사용 가능한 워크플로를 감지합니다
+3. 우선순위 순서로 다음 단계를 추천합니다. 필수 단계를 먼저, 선택 단계를 나중에 제시합니다
+4. 각 추천을 스킬 명령과 짧은 설명으로 보여줍니다
+
+**입력:** 자연어 선택 쿼리(예: `bmad-help SaaS 아이디어가 있는데 어디서 시작하나요?`)
+
+**출력:** 스킬 명령이 포함된 권장 다음 단계의 우선순위 목록
+
+## bmad-brainstorming
+
+**대화형 창의 기법으로 다양한 아이디어를 생성합니다.** 기법 라이브러리에서 검증된 아이디어 발상법을 로드하고 100개 이상의 아이디어를 향해 안내한 뒤 정리하는 브레인스토밍 세션입니다.
+
+**사용 시점:**
+
+- 새 프로젝트를 시작하고 문제 영역을 탐색해야 합니다
+- 아이디어 생성이 막혀 구조화된 창의 기법이 필요합니다
+- SCAMPER, 역브레인스토밍 같은 검증된 아이디어 발상 프레임워크를 사용하고 싶습니다
+
+**작동 방식:**
+
+1. 주제로 브레인스토밍 세션을 설정합니다
+2. 기법 라이브러리에서 창의 기법을 로드합니다
+3. 기법을 하나씩 진행하며 아이디어를 생성합니다
+4. 편향 방지 프로토콜을 적용합니다. 10개 아이디어마다 창의 영역을 바꿔 군집화를 방지합니다
+5. 모든 아이디어를 기법별로 정리한 추가 전용 세션 문서를 만듭니다
+
+**입력:** 브레인스토밍 주제 또는 문제 설명, 선택 사항 컨텍스트 파일
+
+**출력:** 생성된 모든 아이디어가 담긴 `brainstorming-session-{date}.md`
+
+:::note[수량 목표]
+핵심은 아이디어 50-100개 지점에서 나옵니다. 이 워크플로는 정리 전에 100개 이상의 아이디어 생성을 권장합니다.
+:::
+
+## bmad-party-mode
+
+**다중 에이전트 그룹 토론을 조율합니다.** 설치된 모든 BMad 에이전트를 로드하고 각 에이전트가 고유한 전문성과 페르소나로 기여하는 자연스러운 대화를 진행합니다.
+
+**사용 시점:**
+
+- 결정에 여러 전문가 관점이 필요합니다
+- 에이전트들이 서로의 가정에 도전하길 원합니다
+- 여러 도메인에 걸친 복잡한 주제를 탐색합니다
+
+**작동 방식:**
+
+1. 설치된 모든 에이전트 페르소나가 있는 에이전트 매니페스트를 로드합니다
+2. 주제를 분석해 가장 관련 있는 에이전트 2-3개를 선택합니다
+3. 에이전트들이 턴을 나눠 기여하고 자연스러운 상호 대화와 의견 차이를 만듭니다
+4. 시간이 지나며 참여 에이전트를 순환해 다양한 관점을 보장합니다
+5. `goodbye`, `end party`, `quit`로 종료합니다
+
+**입력:** 토론 주제 또는 질문, 참여시키고 싶은 페르소나 지정(선택 사항)
+
+**출력:** 에이전트 페르소나가 유지되는 실시간 다중 에이전트 대화
+
+## bmad-distillator
+
+**소스 문서의 무손실 LLM 최적화 압축입니다.** 후속 LLM 사용을 위해 모든 정보를 보존하는 조밀하고 토큰 효율적인 요약본을 생성합니다. 왕복 재구성으로 검증할 수 있습니다.
+
+**사용 시점:**
+
+- 문서가 LLM 컨텍스트 창에 너무 큽니다
+- 리서치, 사양, 계획 산출물의 토큰 효율적인 버전이 필요합니다
+- 압축 중 정보 손실이 없는지 검증하고 싶습니다
+- 에이전트가 자주 참조하고 정보를 찾아야 합니다
+
+**작동 방식:**
+
+1. **분석** - 소스 문서를 읽고 정보 밀도와 구조를 식별합니다
+2. **압축** - 문장을 조밀한 글머리표 형식으로 바꾸고 장식적 서식을 제거합니다
+3. **확인** - 원래 정보가 모두 보존되었는지 완전성을 확인합니다
+4. **검증(선택 사항)** - 왕복 재구성 테스트로 무손실 압축을 증명합니다
+
+**입력:**
+
+- `source_documents`(필수) - 파일 경로, 폴더 경로, glob 패턴
+- `downstream_consumer`(선택 사항) - 이 요약본을 사용할 대상(예: "PRD 작성")
+- `token_budget`(선택 사항) - 대략적 목표 크기
+- `--validate`(플래그) - 왕복 재구성 테스트 실행
+
+**출력:** 압축률 보고서(예: "3.2:1")가 포함된 요약 Markdown 파일
+
+## bmad-advanced-elicitation
+
+**LLM 출력을 반복 개선 방식으로 개선합니다.** 도출 기법 라이브러리에서 선택해 여러 차례에 걸쳐 내용을 체계적으로 개선합니다.
+
+**사용 시점:**
+
+- LLM 출력이 얕거나 일반적으로 느껴집니다
+- 여러 분석 관점에서 주제를 탐색하고 싶습니다
+- 중요한 문서를 다듬고 더 깊은 사고가 필요합니다
+
+**작동 방식:**
+
+1. 5개 이상의 도출 기법이 있는 기법 레지스트리를 로드합니다
+2. 내용 유형과 복잡도에 가장 잘 맞는 기법 5개를 선택합니다
+3. 대화형 메뉴를 제시합니다. 기법 선택, 다시 섞기, 전체 목록 보기가 가능합니다
+4. 선택한 기법을 적용해 내용을 강화합니다
+5. "진행"을 선택할 때까지 반복 개선 옵션을 다시 제시합니다
+
+**입력:** 강화할 내용 섹션
+
+**출력:** 개선이 적용된 버전
+
+## bmad-review-adversarial-general
+
+**문제가 있다고 가정하고 찾는 비판적 리뷰입니다.** 허술한 작업을 용납하지 않는 회의적인 리뷰어의 관점을 취합니다. 틀린 것뿐 아니라 빠진 것을 찾습니다.
+
+**사용 시점:**
+
+- 산출물 확정 전 품질 보증이 필요합니다
+- 사양, 스토리, 문서를 스트레스 테스트하고 싶습니다
+- 낙관적인 리뷰가 놓치는 검토 공백을 찾고 싶습니다
+
+**작동 방식:**
+
+1. 냉정하고 비판적인 관점으로 내용을 읽습니다
+2. 완전성, 정확성, 품질 전반의 이슈를 식별합니다
+3. 존재하지만 잘못된 것만이 아니라 빠진 것을 특히 찾습니다
+4. 최소 10개 이슈를 찾아야 하며, 부족하면 더 깊게 재분석합니다
+
+**입력:**
+
+- `content`(필수) - diff, 사양, 스토리, 문서 또는 모든 산출물
+- `also_consider`(선택 사항) - 추가로 염두에 둘 영역
+
+**출력:** 설명이 있는 10개 이상의 발견 사항 Markdown 목록
+
+## bmad-review-edge-case-hunter
+
+**모든 분기 경로와 경계 조건을 따라가며 처리되지 않은 사례만 보고합니다.** 엣지 케이스 유형을 기계적으로 도출하는 순수 경로 추적 기법입니다. 적대적 리뷰와 상호 보완적이며, 태도 기반이 아니라 기법 기반입니다.
+
+**사용 시점:**
+
+- 코드나 로직에 대한 철저한 엣지 케이스 검토가 필요합니다
+- 적대적 리뷰를 보완하고 싶습니다(다른 기법, 다른 발견 사항)
+- 경계 조건을 확인하기 위해 diff나 함수를 리뷰합니다
+
+**작동 방식:**
+
+1. 내용의 모든 분기 경로를 열거합니다
+2. 누락된 else/기본값, 보호되지 않은 입력, off-by-one, 산술 오버플로, 암시적 타입 강제 변환, 경쟁 상태, 타임아웃 공백 같은 엣지 케이스 유형을 기계적으로 도출합니다
+3. 각 경로를 기존 방어 로직과 대조합니다
+4. 처리되지 않은 경로만 보고합니다. 이미 처리된 경로는 조용히 버립니다
+
+**입력:**
+
+- `content`(필수) - diff, 전체 파일, 함수
+- `also_consider`(선택 사항) - 추가로 염두에 둘 영역
+
+**출력:** 각 발견 사항이 `location`, `trigger_condition`, `guard_snippet`, `potential_consequence`를 포함하는 JSON 배열
+
+:::note[상호 보완 리뷰]
+상호 보완적 검토를 위해 `bmad-review-adversarial-general`과 `bmad-review-edge-case-hunter`를 함께 실행하세요. 적대적 리뷰는 품질과 완전성 이슈를 잡고, 엣지 케이스 헌터는 처리되지 않은 경로를 잡습니다.
+:::
+
+## bmad-editorial-review-prose
+
+**전달 명확성에 집중한 엄격한 문장 교정입니다.** 이해를 방해하는 문장 문제를 리뷰합니다. Microsoft Writing Style Guide 기준을 적용하고 작성자 목소리를 보존합니다.
+
+**사용 시점:**
+
+- 문서를 초안으로 작성했고 문장을 다듬고 싶습니다
+- 특정 독자를 위한 명확성을 보장해야 합니다
+- 취향 기반 수정 없이 전달만 개선하고 싶습니다
+
+**작동 방식:**
+
+1. 코드 블록과 프런트매터를 건너뛰고 내용을 읽습니다
+2. 스타일 선호가 아닌 전달 이슈를 식별합니다
+3. 여러 위치의 같은 이슈를 중복 제거합니다
+4. 세 열 수정 테이블을 생성합니다
+
+**입력:**
+
+- `content`(필수) - Markdown, 일반 텍스트, XML
+- `style_guide`(선택 사항) - 프로젝트별 스타일 가이드
+- `reader_type`(선택 사항) - 명확성/흐름용 `humans`(기본값) 또는 정밀도/일관성용 `llm`
+
+**출력:** 세 열 Markdown 테이블: `Original Text | Revised Text | Changes`
+
+## bmad-editorial-review-structure
+
+**구조 편집입니다. 삭제, 병합, 이동, 압축을 제안합니다.** 문장 교정 전에 문서 구성을 리뷰하고 명확성과 흐름을 개선하는 실질적 변경을 제안합니다.
+
+**사용 시점:**
+
+- 여러 하위 프로세스에서 생성된 문서에 구조적 일관성이 필요합니다
+- 이해도를 유지하면서 문서 길이를 줄이고 싶습니다
+- 범위 위반이나 묻힌 핵심 정보를 식별해야 합니다
+
+**작동 방식:**
+
+1. 5개 구조 모델(튜토리얼, 참조, 설명, 프롬프트, 전략)에 대해 문서를 분석합니다
+2. 중복, 범위 위반, 묻힌 정보를 식별합니다
+3. 우선순위 권장 사항을 생성합니다: `CUT`, `MERGE`, `MOVE`, `CONDENSE`, `QUESTION`, `PRESERVE`
+4. 총 단어 감소량과 감소율을 추정합니다
+
+**입력:**
+
+- `content`(필수) - 리뷰할 문서
+- `purpose`(선택 사항) - 의도한 목적(예: "빠른 시작 튜토리얼")
+- `target_audience`(선택 사항) - 독자
+- `reader_type`(선택 사항) - `humans` 또는 `llm`
+- `length_target`(선택 사항) - 목표 감소량(예: "30% 줄이기")
+
+**출력:** 문서 요약, 우선순위 권장 사항 목록, 예상 감소량
+
+## bmad-shard-doc
+
+**큰 Markdown 파일을 정리된 섹션 파일로 나눕니다.** 2단계 헤더를 분할 지점으로 사용해 독립적인 섹션 파일과 색인이 있는 폴더를 만듭니다.
+
+**사용 시점:**
+
+- Markdown 문서가 너무 커져 효과적으로 관리하기 어렵습니다(500줄 이상)
+- 단일 문서를 탐색 가능한 섹션으로 나누고 싶습니다
+- 병렬 편집 또는 LLM 컨텍스트 관리를 위해 별도 파일이 필요합니다
+
+**작동 방식:**
+
+1. 소스 파일이 존재하고 Markdown인지 검증합니다
+2. 2단계(`##`) 헤더 기준으로 번호가 붙은 섹션 파일로 나눕니다
+3. 섹션 매니페스트와 링크가 있는 `index.md`를 만듭니다
+4. 원본을 삭제, 보관, 유지할지 묻습니다
+
+**입력:** 소스 Markdown 파일 경로, 선택 사항 대상 폴더
+
+**출력:** `index.md`와 `01-{section}.md`, `02-{section}.md` 등이 있는 폴더
+
+## bmad-index-docs
+
+**폴더의 모든 문서 색인을 생성하거나 업데이트합니다.** 디렉터리를 스캔하고 각 파일을 읽어 목적을 이해한 뒤 링크와 설명이 있는 정리된 `index.md`를 만듭니다.
+
+**사용 시점:**
+
+- 사용 가능한 문서를 LLM이 빠르게 스캔할 수 있는 가벼운 색인이 필요합니다
+- 문서 폴더가 커져 정리된 목차가 필요합니다
+- 최신 상태를 유지하는 자동 생성 개요를 원합니다
+
+**작동 방식:**
+
+1. 대상 디렉터리에서 숨김이 아닌 파일을 모두 스캔합니다
+2. 각 파일을 읽어 실제 목적을 이해합니다
+3. 유형, 목적, 하위 디렉터리 기준으로 파일을 그룹화합니다
+4. 간결한 설명(각 3-10단어)을 생성합니다
+
+**입력:** 대상 폴더 경로
+
+**출력:** 정리된 파일 목록, 상대 링크, 짧은 설명이 있는 `index.md`

docs/ko-kr/reference/modules.md

@@ -0,0 +1,76 @@
+---
+title: 공식 모듈
+description: 커스텀 에이전트, 창의적 지능, 게임 개발, 테스트를 위한 추가 모듈
+sidebar:
+  order: 5
+---
+
+BMad는 설치 중 선택하는 공식 모듈로 확장됩니다. 이러한 추가 모듈은 내장 핵심 기능과 BMM(애자일 제품군)을 넘어 특정 도메인을 위한 전문 에이전트, 워크플로, 작업을 제공합니다.
+
+:::tip[모듈 설치]
+`npx bmad-method install`을 실행하고 원하는 모듈을 선택하세요. 설치 프로그램이 다운로드, 설정, IDE 통합을 자동으로 처리합니다.
+:::
+
+## BMad 빌더(BMB)
+
+안내형 도구를 사용해 커스텀 에이전트, 워크플로, 도메인 특화 모듈을 만듭니다. BMad 빌더는 프레임워크 자체를 확장하는 메타 모듈입니다.
+
+- **코드:** `bmb`
+- **npm:** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
+- **GitHub:** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
+
+**제공:**
+
+- 에이전트 빌더 - 커스텀 전문성과 도구 접근 권한이 있는 전문 AI 에이전트 생성
+- 워크플로 빌더 - 단계와 결정 지점이 있는 구조화된 프로세스 설계
+- 모듈 빌더 - 에이전트와 워크플로를 공유 및 게시 가능한 모듈로 패키징
+- YAML 설정과 npm 게시 지원이 있는 대화형 설정
+
+## 창의적 지능 제품군(CIS)
+
+초기 개발 단계의 구조화된 창의성, 아이디어 발상, 혁신을 위한 AI 기반 도구입니다. 이 제품군은 검증된 프레임워크를 사용해 브레인스토밍, 디자인 사고, 문제 해결을 진행하는 여러 에이전트를 제공합니다.
+
+- **코드:** `cis`
+- **npm:** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
+- **GitHub:** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
+
+**제공:**
+
+- 혁신 전략가, 디자인 사고 코치, 브레인스토밍 코치 에이전트
+- 체계적 사고와 수평적 사고를 위한 문제 해결자와 창의적 문제 해결자
+- 내러티브와 피치를 위한 스토리텔러와 발표 마스터
+- SCAMPER, 역브레인스토밍, 문제 재구성을 포함한 아이디어 발상 프레임워크
+
+## 게임 개발 스튜디오(BMGD)
+
+Unity, Unreal, Godot, 커스텀 엔진에 맞춘 구조화된 게임 개발 워크플로입니다. 빠른 흐름을 통한 신속한 프로토타이핑과 에픽 중심 스프린트를 통한 전체 규모 제작을 지원합니다.
+
+- **코드:** `gds`
+- **npm:** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
+- **GitHub:** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
+
+**제공:**
+
+- 게임 디자인 문서 생성 워크플로
+- 신속한 프로토타이핑을 위한 빠른 개발 모드
+- 캐릭터, 대화, 세계관 구축을 위한 내러티브 디자인 지원
+- 21개 이상 게임 유형과 엔진별 아키텍처 가이드 지원
+
+## 테스트 설계자(TEA)
+
+전문가 에이전트와 9개의 구조화된 워크플로를 통해 엔터프라이즈급 테스트 전략, 자동화 가이드, 릴리스 게이트 결정을 지원합니다. TEA는 위험 기반 우선순위와 요구사항 추적성으로 내장 QA 에이전트를 크게 넘어섭니다.
+
+- **코드:** `tea`
+- **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+- **GitHub:** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
+
+**제공:**
+
+- Murat 에이전트(마스터 테스트 아키텍트 겸 품질 조언자)
+- 테스트 설계, ATDD, 자동화, 테스트 리뷰, 추적성 워크플로
+- NFR 평가, CI 설정, 프레임워크 초기 구조 생성
+- 선택적 Playwright 유틸리티 및 MCP 통합을 포함한 P0-P3 우선순위
+
+## 커뮤니티 모듈
+
+커뮤니티 모듈과 모듈 마켓플레이스가 준비 중입니다. 업데이트는 [BMad GitHub 조직](https://github.com/bmad-code-org)을 확인하세요.

docs/ko-kr/reference/testing.md

@@ -0,0 +1,106 @@
+---
+title: 테스트 옵션
+description: 내장 QA 워크플로와 테스트 설계자(TEA) 모듈의 테스트 자동화 비교
+sidebar:
+  order: 6
+---
+
+BMad는 두 가지 테스트 경로를 제공합니다. 빠른 테스트 생성을 위한 내장 QA 워크플로와 엔터프라이즈급 테스트 전략을 위한 설치 가능한 테스트 설계자 모듈입니다.
+
+## 무엇을 사용해야 하나요?
+
+| 기준 | 내장 QA | TEA 모듈 |
+| --- | --- | --- |
+| **적합한 경우** | 중소형 프로젝트, 빠른 커버리지 | 대형 프로젝트, 규제 대상 또는 복잡한 도메인 |
+| **설정** | 설치할 것 없음 - BMM에 포함 | `npx bmad-method install`로 별도 설치 |
+| **접근 방식** | 테스트를 빠르게 생성하고 나중에 반복 개선 | 먼저 계획하고 추적 가능하게 생성 |
+| **테스트 유형** | API 및 E2E 테스트 | API, E2E, ATDD, NFR 등 |
+| **전략** | 정상 경로 + 중요한 엣지 케이스 | 위험 기반 우선순위(P0-P3) |
+| **워크플로 수** | 1(자동화) | 9개(설계, ATDD, 자동화, 리뷰, 추적 등) |
+
+:::tip[내장 QA로 시작]
+대부분의 프로젝트는 내장 QA 워크플로로 시작하면 됩니다. 나중에 테스트 전략, 품질 게이트, 요구사항 추적성이 필요해지면 TEA를 함께 설치하세요.
+:::
+
+## 내장 QA 워크플로
+
+내장 QA 워크플로(`bmad-qa-generate-e2e-tests`)는 BMM(애자일 제품군) 모듈의 일부이며 개발자 에이전트를 통해 사용할 수 있습니다. 설정이나 추가 설치 없이 프로젝트의 기존 테스트 프레임워크를 사용해 실행 가능한 테스트를 빠르게 생성합니다.
+
+**트리거:** `QA`(개발자 에이전트를 통해) 또는 `bmad-qa-generate-e2e-tests`
+
+### 하는 일
+
+QA 자동화 워크플로는 다섯 단계를 거칩니다.
+
+1. **테스트 프레임워크 감지** - `package.json`과 기존 테스트 파일을 스캔해 프레임워크(Jest, Vitest, Playwright, Cypress 또는 표준 러너)를 찾습니다. 없으면 프로젝트 스택을 분석해 제안합니다.
+2. **기능 식별** - 무엇을 테스트할지 묻거나 코드베이스에서 기능을 자동으로 발견합니다.
+3. **API 테스트 생성** - 상태 코드, 응답 구조, 정상 경로, 오류 사례 1-2개를 다룹니다.
+4. **E2E 테스트 생성** - 의미 기반 로케이터와 사용자에게 보이는 결과 검증으로 사용자 워크플로를 다룹니다.
+5. **실행 및 검증** - 생성된 테스트를 실행하고 실패를 즉시 수정합니다.
+
+워크플로는 프로젝트의 구현 산출물 폴더에 저장되는 테스트 요약을 생성합니다.
+
+### 테스트 패턴
+
+생성된 테스트는 "단순하고 유지보수하기 쉬운" 철학을 따릅니다.
+
+- **표준 프레임워크 API만 사용** - 외부 유틸리티나 커스텀 추상화 없음
+- UI 테스트에는 CSS 선택자 대신 **의미 기반 로케이터** 사용(역할, 레이블, 텍스트)
+- 순서 의존성이 없는 **독립 테스트**
+- 하드코딩된 대기(`wait`/`sleep`) 없음
+- 기능 문서처럼 읽히는 명확한 설명
+
+:::note[범위]
+QA 워크플로는 테스트만 생성합니다. 코드 리뷰와 스토리 검증에는 코드 리뷰 워크플로(`CR`)를 사용하세요.
+:::
+
+### 내장 QA 사용 시점
+
+- 새 기능 또는 기존 기능의 빠른 테스트 커버리지
+- 고급 설정 없는 초보자 친화적 테스트 자동화
+- 모든 개발자가 읽고 유지할 수 있는 표준 테스트 패턴
+- 포괄적인 테스트 전략이 불필요한 중소형 프로젝트
+
+## 테스트 설계자(TEA) 모듈
+
+TEA는 전문가 에이전트(Murat)와 엔터프라이즈급 테스트를 위한 9개 구조화된 워크플로를 제공하는 단독 실행 모듈입니다. 테스트 생성을 넘어 테스트 전략, 위험 기반 계획, 품질 게이트, 요구사항 추적성을 다룹니다.
+
+- **문서:** [TEA 모듈 문서](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+- **설치:** `npx bmad-method install` 실행 후 TEA 모듈 선택
+- **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+
+### TEA가 제공하는 것
+
+| 워크플로 | 목적 |
+| --- | --- |
+| 테스트 설계 | 요구사항에 연결된 포괄적 테스트 전략 생성 |
+| ATDD | 이해관계자 기준을 활용한 인수 테스트 주도 개발 |
+| 자동화 | 고급 패턴과 유틸리티로 테스트 생성 |
+| 테스트 리뷰 | 전략 대비 테스트 품질과 커버리지 검증 |
+| 추적성 | 감사 및 컴플라이언스를 위해 테스트를 요구사항에 매핑 |
+| NFR 평가 | 성능, 보안 등 비기능 요구사항 평가 |
+| CI 설정 | 지속적 통합 파이프라인에서 테스트 실행 구성 |
+| 프레임워크 초기 구조 생성 | 테스트 인프라와 프로젝트 구조 설정 |
+| 릴리스 게이트 | 데이터 기반 출시 여부 결정 |
+
+TEA는 P0-P3 위험 기반 우선순위와 선택적 Playwright 유틸리티 및 MCP 도구 통합도 지원합니다.
+
+### TEA 사용 시점
+
+- 요구사항 추적성 또는 컴플라이언스 문서화가 필요한 프로젝트
+- 많은 기능에 대해 위험 기반 테스트 우선순위가 필요한 팀
+- 릴리스 전 공식 품질 게이트가 있는 엔터프라이즈 환경
+- 테스트 작성 전에 테스트 전략이 계획되어야 하는 복잡한 도메인
+- 내장 QA의 단일 워크플로 접근 방식으로는 부족한 프로젝트
+
+## 테스트가 워크플로와 맞물리는 방식
+
+QA 자동화 워크플로는 BMad Method 워크플로 맵의 단계 4(구현)에 나타납니다. **전체 에픽이 완료된 후**, 즉 에픽의 모든 스토리가 구현되고 코드 리뷰된 뒤 실행하도록 설계되었습니다. 일반적인 순서는 다음과 같습니다.
+
+1. 에픽의 각 스토리마다 개발자(`DS`)로 구현하고 코드 리뷰(`CR`)로 검증합니다
+2. 에픽 완료 후 `QA`(개발자 에이전트를 통해) 또는 TEA의 자동화 워크플로로 테스트를 생성합니다
+3. `bmad-retrospective`를 실행해 배운 점을 기록합니다
+
+내장 QA 워크플로는 계획 문서(PRD, 아키텍처)를 로드하지 않고 소스 코드에서 직접 작업합니다. TEA 워크플로는 추적성을 위해 상위 계획 산출물과 통합할 수 있습니다.
+
+전체 프로세스에서 테스트가 어디에 맞물리는지는 [워크플로 맵](./workflow-map.md)을 참고하세요.

docs/ko-kr/reference/workflow-map.md

@@ -0,0 +1,102 @@
+---
+title: "워크플로 맵"
+description: BMad Method 워크플로 단계와 출력의 시각적 참조
+sidebar:
+  order: 1
+---
+
+BMad Method(BMM)는 BMad 생태계의 모듈이며 컨텍스트 엔지니어링과 계획 모범 사례를 따르는 데 초점을 둡니다. AI 에이전트는 명확하고 구조화된 컨텍스트가 있을 때 가장 잘 작동합니다. BMM 시스템은 4개의 구분된 단계에 걸쳐 그 컨텍스트를 점진적으로 만듭니다. 각 단계와 단계 안의 여러 선택 워크플로는 다음 단계에 필요한 정보를 담은 문서를 만들고, 에이전트는 항상 무엇을 왜 만들어야 하는지 알게 됩니다.
+
+그 근거와 개념은 업계 전반에서 성공적으로 사용되어 온 애자일 방법론에서 온 사고 프레임워크입니다.
+
+언제든 무엇을 해야 할지 확실하지 않다면 `bmad-help` 스킬이 흐름을 잡아 주고 다음 단계를 알려줍니다. 이 문서를 참조로 사용할 수도 있지만, 이미 BMad Method를 설치했다면 `bmad-help`가 더 대화형이고 훨씬 빠릅니다. 또한 BMad Method를 확장한 다른 모듈이나 함께 쓰는 보완 모듈을 사용한다면 `bmad-help`도 사용 가능한 항목을 모두 파악해 현재 상황에 가장 적절한 조언을 제공합니다.
+
+마지막으로 중요한 점: 아래 모든 워크플로는 스킬로 직접 실행하거나, 먼저 에이전트를 로드한 뒤 에이전트 메뉴 항목을 사용해 원하는 도구에서 실행할 수 있습니다.
+
+<iframe src="/workflow-map-diagram-ko-kr.html" title="BMad Method 워크플로 맵 다이어그램" width="100%" height="100%" style="border-radius: 8px; border: 1px solid #334155; min-height: 900px;"></iframe>
+
+<p style="font-size: 0.8rem; text-align: right; margin-top: -0.5rem; margin-bottom: 1rem;">
+  <a href="/workflow-map-diagram-ko-kr.html" target="_blank" rel="noopener noreferrer">다이어그램 새 탭에서 열기 ↗</a>
+</p>
+
+## 단계 1: 분석(선택)
+
+계획을 확정하기 전에 문제 영역을 탐색하고 아이디어를 검증합니다. [**각 도구가 무엇을 하고 언제 쓰는지 알아보기**](../explanation/analysis-phase.md).
+
+| 워크플로 | 목적 | 산출물 |
+| --- | --- | --- |
+| `bmad-brainstorming` | 브레인스토밍 코치의 안내를 받아 프로젝트 아이디어를 발산합니다 | `brainstorming-report.md` |
+| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | 시장, 기술, 도메인 가정을 검증합니다 | 연구 발견 사항 |
+| `bmad-product-brief` | 전략적 비전을 포착합니다. 개념이 명확할 때 가장 좋습니다 | `product-brief.md` |
+| `bmad-prfaq` | 워킹 백워드 방식으로 제품 개념을 스트레스 테스트하고 다듬습니다 | `prfaq-{project}.md` |
+
+## 단계 2: 계획
+
+무엇을 누구를 위해 만들지 정의합니다.
+
+| 워크플로 | 목적 | 산출물 |
+| --- | --- | --- |
+| `bmad-prd` | PRD를 생성, 업데이트, 검증합니다. 안내형 발견 과정과 세 가지 의도를 하나의 스킬에 담았습니다 | 생성/업데이트: `prd.md`, `addendum.md`, `decision-log.md`; 검증: `validation-report.html` + `.md` |
+| `bmad-create-ux-design` | UX가 중요할 때 사용자 경험을 설계합니다 | `ux-spec.md` |
+
+:::tip[하나의 스킬 안에 세 의도]
+`bmad-prd`는 전체 PRD 수명주기를 처리합니다. 호출할 때 의도를 말하거나 스킬이 물어보게 하세요.
+
+- **생성** - 안내형 발견 과정을 통해 처음부터 새 PRD를 만듭니다. `prd.md`, `addendum.md`, `decision-log.md`를 생성합니다
+- **업데이트** - 기존 PRD와 변경 신호를 조정하고, 변경을 적용하기 전에 충돌을 식별합니다
+- **검증** - 설정 가능한 체크리스트로 PRD를 비판적으로 검토하고 구조화된 HTML 발견 사항 보고서를 생성합니다
+:::
+
+:::tip[상위 입력: `bmad-product-brief`]
+`bmad-product-brief`(단계 1)는 `bmad-prd`가 발견 과정에서 입력으로 사용할 수 있는 `product-brief.md`를 생성합니다. 재설명을 줄이고 두 문서를 서로 맞춰 유지합니다. 두 스킬이 서로 필수는 아닙니다. 무엇을 만들지 이미 안다면 `bmad-prd`로 바로 시작하세요.
+:::
+
+## 단계 3: 솔루션 설계
+
+어떻게 만들지 결정하고 작업을 스토리로 나눕니다.
+
+| 워크플로 | 목적 | 산출물 |
+| --- | --- | --- |
+| `bmad-create-architecture` | 기술적 결정을 명시적으로 만듭니다 | ADR이 있는 `architecture.md` |
+| `bmad-create-epics-and-stories` | 요구사항을 구현 가능한 작업으로 나눕니다 | 스토리가 있는 에픽 파일 |
+| `bmad-check-implementation-readiness` | 구현 전 관문 점검 | 통과/우려/실패 결정 |
+
+## 단계 4: 구현
+
+스토리 하나씩 구현합니다. 전체 4단계 자동화는 곧 제공됩니다.
+
+| 워크플로 | 목적 | 산출물 |
+| --- | --- | --- |
+| `bmad-sprint-planning` | 추적 상태 초기화(프로젝트당 한 번, 개발 주기 순서화) | `sprint-status.yaml` |
+| `bmad-create-story` | 구현을 위한 다음 스토리 준비 | `story-[slug].md` |
+| `bmad-dev-story` | 스토리 구현 | 작동하는 코드 + 테스트 |
+| `bmad-code-review` | 구현 품질 검증 | 승인 또는 변경 요청 |
+| `bmad-correct-course` | 스프린트 중 의미 있는 변경 처리 | 업데이트된 계획 또는 경로 재조정 |
+| `bmad-sprint-status` | 스프린트 진행 상황과 스토리 상태 추적 | 스프린트 상태 업데이트 |
+| `bmad-retrospective` | 에픽 완료 후 회고 | 배운 점 |
+| `bmad-investigate` | 입력에 맞게 보정된 증거 등급 발견 사항 기반 포렌식 사례 조사 | `{slug}-investigation.md` |
+
+## 빠른 흐름(병렬 트랙)
+
+작고 잘 이해된 작업에서는 단계 1-3을 건너뜁니다.
+
+| 워크플로 | 목적 | 산출물 |
+| --- | --- | --- |
+| `bmad-quick-dev` | 통합 빠른 흐름 - 의도 정리, 계획, 구현, 리뷰, 발표 | `spec-*.md` + 코드 |
+
+## 컨텍스트 관리
+
+각 문서는 다음 단계의 컨텍스트가 됩니다. PRD는 아키텍트에게 어떤 제약이 중요한지 알려줍니다. 아키텍처는 개발 에이전트에게 어떤 패턴을 따라야 하는지 알려줍니다. 스토리 파일은 구현을 위한 집중적이고 완결된 컨텍스트를 제공합니다. 이 구조가 없으면 에이전트는 일관되지 않은 결정을 내립니다.
+
+### 프로젝트 컨텍스트
+
+:::tip[권장]
+AI 에이전트가 프로젝트의 규칙과 선호 사항을 따르도록 `project-context.md`를 만드세요. 이 파일은 프로젝트의 헌장처럼 작동해 모든 워크플로에서 구현 결정을 안내합니다. 이 선택 파일은 아키텍처 작성이 끝날 때 생성할 수 있고, 기존 프로젝트에서도 현재 관례와 맞춰야 할 중요한 내용을 포착하기 위해 생성할 수 있습니다.
+:::
+
+**만드는 방법:**
+
+- **수동으로** - `_bmad-output/project-context.md`를 만들고 기술 스택과 구현 규칙을 작성합니다
+- **생성하기** - `bmad-generate-project-context`를 실행해 아키텍처 또는 코드베이스에서 자동 생성합니다
+
+[**project-context.md 더 알아보기**](../explanation/project-context.md)

docs/ko-kr/roadmap.mdx

@@ -0,0 +1,136 @@
+---
+title: 로드맵
+description: BMad의 다음 단계 - 기능, 개선 사항, 커뮤니티 기여
+---
+
+# BMad Method: 공개 로드맵
+
+BMad Method, BMad Method 모듈(BMM), BMad 빌더(BMB)는 계속 발전하고 있습니다. 현재 진행 중인 작업과 앞으로 예정된 항목을 소개합니다.
+
+<div class="roadmap-container">
+
+  <h2 class="roadmap-section-title">진행 중</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🧩</span>
+      <h4>범용 스킬 아키텍처</h4>
+      <p>스킬 하나를 어떤 플랫폼에서든 사용할 수 있게 합니다. 한 번 작성하고 어디서나 실행합니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏗️</span>
+      <h4>BMad 빌더 v1</h4>
+      <p>평가, 팀 구성, 점진적 기능 저하를 내장한 프로덕션 준비 AI 에이전트와 워크플로를 만듭니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🧠</span>
+      <h4>프로젝트 컨텍스트 시스템</h4>
+      <p>AI가 실제로 프로젝트를 이해합니다. 코드베이스와 함께 진화하는, 프레임워크를 이해하는 컨텍스트입니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">📦</span>
+      <h4>중앙화된 스킬</h4>
+      <p>한 번 설치하고 어디서나 사용합니다. 파일이 어지럽게 늘어나지 않게 프로젝트 간 스킬을 공유합니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🔄</span>
+      <h4>적응형 스킬</h4>
+      <p>도구를 이해하는 스킬입니다. Claude, Codex, Kimi, OpenCode 등 다양한 도구에 맞춘 변형을 제공합니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">📝</span>
+      <h4>BMad 팀 전문가 블로그</h4>
+      <p>팀이 전하는 가이드, 글, 인사이트입니다. 곧 공개됩니다.</p>
+    </div>
+  </div>
+
+  <h2 class="roadmap-section-title">시작 단계</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏪</span>
+      <h4>스킬 마켓플레이스</h4>
+      <p>커뮤니티가 만든 스킬을 발견하고 설치하고 업데이트합니다. curl 명령 하나로 기능을 확장합니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎨</span>
+      <h4>워크플로 커스터마이징</h4>
+      <p>내 방식에 맞게 조정합니다. Jira, Linear, 커스텀 출력까지, 당신의 워크플로와 규칙에 맞춥니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🚀</span>
+      <h4>1-3단계 최적화</h4>
+      <p>서브 에이전트 컨텍스트 수집으로 빠른 계획을 지원합니다. YOLO 모드의 속도와 안내형 워크플로의 품질을 함께 가져갑니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🌐</span>
+      <h4>엔터프라이즈 준비</h4>
+      <p>SSO, 감사 로그, 팀 워크스페이스. 기업 도입에 필요한 기반 기능입니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">💎</span>
+      <h4>커뮤니티 모듈 확대</h4>
+      <p>엔터테인먼트, 보안, 테라피, 롤플레이 등 훨씬 더 많은 영역으로 BMad Method 플랫폼을 확장합니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">⚡</span>
+      <h4>개발 루프 자동화</h4>
+      <p>개발을 위한 선택형 자동 조종 기능입니다. 품질을 높게 유지하면서 AI가 흐름을 처리하게 합니다.</p>
+    </div>
+  </div>
+
+  <h2 class="roadmap-section-title">커뮤니티와 팀</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎙️</span>
+      <h4>BMad Method 팟캐스트</h4>
+      <p>AI 네이티브 개발에 관한 대화입니다. 2026년 3월 1일 공개 예정입니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎓</span>
+      <h4>BMad Method 마스터 클래스</h4>
+      <p>사용자에서 전문가로 나아갑니다. 모든 단계와 워크플로를 깊게 다룹니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏗️</span>
+      <h4>BMad 빌더 마스터 클래스</h4>
+      <p>직접 에이전트를 만듭니다. 단순한 사용을 넘어 직접 만들 준비가 되었을 때 필요한 고급 기법입니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">⚡</span>
+      <h4>BMad Prototype First</h4>
+      <p>아이디어에서 작동하는 프로토타입까지 한 세션에 이어 갑니다. 구상하던 앱을 빠르게 실체로 만듭니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🌴</span>
+      <h4>BMad BALM!</h4>
+      <p>AI 네이티브 시대의 생활 관리입니다. 작업, 습관, 목표까지 아우르는 AI 코파일럿입니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🖥️</span>
+      <h4>공식 UI</h4>
+      <p>전체 BMad 생태계를 위한 세련된 인터페이스입니다. CLI의 힘과 GUI의 편의성을 함께 제공합니다.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🔒</span>
+      <h4>BMad in a Box</h4>
+      <p>셀프 호스팅, 망 분리, 엔터프라이즈급 배포를 지원합니다. 당신의 AI 어시스턴트를 당신의 인프라에서 직접 통제합니다.</p>
+    </div>
+  </div>
+
+  <div style="text-align: center; margin-top: 3rem; padding: 2rem; background: var(--color-bg-card); border-radius: 12px; border: 1px solid var(--color-border);">
+    <h3 style="margin: 0 0 1rem;">기여하고 싶나요?</h3>
+    <p style="color: var(--slate-color-400); margin: 0;">
+      이것은 계획된 항목의 일부일 뿐입니다. BMad 오픈 소스 팀은 기여자를 환영합니다!{" "}<br />
+      <a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">GitHub에서 함께</a> AI 기반 개발의 미래를 만들어 주세요.
+    </p>
+    <p style="color: var(--slate-color-400); margin: 1.5rem 0 0;">
+      우리가 만드는 것을 좋아하시나요? 일회성 및 월간{" "}<a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">후원</a> 모두 감사히 받습니다.
+    </p>
+    <p style="color: var(--slate-color-400); margin: 1rem 0 0;">
+      기업 후원, 파트너십 문의, 발표 요청, 교육, 미디어 문의는{" "}
+      <a href="mailto:contact@bmadcode.com" style="color: var(--color-in-progress);">contact@bmadcode.com</a>으로 연락하세요.
+    </p>
+  </div>
+</div>

docs/ko-kr/tutorials/getting-started.md

@@ -0,0 +1,289 @@
+---
+title: "시작하기"
+description: BMad를 설치하고 첫 프로젝트를 만듭니다
+---
+
+계획, 아키텍처, 구현을 안내하는 전문 에이전트 기반 AI 워크플로로 소프트웨어를 더 빠르게 만드세요.
+
+## 배울 내용
+
+- 새 프로젝트에 BMad Method를 설치하고 초기화합니다
+- 다음에 무엇을 해야 할지 아는 지능형 안내자 **BMad 도움말**을 사용합니다
+- 프로젝트 규모에 맞는 계획 트랙을 선택합니다
+- 요구사항부터 작동하는 코드까지 단계별로 진행합니다
+- 에이전트와 워크플로를 효과적으로 사용합니다
+
+:::note[필수 조건]
+- **Node.js 20+** - 설치 프로그램에 필요합니다
+- **Git** - 버전 관리를 위해 권장합니다
+- **AI 기반 IDE** - Claude Code, Cursor 또는 유사 도구
+- **프로젝트 아이디어** - 학습용이라면 단순한 아이디어도 충분합니다
+:::
+
+:::tip[가장 쉬운 경로]
+**설치** → `npx bmad-method install`
+**질문** → `bmad-help 먼저 무엇을 해야 하나요?`
+**빌드** → BMad 도움말의 안내에 따라 워크플로를 진행하세요
+:::
+
+## BMad 도움말 만나기: 지능형 안내자
+
+**BMad 도움말은 BMad를 시작하는 가장 빠른 방법입니다.** 워크플로나 단계를 외울 필요가 없습니다. 그냥 물어보면 BMad 도움말이 다음을 수행합니다.
+
+- **프로젝트를 검사**해 이미 완료된 작업을 확인합니다
+- 설치된 모듈을 기준으로 **선택지를 보여줍니다**
+- 첫 필수 작업을 포함해 **다음 단계를 추천합니다**
+- "SaaS 아이디어가 있는데 어디서 시작하지?" 같은 **질문에 답합니다**
+
+### BMad 도움말 사용 방법
+
+AI IDE에서 스킬을 호출해 실행합니다.
+
+```
+bmad-help
+```
+
+컨텍스트가 있는 안내를 받으려면 질문과 함께 사용할 수도 있습니다.
+
+```
+bmad-help SaaS 제품 아이디어가 있고 원하는 기능도 모두 알고 있습니다. 어디서 시작하면 좋나요?
+```
+
+BMad 도움말은 다음을 답합니다.
+
+- 현재 상황에 권장되는 선택지
+- 첫 번째 필수 작업
+- 나머지 과정의 모습
+
+### 워크플로 끝에서도 동작합니다
+
+BMad 도움말은 질문에 답하기만 하지 않습니다. **모든 워크플로 끝에서 자동으로 실행되어** 다음에 무엇을 해야 할지 알려줍니다. 추측하거나 문서를 뒤질 필요 없이 다음 필수 워크플로에 대한 명확한 안내를 받습니다.
+
+:::tip[여기서 시작하세요]
+BMad를 설치한 뒤 바로 `bmad-help` 스킬을 호출하세요. 설치된 모듈을 감지하고 프로젝트에 맞는 시작점으로 안내합니다.
+:::
+
+## BMad 이해하기
+
+BMad는 전문 AI 에이전트가 있는 안내형 워크플로를 통해 소프트웨어를 만들도록 돕습니다. 과정은 네 단계로 진행됩니다.
+
+| 단계 | 이름 | 일어나는 일 |
+| --- | --- | --- |
+| 1 | 분석 | 브레인스토밍, 리서치, 제품 개요 또는 PRFAQ *(선택)* |
+| 2 | 계획 | 요구사항 작성(PRD 또는 사양) |
+| 3 | 솔루션 설계 | 아키텍처 설계 *(BMad Method/엔터프라이즈 전용)* |
+| 4 | 구현 | 에픽별, 스토리별 구현 |
+
+단계, 워크플로, 컨텍스트 관리를 살펴보려면 **[워크플로 맵 열기](../reference/workflow-map.md)**를 확인하세요.
+
+프로젝트 복잡도에 따라 BMad는 세 가지 계획 트랙을 제공합니다.
+
+| 트랙 | 적합한 경우 | 생성되는 문서 |
+| --- | --- | --- |
+| **빠른 흐름** | 버그 수정, 단순 기능, 명확한 범위(1-15개 스토리) | 기술 사양만 |
+| **BMad Method** | 제품, 플랫폼, 복잡한 기능(10-50개 이상 스토리) | PRD + 아키텍처 + UX |
+| **엔터프라이즈** | 컴플라이언스, 멀티테넌트 시스템(30개 이상 스토리) | PRD + 아키텍처 + 보안 + DevOps |
+
+:::note
+스토리 수는 기준이 아니라 안내입니다. 스토리 수 계산보다 계획 필요성에 따라 트랙을 선택하세요.
+:::
+
+## 설치
+
+프로젝트 디렉터리에서 터미널을 열고 실행합니다.
+
+```bash
+npx bmad-method install
+```
+
+기본 릴리스 채널 대신 최신 사전 릴리스 빌드를 원한다면 `npx bmad-method@next install`을 사용하세요.
+
+모듈 선택 프롬프트가 나오면 **BMad Method**를 선택합니다.
+
+설치 프로그램은 두 폴더를 만듭니다.
+
+- `_bmad/` - 에이전트, 워크플로, 작업, 설정
+- `_bmad-output/` - 지금은 비어 있지만 산출물이 저장될 위치입니다
+
+:::tip[다음 단계]
+프로젝트 폴더에서 AI IDE를 열고 다음을 실행하세요.
+
+```
+bmad-help
+```
+
+BMad 도움말이 완료된 작업을 감지하고 정확한 다음 단계를 추천합니다. "내 선택지는 무엇인가요?" 또는 "SaaS 아이디어가 있는데 어디서 시작해야 하나요?"처럼 물어볼 수도 있습니다.
+:::
+
+:::note[에이전트를 로드하고 워크플로를 실행하는 방법]
+각 워크플로에는 IDE에서 이름으로 호출하는 **스킬**이 있습니다(예: `bmad-prd`). AI 도구가 `bmad-*` 이름을 인식하고 실행하므로 에이전트를 따로 로드할 필요가 없습니다. 일반 대화를 위해 에이전트 스킬을 직접 호출할 수도 있습니다(예: PM 에이전트용 `bmad-agent-pm`).
+:::
+
+:::caution[새 채팅]
+각 워크플로는 항상 새 채팅에서 시작하세요. 이렇게 하면 컨텍스트 제한으로 인한 문제를 예방할 수 있습니다.
+:::
+
+## 1단계: 계획 만들기
+
+1-3단계를 진행합니다. **각 워크플로는 새 채팅에서 실행하세요.**
+
+:::tip[프로젝트 컨텍스트(선택)]
+시작하기 전에 `project-context.md`를 만들어 기술 선호도와 구현 규칙을 문서화하는 것을 고려하세요. 이렇게 하면 모든 AI 에이전트가 프로젝트 전반에서 당신의 규칙을 따릅니다.
+
+`_bmad-output/project-context.md`에 직접 만들거나 아키텍처 이후 `bmad-generate-project-context`로 생성할 수 있습니다. [자세히 알아보기](../explanation/project-context.md).
+:::
+
+### 1단계: 분석(선택)
+
+이 단계의 모든 워크플로는 선택 사항입니다. [**무엇을 써야 할지 모르겠나요?**](../explanation/analysis-phase.md)
+
+- **브레인스토밍**(`bmad-brainstorming`) - 안내형 아이디어 발산
+- **리서치**(`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) - 시장, 도메인, 기술 리서치
+- **제품 개요**(`bmad-product-brief`) - 개념이 명확할 때 권장되는 기초 문서
+- **PRFAQ**(`bmad-prfaq`) - 제품 개념을 압박하고 다듬는 워킹 백워드 챌린지
+
+### 2단계: 계획(필수)
+
+**BMad Method 및 엔터프라이즈 트랙:**
+
+1. 새 채팅에서 `bmad-prd`를 실행합니다. 의도(생성, 업데이트, 검증)를 직접 말하거나 스킬이 묻게 둡니다
+2. 출력: `prd.md`, `addendum.md`, `decision-log.md`
+
+:::note[`bmad-prd` 의도]
+- **생성** - 처음부터 코칭형 발견 과정을 진행합니다. 스킬이 워크스페이스 폴더 이름을 정하고 만족할 만한 PRD까지 안내합니다
+- **업데이트** - 기존 PRD와 변경 신호를 지정합니다. 변경을 적용하기 전에 충돌을 드러냅니다
+- **검증** - 완료된 PRD를 체크리스트로 비평하고 HTML 발견 사항 보고서를 생성합니다
+:::
+
+**빠른 흐름 트랙:**
+
+- `bmad-quick-dev`를 실행합니다. 계획과 구현을 하나의 워크플로에서 처리하므로 구현 단계로 바로 넘어갑니다
+
+:::note[UX 설계(선택)]
+프로젝트에 사용자 인터페이스가 있다면 PRD를 만든 뒤 **UX 디자이너 에이전트**(`bmad-agent-ux-designer`)를 호출하고 UX 설계 워크플로(`bmad-create-ux-design`)를 실행하세요.
+:::
+
+### 3단계: 솔루션 설계(BMad Method/엔터프라이즈)
+
+**아키텍처 만들기**
+
+1. 새 채팅에서 **아키텍트 에이전트**(`bmad-agent-architect`)를 호출합니다
+2. `bmad-create-architecture`(`bmad-create-architecture`)를 실행합니다
+3. 출력: 기술 결정이 담긴 아키텍처 문서
+
+**에픽과 스토리 만들기**
+
+:::tip[V6 개선]
+이제 에픽과 스토리는 아키텍처 *이후* 생성됩니다. 데이터베이스, API 패턴, 기술 스택 같은 아키텍처 결정이 작업 분해 방식에 직접 영향을 주므로 스토리 품질이 좋아집니다.
+:::
+
+1. 새 채팅에서 **PM 에이전트**(`bmad-agent-pm`)를 호출합니다
+2. `bmad-create-epics-and-stories`(`bmad-create-epics-and-stories`)를 실행합니다
+3. 워크플로는 PRD와 아키텍처를 모두 사용해 기술적 맥락이 반영된 스토리를 만듭니다
+
+**구현 준비도 점검** *(강력 권장)*
+
+1. 새 채팅에서 **아키텍트 에이전트**(`bmad-agent-architect`)를 호출합니다
+2. `bmad-check-implementation-readiness`(`bmad-check-implementation-readiness`)를 실행합니다
+3. 모든 계획 문서 간 응집성을 검증합니다
+
+## 2단계: 프로젝트 만들기
+
+계획이 완료되면 구현으로 이동합니다. **각 워크플로는 새 채팅에서 실행해야 합니다.**
+
+### 스프린트 계획 초기화
+
+**개발자 에이전트**(`bmad-agent-dev`)를 호출하고 `bmad-sprint-planning`(`bmad-sprint-planning`)을 실행합니다. 모든 에픽과 스토리를 추적하는 `sprint-status.yaml`이 생성됩니다.
+
+### 빌드 사이클
+
+각 스토리마다 새 채팅으로 이 사이클을 반복합니다.
+
+| 단계 | 에이전트 | 워크플로 | 명령 | 목적 |
+| --- | --- | --- | --- | --- |
+| 1 | DEV | `bmad-create-story` | `bmad-create-story` | 에픽에서 스토리 파일 생성 |
+| 2 | DEV | `bmad-dev-story` | `bmad-dev-story` | 스토리 구현 |
+| 3 | DEV | `bmad-code-review` | `bmad-code-review` | 품질 검증 *(권장)* |
+
+에픽의 모든 스토리를 완료한 뒤 **개발자 에이전트**(`bmad-agent-dev`)를 호출하고 `bmad-retrospective`(`bmad-retrospective`)를 실행합니다.
+
+## 달성한 것
+
+BMad로 빌드하는 기초를 배웠습니다.
+
+- BMad를 설치하고 IDE에 맞게 설정했습니다
+- 선택한 계획 트랙으로 프로젝트를 초기화했습니다
+- 계획 문서(PRD, 아키텍처, 에픽과 스토리)를 만들었습니다
+- 구현을 위한 빌드 사이클을 이해했습니다
+
+이제 프로젝트에는 다음이 있습니다.
+
+```text
+your-project/
+├── _bmad/                                   # BMad 설정
+├── _bmad-output/
+│   ├── planning-artifacts/
+│   │   ├── PRD.md                           # 요구사항 문서
+│   │   ├── architecture.md                  # 기술 결정
+│   │   └── epics/                           # 에픽과 스토리 파일
+│   ├── implementation-artifacts/
+│   │   └── sprint-status.yaml               # 스프린트 추적
+│   └── project-context.md                   # 구현 규칙(선택)
+└── ...
+```
+
+## 빠른 참조
+
+| 워크플로 | 명령 | 에이전트 | 목적 |
+| --- | --- | --- | --- |
+| **`bmad-help`** | `bmad-help` | 무관 | **무엇이든 물어볼 수 있는 지능형 안내자** |
+| `bmad-prd` | `bmad-prd` | 무관 | PRD 생성, 업데이트 또는 검증 |
+| `bmad-create-architecture` | `bmad-create-architecture` | 아키텍트 | 아키텍처 문서 생성 |
+| `bmad-generate-project-context` | `bmad-generate-project-context` | 분석가 | 프로젝트 컨텍스트 파일 생성 |
+| `bmad-create-epics-and-stories` | `bmad-create-epics-and-stories` | PM | PRD를 에픽으로 분해 |
+| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | 아키텍트 | 계획 응집성 검증 |
+| `bmad-sprint-planning` | `bmad-sprint-planning` | DEV | 스프린트 추적 초기화 |
+| `bmad-create-story` | `bmad-create-story` | DEV | 스토리 파일 생성 |
+| `bmad-dev-story` | `bmad-dev-story` | DEV | 스토리 구현 |
+| `bmad-code-review` | `bmad-code-review` | DEV | 구현된 코드 리뷰 |
+
+## 자주 묻는 질문
+
+**항상 아키텍처가 필요한가요?**
+오직 BMad Method와 엔터프라이즈 트랙에서만 필요합니다. 빠른 흐름은 사양에서 구현으로 바로 넘어갑니다.
+
+**나중에 계획을 바꿀 수 있나요?**
+네. `bmad-correct-course` 워크플로가 구현 중 범위 변경을 처리합니다.
+
+**먼저 브레인스토밍하고 싶다면요?**
+PRD를 시작하기 전에 분석가 에이전트(`bmad-agent-analyst`)를 호출하고 `bmad-brainstorming`(`bmad-brainstorming`)을 실행하세요.
+
+**엄격한 순서를 따라야 하나요?**
+반드시 그렇지는 않습니다. 흐름에 익숙해지면 위의 빠른 참조를 사용해 워크플로를 직접 실행할 수 있습니다.
+
+## 도움 받기
+
+:::tip[첫 번째 목적지: BMad 도움말]
+**언제든 `bmad-help`를 호출하세요.** 막혔을 때 가장 빠른 방법입니다. 무엇이든 물어보세요.
+
+- "설치 후 무엇을 해야 하나요?"
+- "워크플로 X에서 막혔어요"
+- "Y에 대한 선택지는 무엇인가요?"
+- "지금까지 완료된 것을 보여 주세요"
+
+BMad 도움말은 프로젝트를 검사하고 완료한 작업을 감지한 뒤 다음에 무엇을 해야 할지 정확히 알려줍니다.
+:::
+
+- **워크플로 중** - 에이전트가 질문과 설명으로 안내합니다
+- **커뮤니티** - [Discord](https://discord.gg/gk8jAdXWmj)(#bmad-method-help, #report-bugs-and-issues)
+
+## 핵심 요약
+
+:::tip[이것만 기억하세요]
+- **`bmad-help`로 시작하세요** - 프로젝트와 선택지를 아는 지능형 안내자입니다
+- **항상 새 채팅을 사용하세요** - 각 워크플로마다 새 채팅을 시작합니다
+- **트랙이 중요합니다** - 빠른 흐름은 `bmad-quick-dev`를 사용하고, BMad Method/엔터프라이즈는 PRD와 아키텍처가 필요합니다
+- **BMad 도움말은 자동으로 실행됩니다** - 모든 워크플로는 다음 단계 안내로 끝납니다
+:::
+
+시작할 준비가 되었나요? BMad를 설치하고 `bmad-help`를 호출한 뒤 안내에 따라 첫 흐름을 시작하세요.

src/bmm-skills/3-solutioning/bmad-create-epics-and-stories/steps/step-01-validate-prerequisites.md

@@ -48,7 +48,7 @@ Verify required documents exist and are complete:
 
 1. **PRD.md** - Contains requirements (FRs and NFRs) and product scope
 2. **Architecture.md** - Contains technical decisions, API contracts, data models
-3. **UX Design.md** (if UI exists) - Contains interaction patterns, mockups, user flows
+3. **UX design contract** (if UI exists) - Contains visual identity, interaction patterns, mockups, and user flows
 
 ### 2. Document Discovery and Validation
 
@@ -66,8 +66,16 @@ Search for required documents using these patterns (sharded means a large docume
 
 **UX Design Document Search (Optional):**
 
-1. `{planning_artifacts}/*ux*.md` (whole document)
-2. `{planning_artifacts}/*ux*/index.md` (sharded version)
+1. `{planning_artifacts}/ux-designs/ux-*/DESIGN.md` and `{planning_artifacts}/ux-designs/ux-*/EXPERIENCE.md` (bmad-ux spine pair)
+2. `{planning_artifacts}/*ux*.md` (legacy whole document)
+3. `{planning_artifacts}/*ux*/index.md` (legacy sharded version)
+
+For each matching bmad-ux run folder, treat `DESIGN.md` and `EXPERIENCE.md` as one UX design contract:
+
+- Confirm and load both files together. `DESIGN.md` owns visual identity and design tokens; `EXPERIENCE.md` owns information architecture, behavior, states, interactions, accessibility, and journeys.
+- Add both files to the `inputDocuments: []` frontmatter array.
+- If only one spine exists, report the incomplete pair and ask whether the user wants to include the partial UX handoff.
+- If multiple run folders match, show each run folder with the spine frontmatter `status` and `updated` values when available, then ask the user which UX design contract to include.
 
 Before proceeding, Ask the user if there are any other documents to include for analysis, and if anything found should be excluded. Wait for user confirmation. Once confirmed, create the {planning_artifacts}/epics.md from the ../templates/epics-template.md and in the front matter list the files in the array of `inputDocuments: []`.
 
@@ -136,7 +144,7 @@ Review the Architecture document for technical requirements that impact epic and
 
 **IMPORTANT**: The UX Design Specification is a first-class input document, not supplementary material. Requirements from the UX spec must be extracted with the same rigor as PRD functional requirements.
 
-Read the FULL UX Design document and extract ALL actionable work items:
+Read the FULL UX design contract and extract ALL actionable work items. For a bmad-ux spine pair, read both `DESIGN.md` and `EXPERIENCE.md`:
 
 **Look for:**
 

src/bmm-skills/4-implementation/bmad-retrospective/SKILL.md

@@ -225,12 +225,12 @@ Amelia (Developer): "Perfect. Epic {{epic_number}} is complete and ready for ret
 
 </step>
 
-<step n="0.5" goal="Discover and load project documents">
+<step n="2" goal="Discover and load project documents">
   <action>Load input files according to the Input Files table above. For SELECTIVE_LOAD inputs, load only the epic matching {{epic_number}}. For FULL_LOAD inputs, load the complete document. For INDEX_GUIDED inputs, check the index first and load relevant sections. After discovery, these content variables are available: {epics_content} (selective load for this epic), {architecture_content}, {prd_content}, {document_project_content}</action>
   <note>After discovery, these content variables are available: {epics_content} (selective load for this epic), {architecture_content}, {prd_content}, {document_project_content}</note>
 </step>
 
-<step n="2" goal="Deep Story Analysis - Extract Lessons from Implementation">
+<step n="3" goal="Deep Story Analysis - Extract Lessons from Implementation">
 
 <output>
 Amelia (Developer): "Before we start the team discussion, let me review all the story records to surface key themes. This'll help us have a richer conversation."
@@ -324,7 +324,7 @@ Amelia (Developer): "We'll get to all of it. But first, let me load the previous
 
 </step>
 
-<step n="3" goal="Load and Integrate Previous Epic Retrospective">
+<step n="4" goal="Load and Integrate Previous Epic Retrospective">
 
 <action>Calculate previous epic number: {{prev_epic_num}} = {{epic_number}} - 1</action>
 
@@ -420,7 +420,7 @@ Charlie (Senior Dev): "First epic, first retro. Let's make it count."
 
 </step>
 
-<step n="4" goal="Preview Next Epic with Change Detection">
+<step n="5" goal="Preview Next Epic with Change Detection">
 
 <action>Calculate next epic number: {{next_epic_num}} = {{epic_number}} + 1</action>
 
@@ -509,7 +509,7 @@ Amelia (Developer): "No problem. We'll still do a thorough retro on Epic {{epic_
 
 </step>
 
-<step n="5" goal="Initialize Retrospective with Rich Context">
+<step n="6" goal="Initialize Retrospective with Rich Context">
 
 <action>Load agent roster from {agent_roster}</action>
 <action>Identify which agents participated in Epic {{epic_number}} based on story records</action>
@@ -599,7 +599,7 @@ Amelia (Developer): "Exactly. {user_name}, any questions before we dive in?"
 
 </step>
 
-<step n="6" goal="Epic Review Discussion - What Went Well, What Didn't">
+<step n="7" goal="Epic Review Discussion - What Went Well, What Didn't">
 
 <output>
 Amelia (Developer): "Let's start with the good stuff. What went well in Epic {{epic_number}}?"
@@ -673,7 +673,7 @@ Alice (Product Owner): "I appreciate that. I could've been more proactive about
 Amelia (Developer): "This is good. We're identifying systemic improvements, not assigning blame."
 </output>
 
-<action>Continue the discussion, weaving in patterns discovered from the deep story analysis (Step 2)</action>
+<action>Continue the discussion, weaving in patterns discovered from the deep story analysis (Step 3)</action>
 
 <output>
 Amelia (Developer): "Speaking of patterns, I noticed something when reviewing all the story records..."
@@ -744,13 +744,13 @@ Amelia (Developer): "Does that capture it? Anyone have something important we mi
 
 </step>
 
-<step n="7" goal="Next Epic Preparation Discussion - Interactive and Collaborative">
+<step n="8" goal="Next Epic Preparation Discussion - Interactive and Collaborative">
 
 <check if="{{next_epic_exists}} == false">
   <output>
 Amelia (Developer): "Normally we'd discuss preparing for the next epic, but since Epic {{next_epic_num}} isn't defined yet, let's skip to action items."
   </output>
-  <action>Skip to Step 8</action>
+  <action>Skip to Step 9</action>
 </check>
 
 <output>
@@ -868,7 +868,7 @@ Amelia (Developer): "{user_name}, does this preparation plan work for you?"
 
 </step>
 
-<step n="8" goal="Synthesize Action Items with Significant Change Detection">
+<step n="9" goal="Synthesize Action Items with Significant Change Detection">
 
 <output>
 Amelia (Developer): "Let's capture concrete action items from everything we've discussed."
@@ -1109,7 +1109,7 @@ Amelia (Developer): "Everyone clear on what they own?"
 
 </step>
 
-<step n="9" goal="Critical Readiness Exploration - Interactive Deep Dive">
+<step n="10" goal="Critical Readiness Exploration - Interactive Deep Dive">
 
 <output>
 Amelia (Developer): "Before we close, I want to do a final readiness check."
@@ -1292,7 +1292,7 @@ Charlie (Senior Dev): "Better to catch this now than three stories into the next
 
 </step>
 
-<step n="10" goal="Retrospective Closure with Celebration and Commitment">
+<step n="11" goal="Retrospective Closure with Celebration and Commitment">
 
 <output>
 Amelia (Developer): "We've covered a lot of ground today. Let me bring this retrospective to a close."
@@ -1368,7 +1368,7 @@ Amelia (Developer): "See you all when prep work is done. Meeting adjourned!"
 
 </step>
 
-<step n="11" goal="Save Retrospective and Update Sprint Status">
+<step n="12" goal="Save Retrospective and Update Sprint Status">
 
 <action>Ensure retrospectives folder exists: {implementation_artifacts}</action>
 <action>Create folder if it doesn't exist</action>
@@ -1425,7 +1425,7 @@ Retrospective document was saved successfully, but {sprint_status_file} may need
 
 </step>
 
-<step n="12" goal="Final Summary and Handoff">
+<step n="13" goal="Final Summary and Handoff">
 
 <output>
 **✅ Retrospective Complete, {user_name}!**

src/bmm-skills/4-implementation/bmad-retrospective/customize.toml

@@ -34,7 +34,7 @@ persistent_facts = [
   "file:{project-root}/**/project-context.md",
 ]
 
-# Scalar: executed when the workflow reaches Step 12 (Final Summary and Handoff),
+# Scalar: executed when the workflow reaches Step 13 (Final Summary and Handoff),
 # after the retrospective document is saved and sprint-status is updated. Override wins.
 # Leave empty for no custom post-completion behavior.
 

tools/validate-doc-links.js

@@ -288,8 +288,14 @@ function processFile(filePath) {
     if (anchor) {
       const targetContent = fs.readFileSync(targetFile, 'utf-8');
       const anchors = extractAnchors(targetContent);
+      let normalizedAnchor;
+      try {
+        normalizedAnchor = headingToAnchor(decodeURIComponent(anchor));
+      } catch {
+        normalizedAnchor = headingToAnchor(anchor);
+      }
 
-      if (!anchors.has(anchor)) {
+      if (!anchors.has(anchor) && !anchors.has(normalizedAnchor)) {
         issues.push({
           type: 'broken-anchor',
           linkText,

website/astro.config.mjs

@@ -94,53 +94,78 @@ export default defineConfig({
       sidebar: [
         {
           label: 'Welcome',
-          translations: { 'vi-VN': 'Chào mừng', 'zh-CN': '欢迎', 'fr-FR': 'Bienvenue', 'cs-CZ': 'Vítejte' },
+          translations: { 'ko-KR': '환영합니다', 'vi-VN': 'Chào mừng', 'zh-CN': '欢迎', 'fr-FR': 'Bienvenue', 'cs-CZ': 'Vítejte' },
           slug: 'index',
         },
         {
           label: 'Roadmap',
-          translations: { 'vi-VN': 'Lộ trình', 'zh-CN': '路线图', 'fr-FR': 'Feuille de route', 'cs-CZ': 'Plán rozvoje' },
+          translations: { 'ko-KR': '로드맵', 'vi-VN': 'Lộ trình', 'zh-CN': '路线图', 'fr-FR': 'Feuille de route', 'cs-CZ': 'Plán rozvoje' },
           slug: 'roadmap',
         },
         {
           label: 'Tutorials',
-          translations: { 'vi-VN': 'Hướng dẫn nhập môn', 'zh-CN': '教程', 'fr-FR': 'Tutoriels', 'cs-CZ': 'Tutoriály' },
+          translations: { 'ko-KR': '튜토리얼', 'vi-VN': 'Hướng dẫn nhập môn', 'zh-CN': '教程', 'fr-FR': 'Tutoriels', 'cs-CZ': 'Tutoriály' },
           collapsed: false,
           autogenerate: { directory: 'tutorials' },
         },
         {
           label: 'How-To Guides',
-          translations: { 'vi-VN': 'Hướng dẫn tác vụ', 'zh-CN': '操作指南', 'fr-FR': 'Guides pratiques', 'cs-CZ': 'Praktické návody' },
+          translations: {
+            'ko-KR': '사용 가이드',
+            'vi-VN': 'Hướng dẫn tác vụ',
+            'zh-CN': '操作指南',
+            'fr-FR': 'Guides pratiques',
+            'cs-CZ': 'Praktické návody',
+          },
           collapsed: true,
           autogenerate: { directory: 'how-to' },
         },
         {
           label: 'Explanation',
-          translations: { 'vi-VN': 'Giải thích', 'zh-CN': '概念说明', 'fr-FR': 'Explications', 'cs-CZ': 'Vysvětlení' },
+          translations: {
+            'ko-KR': '개념 설명',
+            'vi-VN': 'Giải thích',
+            'zh-CN': '概念说明',
+            'fr-FR': 'Explications',
+            'cs-CZ': 'Vysvětlení',
+          },
           collapsed: true,
           autogenerate: { directory: 'explanation' },
         },
         {
           label: 'Reference',
-          translations: { 'vi-VN': 'Tham chiếu', 'zh-CN': '参考', 'fr-FR': 'Référence', 'cs-CZ': 'Reference' },
+          translations: { 'ko-KR': '참조', 'vi-VN': 'Tham chiếu', 'zh-CN': '参考', 'fr-FR': 'Référence', 'cs-CZ': 'Reference' },
           collapsed: true,
           autogenerate: { directory: 'reference' },
         },
         // TEA docs moved to standalone module site; keep BMM sidebar focused.
         {
           label: 'BMad Ecosystem',
-          translations: { 'vi-VN': 'Hệ sinh thái BMad', 'zh-CN': 'BMad 生态系统', 'fr-FR': 'Écosystème BMad', 'cs-CZ': 'Ekosystém BMad' },
+          translations: {
+            'ko-KR': 'BMad 생태계',
+            'vi-VN': 'Hệ sinh thái BMad',
+            'zh-CN': 'BMad 生态系统',
+            'fr-FR': 'Écosystème BMad',
+            'cs-CZ': 'Ekosystém BMad',
+          },
           collapsed: false,
           items: [
             {
               label: 'BMad Builder',
-              translations: { 'vi-VN': 'BMad Builder', 'zh-CN': 'BMad 构建器', 'fr-FR': 'BMad Builder', 'cs-CZ': 'BMad Builder' },
+              translations: {
+                'ko-KR': 'BMad Builder',
+                'vi-VN': 'BMad Builder',
+                'zh-CN': 'BMad 构建器',
+                'fr-FR': 'BMad Builder',
+                'cs-CZ': 'BMad Builder',
+              },
               link: 'https://bmad-builder-docs.bmad-method.org/',
               attrs: { target: '_blank' },
             },
             {
               label: 'Creative Intelligence Suite',
               translations: {
+                'ko-KR': '창의적 지능 제품군',
                 'vi-VN': 'Bộ công cụ Trí tuệ Sáng tạo',
                 'zh-CN': '创意智能套件',
                 'fr-FR': "Suite d'Intelligence Créative",
@@ -152,6 +177,7 @@ export default defineConfig({
             {
               label: 'Game Dev Studio',
               translations: {
+                'ko-KR': '게임 개발 스튜디오',
                 'vi-VN': 'Xưởng phát triển Game',
                 'zh-CN': '游戏开发工作室',
                 'fr-FR': 'Studio de Développement de Jeux',
@@ -163,6 +189,7 @@ export default defineConfig({
             {
               label: 'Test Architect (TEA)',
               translations: {
+                'ko-KR': '테스트 설계자(TEA)',
                 'vi-VN': 'Kiến trúc sư Kiểm thử (TEA)',
                 'zh-CN': '测试架构师 (TEA)',
                 'fr-FR': 'Architecte de Tests (TEA)',

website/public/workflow-map-diagram-fr.html

@@ -132,10 +132,10 @@
     <div class="header">
         <div class="header-badge">⚡ Carte des Workflows V6</div>
         <h1>Méthode BMad</h1>
-        <p class="subtitle">Ingénierie de contexte pour le développement piloté par l'IA</p>
+        <p class="subtitle">Ingénierie du contexte pour le développement piloté par l’IA</p>
     </div>
 
-    <div class="flow-legend">→ les flèches indiquent le flux des artefacts entre les workflows</div>
+    <div class="flow-legend">→ les flèches montrent le flux des artefacts entre les workflows</div>
 
     <div class="flow-grid">
         <!-- Phase 1: Analysis -->
@@ -163,18 +163,29 @@
                     </div>
                     <div class="workflow-meta">
                         <div class="agent"><div class="agent-icon mary">M</div><span class="agent-name">Mary</span></div>
-                        <span class="output">conclusions</span>
+                        <span class="output">résultats</span>
                     </div>
                 </div>
                 <div class="workflow">
                     <div class="workflow-header">
-                        <span class="workflow-name">create-product-brief</span>
+                        <span class="workflow-name">product-brief</span>
+                        <span class="badge opt">ou ↓</span>
                     </div>
                     <div class="workflow-meta">
                         <div class="agent"><div class="agent-icon mary">M</div><span class="agent-name">Mary</span></div>
                         <span class="output">product-brief.md →</span>
                     </div>
                 </div>
+                <div class="workflow">
+                    <div class="workflow-header">
+                        <span class="workflow-name">prfaq</span>
+                        <span class="badge opt">ou ↑</span>
+                    </div>
+                    <div class="workflow-meta">
+                        <div class="agent"><div class="agent-icon mary">M</div><span class="agent-name">Mary</span></div>
+                        <span class="output">prfaq.md →</span>
+                    </div>
+                </div>
             </div>
             <div class="arrow">→</div>
         </div>
@@ -188,14 +199,14 @@
             <div class="workflows">
                 <div class="workflow">
                     <div class="workflow-header">
-                        <span class="workflow-name">create-prd</span>
+                        <span class="workflow-name">prd</span>
                     </div>
                     <div class="workflow-meta">
-                        <div class="agent"><div class="agent-icon john">J</div><span class="agent-name">John</span></div>
-                        <span class="output">PRD.md →</span>
+                        <div class="agent"><div class="agent-icon john">J</div><span class="agent-name">Au choix</span></div>
+                        <span class="output">prd.md →</span>
                     </div>
                 </div>
-                <div class="decision">Comporte une Interface Utilisateur ?</div>
+                <div class="decision">Interface utilisateur ?</div>
                 <div class="workflow">
                     <div class="workflow-header">
                         <span class="workflow-name">create-ux-design</span>
@@ -241,7 +252,7 @@
                     </div>
                     <div class="workflow-meta">
                         <div class="agent"><div class="agent-icon john">J</div><span class="agent-name">John</span></div>
-                        <span class="output">vérification</span>
+                        <span class="output">validation</span>
                     </div>
                 </div>
             </div>
@@ -308,7 +319,7 @@
                     </div>
                     <div class="workflow-meta">
                         <div class="agent"><div class="agent-icon amelia">A</div><span class="agent-name">Amelia</span></div>
-                        <span class="output">leçons</span>
+                        <span class="output">leçons apprises</span>
                     </div>
                 </div>
                 <div class="workflow">
@@ -318,7 +329,7 @@
                     </div>
                     <div class="workflow-meta">
                         <div class="agent"><div class="agent-icon amelia">A</div><span class="agent-name">Amelia</span></div>
-                        <span class="output">dossier de cas</span>
+                        <span class="output">rapport d’investigation</span>
                     </div>
                 </div>
             </div>
@@ -329,22 +340,22 @@
         <div class="quickflow-header">
             <span>⚡</span>
             <div>
-                <h2>Quick Dev (Parcours Rapide)</h2>
-                <span>Pour les petites modifications bien comprises — sautez les phases 1-3</span>
+                <h2>Quick Dev (Parcours Parallèle)</h2>
+                <span>Pour les petits changements bien cernés — sautez les phases 1 à 3</span>
             </div>
         </div>
         <div class="quickflow-body">
             <div class="quickflow-item">
                 <div class="agent"><div class="agent-icon amelia">A</div><span class="agent-name">Amelia</span></div>
                 <code>quick-dev</code>
-                <div style="font-size: 0.65rem; color: var(--text-muted); margin-top: 4px;">intention → spec technique → code fonctionnel</div>
+                <div style="font-size: 0.65rem; color: var(--text-muted); margin-top: 4px;">intention → spécification technique → code fonctionnel</div>
             </div>
         </div>
     </div>
 
     <div class="context">
         <div class="context-header">📚 Flux de Contexte</div>
-        <p style="margin-bottom: 8px; color: var(--text-muted);">Chaque document devient le contexte pour la phase suivante.</p>
+        <p style="margin-bottom: 8px; color: var(--text-muted);">Chaque document devient le contexte de la phase suivante.</p>
         <div class="context-items">
             <span><code>create-story</code> <span>charge epics, PRD, architecture, UX</span></span>
             <span><code>dev-story</code> <span>charge le fichier story</span></span>

website/public/workflow-map-diagram-ko.html

@@ -0,0 +1,644 @@
+<!doctype html>
+<html lang="ko-KR">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>BMad Method 워크플로 맵</title>
+    <style>
+      :root {
+        --analysis: #0ea5e9;
+        --planning: #22c55e;
+        --solutioning: #eab308;
+        --implementation: #ef4444;
+        --quickflow: #64748b;
+        --bg: #0f172a;
+        --card: #1e293b;
+        --text: #f8fafc;
+        --text-muted: #94a3b8;
+        --border: #334155;
+        --success: #10b981;
+        --arrow: #f59e0b;
+      }
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        background: var(--bg);
+        color: var(--text);
+        line-height: 1.4;
+        padding: 12px;
+      }
+      .header {
+        text-align: center;
+        margin-bottom: 16px;
+      }
+      .header-badge {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        background: linear-gradient(135deg, var(--analysis), var(--planning));
+        padding: 4px 12px;
+        border-radius: 20px;
+        font-size: 0.75rem;
+        font-weight: 600;
+        margin-bottom: 8px;
+      }
+      h1 {
+        font-size: 1.5rem;
+        font-weight: 700;
+      }
+      .subtitle {
+        color: var(--text-muted);
+        font-size: 0.8rem;
+      }
+
+      .flow-legend {
+        background: rgba(245, 158, 11, 0.1);
+        border: 1px solid rgba(245, 158, 11, 0.3);
+        border-radius: 8px;
+        padding: 8px 12px;
+        margin-bottom: 16px;
+        text-align: center;
+        font-size: 0.7rem;
+        color: var(--arrow);
+      }
+
+      .flow-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+        gap: 8px;
+        margin-bottom: 16px;
+      }
+
+      .phase {
+        background: var(--card);
+        border-radius: 10px;
+        border: 1px solid var(--border);
+        border-top: 3px solid;
+      }
+      .phase.analysis {
+        border-top-color: var(--analysis);
+      }
+      .phase.planning {
+        border-top-color: var(--planning);
+      }
+      .phase.solutioning {
+        border-top-color: var(--solutioning);
+      }
+      .phase.implementation {
+        border-top-color: var(--implementation);
+      }
+
+      .phase-header {
+        padding: 10px 12px 8px;
+        border-bottom: 1px solid var(--border);
+        display: flex;
+        align-items: center;
+        gap: 8px;
+      }
+      .phase-num {
+        width: 22px;
+        height: 22px;
+        border-radius: 6px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 0.75rem;
+        font-weight: 700;
+      }
+      .analysis .phase-num {
+        background: var(--analysis);
+      }
+      .planning .phase-num {
+        background: var(--planning);
+      }
+      .solutioning .phase-num {
+        background: var(--solutioning);
+        color: #000;
+      }
+      .implementation .phase-num {
+        background: var(--implementation);
+      }
+      .phase-title {
+        font-size: 0.95rem;
+        font-weight: 700;
+      }
+      .phase-opt {
+        font-size: 0.6rem;
+        padding: 2px 6px;
+        border-radius: 4px;
+        background: rgba(14, 165, 233, 0.2);
+        color: #7dd3fc;
+      }
+
+      .workflows {
+        padding: 8px 10px;
+      }
+
+      .workflow {
+        background: rgba(255, 255, 255, 0.03);
+        border-radius: 6px;
+        padding: 8px;
+        margin-bottom: 6px;
+        font-size: 0.7rem;
+      }
+      .workflow-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 4px;
+      }
+      .workflow-name {
+        font-family: monospace;
+        color: var(--success);
+        background: rgba(16, 185, 129, 0.1);
+        padding: 2px 6px;
+        border-radius: 3px;
+        font-size: 0.65rem;
+      }
+      .workflow-meta {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+      }
+      .agent {
+        display: flex;
+        align-items: center;
+        gap: 4px;
+      }
+      .agent-icon {
+        width: 14px;
+        height: 14px;
+        border-radius: 3px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 0.55rem;
+        font-weight: 700;
+      }
+      .agent-icon.mary {
+        background: linear-gradient(135deg, #f472b6, #ec4899);
+      }
+      .agent-icon.john {
+        background: linear-gradient(135deg, #60a5fa, #3b82f6);
+      }
+      .agent-icon.sally {
+        background: linear-gradient(135deg, #fbbf24, #f59e0b);
+        color: #000;
+      }
+      .agent-icon.winston {
+        background: linear-gradient(135deg, #a78bfa, #8b5cf6);
+      }
+      .agent-icon.amelia {
+        background: linear-gradient(135deg, #fb7185, #ef4444);
+      }
+
+      .agent-name {
+        font-size: 0.65rem;
+      }
+      .output {
+        color: var(--success);
+        font-family: monospace;
+        font-size: 0.6rem;
+      }
+      .badge {
+        font-size: 0.55rem;
+        padding: 1px 4px;
+        border-radius: 3px;
+      }
+      .badge.opt {
+        background: rgba(251, 191, 36, 0.15);
+        color: #fbbf24;
+      }
+      .badge.iffy {
+        background: rgba(168, 85, 247, 0.15);
+        color: #a855f7;
+      }
+      .badge.adhoc {
+        background: rgba(59, 130, 246, 0.15);
+        color: #3b82f6;
+      }
+
+      .arrow {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: var(--arrow);
+        font-size: 0.9rem;
+        margin: 6px 0;
+      }
+
+      .decision {
+        background: linear-gradient(135deg, #a855f7, #9333ea);
+        padding: 4px 8px;
+        border-radius: 4px;
+        text-align: center;
+        font-size: 0.65rem;
+        font-weight: 600;
+        margin: 6px 0;
+      }
+
+      .quickflow {
+        background: rgba(100, 116, 139, 0.2);
+        border: 2px dashed var(--quickflow);
+        border-radius: 10px;
+        padding: 12px;
+        margin-bottom: 16px;
+      }
+      .quickflow-header {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin-bottom: 8px;
+      }
+      .quickflow-header h2 {
+        font-size: 0.95rem;
+      }
+      .quickflow-header span {
+        font-size: 0.7rem;
+        color: var(--text-muted);
+      }
+      .quickflow-body {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+      }
+      .quickflow-item {
+        flex: 1;
+        background: rgba(255, 255, 255, 0.03);
+        border-radius: 8px;
+        padding: 10px;
+      }
+      .quickflow-item code {
+        font-family: monospace;
+        color: var(--success);
+        background: rgba(16, 185, 129, 0.1);
+        padding: 2px 6px;
+        border-radius: 3px;
+        font-size: 0.7rem;
+      }
+
+      .context {
+        background: rgba(14, 165, 233, 0.08);
+        border-radius: 10px;
+        padding: 12px;
+        font-size: 0.75rem;
+      }
+      .context-header {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin-bottom: 6px;
+        font-weight: 600;
+      }
+      .context-items {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px;
+      }
+      .context-items code {
+        font-family: monospace;
+        color: var(--success);
+        background: rgba(16, 185, 129, 0.1);
+        padding: 2px 5px;
+        border-radius: 3px;
+        font-size: 0.65rem;
+      }
+      .context-items span {
+        color: var(--text-muted);
+      }
+
+      .legend {
+        display: flex;
+        justify-content: center;
+        gap: 12px;
+        flex-wrap: wrap;
+        font-size: 0.7rem;
+        margin-top: 12px;
+      }
+      .legend-item {
+        display: flex;
+        align-items: center;
+        gap: 4px;
+      }
+      .legend-dot {
+        width: 12px;
+        height: 3px;
+        border-radius: 2px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="header">
+      <div class="header-badge">⚡ 워크플로 맵 V6</div>
+      <h1>BMad Method</h1>
+      <p class="subtitle">AI 기반 개발을 위한 컨텍스트 엔지니어링</p>
+    </div>
+
+    <div class="flow-legend">→ 화살표는 워크플로 간 산출물 흐름을 나타냅니다</div>
+
+    <div class="flow-grid">
+      <!-- Phase 1: Analysis -->
+      <div class="phase analysis">
+        <div class="phase-header">
+          <div class="phase-num">1</div>
+          <div class="phase-title">분석</div>
+          <span class="phase-opt">선택 사항</span>
+        </div>
+        <div class="workflows">
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">brainstorm</span>
+              <span class="badge opt">선택</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon mary">M</div>
+                <span class="agent-name">Mary</span>
+              </div>
+              <span class="output">brainstorming-report.md</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">research</span>
+              <span class="badge opt">선택</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon mary">M</div>
+                <span class="agent-name">Mary</span>
+              </div>
+              <span class="output">리서치 결과</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">product-brief</span>
+              <span class="badge opt">또는 ↓</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon mary">M</div>
+                <span class="agent-name">Mary</span>
+              </div>
+              <span class="output">product-brief.md →</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">prfaq</span>
+              <span class="badge opt">또는 ↑</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon mary">M</div>
+                <span class="agent-name">Mary</span>
+              </div>
+              <span class="output">prfaq.md →</span>
+            </div>
+          </div>
+        </div>
+        <div class="arrow">→</div>
+      </div>
+
+      <!-- Phase 2: Planning -->
+      <div class="phase planning">
+        <div class="phase-header">
+          <div class="phase-num">2</div>
+          <div class="phase-title">계획</div>
+        </div>
+        <div class="workflows">
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">prd</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon john">J</div>
+                <span class="agent-name">Any</span>
+              </div>
+              <span class="output">prd.md →</span>
+            </div>
+          </div>
+          <div class="decision">UI가 있나요?</div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">create-ux-design</span>
+              <span class="badge iffy">예</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon sally">S</div>
+                <span class="agent-name">Sally</span>
+              </div>
+              <span class="output">ux-spec.md →</span>
+            </div>
+          </div>
+        </div>
+        <div class="arrow">→</div>
+      </div>
+
+      <!-- Phase 3: Solutioning -->
+      <div class="phase solutioning">
+        <div class="phase-header">
+          <div class="phase-num">3</div>
+          <div class="phase-title">솔루션 설계</div>
+        </div>
+        <div class="workflows">
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">create-architecture</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon winston">W</div>
+                <span class="agent-name">Winston</span>
+              </div>
+              <span class="output">architecture.md →</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">create-epics-and-stories</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon john">J</div>
+                <span class="agent-name">John</span>
+              </div>
+              <span class="output">epics.md →</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">check-implementation-readiness</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon john">J</div>
+                <span class="agent-name">John</span>
+              </div>
+              <span class="output">구현 착수 전 준비도 점검</span>
+            </div>
+          </div>
+        </div>
+        <div class="arrow">→</div>
+      </div>
+
+      <!-- Phase 4: Implementation -->
+      <div class="phase implementation">
+        <div class="phase-header">
+          <div class="phase-num">4</div>
+          <div class="phase-title">구현</div>
+        </div>
+        <div class="workflows">
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">sprint-planning</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon amelia">A</div>
+                <span class="agent-name">Amelia</span>
+              </div>
+              <span class="output">sprint-status.yaml →</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">create-story</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon amelia">A</div>
+                <span class="agent-name">Amelia</span>
+              </div>
+              <span class="output">story-[slug].md →</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">dev-story</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon amelia">A</div>
+                <span class="agent-name">Amelia</span>
+              </div>
+              <span class="output">코드 →</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">code-review</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon amelia">A</div>
+                <span class="agent-name">Amelia</span>
+              </div>
+              <span class="output">승인</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">correct-course</span>
+              <span class="badge adhoc">필요 시</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon john">J</div>
+                <span class="agent-name">John</span>
+              </div>
+              <span class="output">계획 업데이트</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">retrospective</span>
+              <span class="badge adhoc">에픽 별</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon amelia">A</div>
+                <span class="agent-name">Amelia</span>
+              </div>
+              <span class="output">배운 점</span>
+            </div>
+          </div>
+          <div class="workflow">
+            <div class="workflow-header">
+              <span class="workflow-name">investigate</span>
+              <span class="badge adhoc">언제든지</span>
+            </div>
+            <div class="workflow-meta">
+              <div class="agent">
+                <div class="agent-icon amelia">A</div>
+                <span class="agent-name">Amelia</span>
+              </div>
+              <span class="output">사례 파일</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div class="quickflow">
+      <div class="quickflow-header">
+        <span>⚡</span>
+        <div>
+          <h2>Quick Flow (병렬 트랙)</h2>
+          <span>범위가 작고 명확한 변경에 사용됩니다 — 1~3단계를 건너뜁니다</span>
+        </div>
+      </div>
+      <div class="quickflow-body">
+        <div class="quickflow-item">
+          <div class="agent">
+            <div class="agent-icon amelia">A</div>
+            <span class="agent-name">Amelia</span>
+          </div>
+          <code>quick-dev</code>
+          <div style="font-size: 0.65rem; color: var(--text-muted); margin-top: 4px">의도 → 기술 명세 → 동작하는 코드</div>
+        </div>
+      </div>
+    </div>
+
+    <div class="context">
+      <div class="context-header">📚 컨텍스트 흐름</div>
+      <p style="margin-bottom: 8px; color: var(--text-muted)">각 문서는 다음 단계의 컨텍스트가 됩니다.</p>
+      <div class="context-items">
+        <span><code>create-story</code> <span>에픽, PRD, 아키텍처, UX를 로드</span></span>
+        <span><code>dev-story</code> <span>스토리 파일을 로드</span></span>
+        <span><code>code-review</code> <span>아키텍처와 스토리를 로드</span></span>
+        <span><code>quick-dev</code> <span>명확화, 계획, 구현, 리뷰</span></span>
+      </div>
+    </div>
+
+    <div class="legend">
+      <div class="legend-item">
+        <div class="legend-dot" style="background: var(--analysis)"></div>
+        분석
+      </div>
+      <div class="legend-item">
+        <div class="legend-dot" style="background: var(--planning)"></div>
+        계획
+      </div>
+      <div class="legend-item">
+        <div class="legend-dot" style="background: var(--solutioning)"></div>
+        솔루션 설계
+      </div>
+      <div class="legend-item">
+        <div class="legend-dot" style="background: var(--implementation)"></div>
+        구현
+      </div>
+      <div class="legend-item">
+        <div class="legend-dot" style="background: var(--quickflow)"></div>
+        빠른 흐름
+      </div>
+    </div>
+  </body>
+</html>

website/public/workflow-map-diagram.html

@@ -202,19 +202,19 @@
                         <span class="workflow-name">prd</span>
                     </div>
                     <div class="workflow-meta">
-                        <div class="agent"><div class="agent-icon john">J</div><span class="agent-name">Any</span></div>
+                        <div class="agent"><div class="agent-icon john">J</div><span class="agent-name">John</span></div>
                         <span class="output">prd.md →</span>
                     </div>
                 </div>
                 <div class="decision">Has UI?</div>
                 <div class="workflow">
                     <div class="workflow-header">
-                        <span class="workflow-name">create-ux-design</span>
+                        <span class="workflow-name">ux</span>
                         <span class="badge iffy">if yes</span>
                     </div>
                     <div class="workflow-meta">
                         <div class="agent"><div class="agent-icon sally">S</div><span class="agent-name">Sally</span></div>
-                        <span class="output">ux-spec.md →</span>
+                        <span class="output">DESIGN.md + EXPERIENCE.md →</span>
                     </div>
                 </div>
             </div>

website/src/components/Banner.astro

@@ -2,13 +2,102 @@
 import { getSiteUrl } from '../lib/site-url.mjs';
 
 const llmsFullUrl = `${getSiteUrl()}/llms-full.txt`;
+const bannerCopy = {
+  root: {
+    aiLabel: 'AI documentation notice',
+    aiPrefix: 'Consolidated, AI-optimized BMAD docs:',
+    aiLinkGap: ' ',
+    aiSuffix: 'Fetch this plain text file for complete context.',
+    announceLabel: 'BMad Builder announcement',
+    announcePrefix: 'Build your own BMad modules and share them with the community!',
+    announceLinkGap: ' ',
+    getStarted: 'Get started',
+    connectorBefore: ' ',
+    connector: 'or',
+    connectorAfter: ' ',
+    submit: 'submit to the marketplace',
+  },
+  'ko-kr': {
+    aiLabel: 'AI 문서 안내',
+    aiPrefix: 'AI에 최적화된 통합 BMAD 문서:',
+    aiLinkGap: ' ',
+    aiSuffix: '전체 컨텍스트가 필요하면 이 일반 텍스트 파일을 가져오세요.',
+    announceLabel: 'BMad Builder 공지',
+    announcePrefix: '나만의 BMad 모듈을 만들고 커뮤니티와 공유하세요!',
+    announceLinkGap: ' ',
+    getStarted: '시작하기',
+    connectorBefore: ' ',
+    connector: '또는',
+    connectorAfter: ' ',
+    submit: '마켓플레이스에 제출하기',
+  },
+  'vi-vn': {
+    aiLabel: 'Thông báo tài liệu AI',
+    aiPrefix: 'Tài liệu BMAD hợp nhất, tối ưu cho AI:',
+    aiLinkGap: ' ',
+    aiSuffix: 'Lấy tệp văn bản thuần này để có đầy đủ ngữ cảnh.',
+    announceLabel: 'Thông báo BMad Builder',
+    announcePrefix: 'Xây dựng các mô-đun BMad của riêng bạn và chia sẻ với cộng đồng!',
+    announceLinkGap: ' ',
+    getStarted: 'Bắt đầu',
+    connectorBefore: ' ',
+    connector: 'hoặc',
+    connectorAfter: ' ',
+    submit: 'gửi lên marketplace',
+  },
+  'zh-cn': {
+    aiLabel: 'AI 文档提示',
+    aiPrefix: '整合的 AI 优化 BMAD 文档：',
+    aiLinkGap: '',
+    aiSuffix: '获取此纯文本文件以获得完整上下文。',
+    announceLabel: 'BMad Builder 公告',
+    announcePrefix: '构建你自己的 BMad 模块并与社区分享！',
+    announceLinkGap: '',
+    getStarted: '开始使用',
+    connectorBefore: '',
+    connector: '或',
+    connectorAfter: '',
+    submit: '提交到 marketplace',
+  },
+  fr: {
+    aiLabel: 'Avis sur la documentation IA',
+    aiPrefix: 'Documentation BMAD consolidée et optimisée pour l’IA :',
+    aiLinkGap: ' ',
+    aiSuffix: 'Récupérez ce fichier texte brut pour obtenir le contexte complet.',
+    announceLabel: 'Annonce BMad Builder',
+    announcePrefix: 'Créez vos propres modules BMad et partagez-les avec la communauté !',
+    announceLinkGap: ' ',
+    getStarted: 'Commencer',
+    connectorBefore: ' ',
+    connector: 'ou',
+    connectorAfter: ' ',
+    submit: 'soumettre au marketplace',
+  },
+  cs: {
+    aiLabel: 'Upozornění k dokumentaci pro AI',
+    aiPrefix: 'Konsolidovaná dokumentace BMAD optimalizovaná pro AI:',
+    aiLinkGap: ' ',
+    aiSuffix: 'Stáhněte si tento prostý textový soubor pro úplný kontext.',
+    announceLabel: 'Oznámení BMad Builder',
+    announcePrefix: 'Vytvářejte vlastní moduly BMad a sdílejte je s komunitou!',
+    announceLinkGap: ' ',
+    getStarted: 'Začít',
+    connectorBefore: ' ',
+    connector: 'nebo',
+    connectorAfter: ' ',
+    submit: 'odeslat na marketplace',
+  },
+};
+const pathSegments = Astro.url.pathname.split('/').filter(Boolean);
+const locale = pathSegments.find((segment) => segment in bannerCopy) ?? 'root';
+const copy = bannerCopy[locale] ?? bannerCopy.root;
 ---
 
-<div class="ai-banner" role="note" aria-label="AI documentation notice">
-  <span>🤖 Consolidated, AI-optimized BMAD docs: <a href={llmsFullUrl}>llms-full.txt</a>. Fetch this plain text file for complete context.</span>
+<div class="ai-banner" role="note" aria-label={copy.aiLabel}>
+  <span>🤖 {copy.aiPrefix}{copy.aiLinkGap}<a href={llmsFullUrl}>llms-full.txt</a>. {copy.aiSuffix}</span>
 </div>
-<div class="announce-banner" role="note" aria-label="BMad Builder announcement">
-  <span>🚀 Build your own BMad modules and share them with the community! <a href="https://bmad-builder-docs.bmad-method.org/tutorials/build-your-first-module/">Get started</a> or <a href="https://bmad-builder-docs.bmad-method.org/how-to/distribute-your-module/">submit to the marketplace</a>.</span>
+<div class="announce-banner" role="note" aria-label={copy.announceLabel}>
+  <span>🚀 {copy.announcePrefix}{copy.announceLinkGap}<a href="https://bmad-builder-docs.bmad-method.org/tutorials/build-your-first-module/">{copy.getStarted}</a>{copy.connectorBefore}{copy.connector}{copy.connectorAfter}<a href="https://bmad-builder-docs.bmad-method.org/how-to/distribute-your-module/">{copy.submit}</a>.</span>
 </div>
 
 <style>

website/src/content/i18n/ko-KR.json

@@ -0,0 +1,28 @@
+{
+  "skipLink.label": "본문으로 건너뛰기",
+  "search.label": "검색",
+  "search.ctrlKey": "Ctrl",
+  "search.cancelLabel": "취소",
+  "themeSelect.accessibleLabel": "테마 선택",
+  "themeSelect.dark": "어둡게",
+  "themeSelect.light": "밝게",
+  "themeSelect.auto": "자동",
+  "languageSelect.accessibleLabel": "언어 선택",
+  "menuButton.accessibleLabel": "메뉴",
+  "sidebarNav.accessibleLabel": "기본 탐색",
+  "tableOfContents.onThisPage": "이 페이지에서",
+  "tableOfContents.overview": "개요",
+  "i18n.untranslatedContent": "이 콘텐츠는 아직 한국어로 제공되지 않습니다.",
+  "page.editLink": "이 페이지 편집",
+  "page.lastUpdated": "마지막 업데이트:",
+  "page.previousLink": "이전 페이지",
+  "page.nextLink": "다음 페이지",
+  "page.draft": "이 콘텐츠는 초안 상태이며 공식 빌드에는 표시되지 않습니다.",
+  "404.text": "페이지를 찾을 수 없습니다. 주소를 확인하거나 검색을 사용하세요.",
+  "aside.note": "참고",
+  "aside.tip": "팁",
+  "aside.caution": "주의",
+  "aside.danger": "경고",
+  "fileTree.directory": "디렉터리",
+  "builtWithStarlight.label": "Starlight로 제작"
+}

website/src/lib/locales.mjs

@@ -15,6 +15,10 @@ export const locales = {
     label: 'English',
     lang: 'en',
   },
+  'ko-kr': {
+    label: '한국어',
+    lang: 'ko-KR',
+  },
   'vi-vn': {
     label: 'Tiếng Việt',
     lang: 'vi-VN',