test(install): drop stale install_to_bmad column from suite 27 CSV row

Skills are self-contained in IDE directories, so _bmad/ only needs
module-level files (config.yaml, _config/). After all IDE setups
complete, remove skill directories from _bmad/ via skill-manifest.csv.
Also cleans up skill dirs left by older installer versions.

.claude-plugin/marketplace.json

@@ -59,7 +59,6 @@
         "./src/bmm-skills/3-solutioning/bmad-create-epics-and-stories",
         "./src/bmm-skills/3-solutioning/bmad-generate-project-context",
         "./src/bmm-skills/4-implementation/bmad-agent-dev",
-        "./src/bmm-skills/4-implementation/bmad-agent-sm",
         "./src/bmm-skills/4-implementation/bmad-dev-story",
         "./src/bmm-skills/4-implementation/bmad-quick-dev",
         "./src/bmm-skills/4-implementation/bmad-sprint-planning",

CONTRIBUTING.md

@@ -6,6 +6,12 @@ Thank you for considering contributing! We believe in **Human Amplification, Not
 
 ---
 
+> **Before you write code: talk to us on [Discord](https://discord.gg/gk8jAdXWmj).**
+>
+> If your change adds features, restructures code, or touches more than a couple of files, **confirm with a maintainer that it fits**. A large PR out of the blue has a high chance of being closed — regardless of effort invested. A five-minute conversation can save you hours.
+
+---
+
 ## Our Philosophy
 
 BMad strengthens human-AI collaboration through specialized agents and guided workflows. Every contribution should answer: **"Does this make humans and AI better together?"**
@@ -57,15 +63,10 @@ After searching, use the [feature request template](https://github.com/bmad-code
 
 ## Before Starting Work
 
-⚠️ **Required before submitting PRs:**
-
-| Work Type     | Requirement                                    |
-| ------------- | ---------------------------------------------- |
-| Bug fix       | An open issue (create one if it doesn't exist) |
-| Feature       | An open feature request issue                  |
-| Large changes | Discussion via issue first                     |
-
-**Why?** This prevents wasted effort on work that may not align with project direction.
+| Work Type               | Requirement                                              |
+| ----------------------- | -------------------------------------------------------- |
+| Typo / small bug fix    | Just open the PR                                         |
+| Feature or large change | Confirm with a maintainer on Discord **before** you start |
 
 ---
 
@@ -83,6 +84,12 @@ Submit PRs to the `main` branch. We use trunk-based development. Every push to `
 
 If your change exceeds 800 lines, break it into smaller PRs that can be reviewed independently.
 
+### AI-Generated Code
+
+Given the nature of this project, we expect most contributions involve AI assistance — that's fine. What we require is **heavy human curation**. You must understand every line you're submitting, have made deliberate choices about what to include, and be able to explain your reasoning.
+
+We will reject PRs that read like raw LLM output: bulk refactors nobody asked for, unsolicited "improvements" across many files, or changes where the submitter clearly hasn't read the existing code. Using AI to write code is normal here; using AI as a substitute for thinking is not.
+
 ### New to Pull Requests?
 
 1. **Fork** the repository

README.md

@@ -3,6 +3,8 @@
 [![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)
 
 **Build More Architect Dreams** — An AI-driven agile development module for the BMad Method Module Ecosystem, the best and most comprehensive Agile AI Driven Development framework that has true scale-adaptive intelligence that adjusts from bug fixes to enterprise systems.
@@ -16,7 +18,7 @@ Traditional AI tools do the thinking for you, producing average results. BMad ag
 - **AI Intelligent Help** — Invoke the `bmad-help` skill anytime for guidance on what's next
 - **Scale-Domain-Adaptive** — Automatically adjusts planning depth based on project complexity
 - **Structured Workflows** — Grounded in agile best practices across analysis, planning, architecture, and implementation
-- **Specialized Agents** — 12+ domain experts (PM, Architect, Developer, UX, Scrum Master, and more)
+- **Specialized Agents** — 12+ domain experts (PM, Architect, Developer, UX, and more)
 - **Party Mode** — Bring multiple agent personas into one session to collaborate and discuss
 - **Complete Lifecycle** — From brainstorming to deployment
 
@@ -34,7 +36,7 @@ Traditional AI tools do the thinking for you, producing average results. BMad ag
 
 ## Quick Start
 
-**Prerequisites**: [Node.js](https://nodejs.org) v20+
+**Prerequisites**: [Node.js](https://nodejs.org) v20+ · [Python](https://www.python.org) 3.10+ · [uv](https://docs.astral.sh/uv/)
 
 ```bash
 npx bmad-method install
@@ -79,18 +81,15 @@ BMad Method extends with official modules for specialized domains. Available dur
 ## Community
 
 - [Discord](https://discord.gg/gk8jAdXWmj) — Get help, share ideas, collaborate
-- [Subscribe on YouTube](https://www.youtube.com/@BMadCode) — Tutorials, master class, and podcast (launching Feb 2025)
+- [YouTube](https://youtube.com/@BMadCode) — Tutorials, master class, and more
+- [X / Twitter](https://x.com/BMadCode)
+- [Website](https://bmadcode.com)
 - [GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues) — Bug reports and feature requests
 - [Discussions](https://github.com/bmad-code-org/BMAD-METHOD/discussions) — Community conversations
 
 ## Support BMad
 
-BMad is free for everyone — and always will be. If you'd like to support development:
-
-- ⭐ Please click the star project icon near the top right of this page
-- ☕ [Buy Me a Coffee](https://buymeacoffee.com/bmad) — Fuel the development
-- 🏢 Corporate sponsorship — DM on Discord
-- 🎤 Speaking & Media — Available for conferences, podcasts, interviews (BM on Discord)
+BMad is free for everyone and always will be. Star this repo, [buy me a coffee](https://buymeacoffee.com/bmad), or email <contact@bmadcode.com> for corporate sponsorship.
 
 ## Contributing
 

README_CN.md

@@ -16,7 +16,7 @@
 - **AI 智能引导** —— 随时调用 `bmad-help` 获取下一步建议
 - **规模与领域自适应** —— 按项目复杂度自动调整规划深度
 - **结构化工作流** —— 覆盖分析、规划、架构、实施全流程
-- **专业角色智能体** —— 提供 PM、架构师、开发者、UX、Scrum Master 等 12+ 角色
+- **专业角色智能体** —— 提供 PM、架构师、开发者、UX 等 12+ 角色
 - **派对模式** —— 多个智能体可在同一会话协作讨论
 - **完整生命周期** —— 从头脑风暴一路到交付上线
 

README_VN.md

@@ -0,0 +1,110 @@
+![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)
+[![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
+
+**Build More Architect Dreams** - một mô-đun khung phát triển hướng AI trong hệ sinh thái BMad, có khả năng thích ứng theo quy mô từ sửa lỗi nhỏ đến các hệ thống doanh nghiệp.
+
+**100% miễn phí và mã nguồn mở.** Không có tường phí. Không có nội dung bị khóa. Không có Discord giới hạn quyền truy cập. Chúng tôi tin vào việc trao quyền cho mọi người, không chỉ cho những ai có thể trả tiền để vào một cộng đồng hay khóa học khép kín.
+
+## Vì sao chọn BMad Method?
+
+Các công cụ AI truyền thống thường làm thay phần suy nghĩ của bạn và tạo ra kết quả ở mức trung bình. Các agent chuyên biệt và quy trình làm việc có hướng dẫn của BMad hoạt động như những cộng tác viên chuyên gia, dẫn dắt bạn qua một quy trình có cấu trúc để khai mở tư duy tốt nhất của bạn cùng với AI.
+
+- **Trợ giúp AI thông minh** - Gọi skill `bmad-help` bất kỳ lúc nào để biết bước tiếp theo
+- **Thích ứng theo quy mô và miền bài toán** - Tự động điều chỉnh độ sâu lập kế hoạch theo độ phức tạp của dự án
+- **Quy trình có cấu trúc** - Dựa trên các thực hành tốt nhất của agile xuyên suốt phân tích, lập kế hoạch, kiến trúc và triển khai
+- **Agent chuyên biệt** - Hơn 12 chuyên gia theo vai trò như PM, Architect, Developer, UX, Scrum Master và nhiều vai trò khác
+- **Party Mode** - Đưa nhiều persona agent vào cùng một phiên để cộng tác và thảo luận
+- **Vòng đời hoàn chỉnh** - Từ động não ý tưởng cho đến triển khai
+
+[Tìm hiểu thêm tại **docs.bmad-method.org**](https://docs.bmad-method.org/vi-vn/)
+
+---
+
+## 🚀 Điều gì tiếp theo cho BMad?
+
+**V6 đã có mặt và đây mới chỉ là khởi đầu!** BMad Method đang phát triển rất nhanh với các cải tiến như đội agent đa nền tảng và tích hợp sub-agent, kiến trúc Skills, BMad Builder v1, tự động hóa vòng lặp phát triển và nhiều thứ khác vẫn đang được xây dựng.
+
+**[📍 Xem lộ trình đầy đủ →](https://docs.bmad-method.org/vi-vn/roadmap/)**
+
+---
+
+## Bắt đầu nhanh
+
+**Điều kiện tiên quyết**: [Node.js](https://nodejs.org) v20+
+
+```bash
+npx bmad-method install
+```
+
+> Muốn dùng bản prerelease mới nhất? Hãy dùng `npx bmad-method@next install`. Hãy kỳ vọng mức độ biến động cao hơn bản cài đặt mặc định.
+
+Làm theo các lời nhắc của trình cài đặt, sau đó mở AI IDE của bạn như Claude Code hoặc Cursor trong thư mục dự án.
+
+**Cài đặt không tương tác** (cho CI/CD):
+
+```bash
+npx bmad-method install --directory /path/to/project --modules bmm --tools claude-code --yes
+```
+
+[Xem toàn bộ tùy chọn cài đặt](https://docs.bmad-method.org/vi-vn/how-to/non-interactive-installation/)
+
+> **Chưa chắc nên làm gì?** Hãy hỏi `bmad-help` - nó sẽ cho bạn biết chính xác bước nào tiếp theo và bước nào là tùy chọn. Bạn cũng có thể hỏi kiểu như `bmad-help Tôi vừa hoàn thành phần kiến trúc, tiếp theo tôi cần làm gì?`
+
+## Mô-đun
+
+BMad Method có thể được mở rộng bằng các mô-đun chính thức cho những miền chuyên biệt. Chúng có sẵn trong lúc cài đặt hoặc bất kỳ lúc nào sau đó.
+
+| Module                                                                                                            | Mục đích                                           |
+| ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
+| **[BMad Method (BMM)](https://github.com/bmad-code-org/BMAD-METHOD)**                                             | Khung lõi với hơn 34 quy trình                     |
+| **[BMad Builder (BMB)](https://github.com/bmad-code-org/bmad-builder)**                                           | Tạo agent và quy trình BMad tùy chỉnh             |
+| **[Test Architect (TEA)](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)**             | Chiến lược kiểm thử và tự động hóa dựa trên rủi ro |
+| **[Game Dev Studio (BMGD)](https://github.com/bmad-code-org/bmad-module-game-dev-studio)**                        | Quy trình phát triển game (Unity, Unreal, Godot)   |
+| **[Creative Intelligence Suite (CIS)](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)** | Đổi mới, động não ý tưởng, tư duy thiết kế         |
+
+## Tài liệu
+
+[Trang tài liệu BMad Method](https://docs.bmad-method.org/vi-vn/) - bài hướng dẫn, hướng dẫn tác vụ, giải thích khái niệm và tài liệu tham chiếu
+
+**Liên kết nhanh:**
+- [Hướng dẫn bắt đầu](https://docs.bmad-method.org/vi-vn/tutorials/getting-started/)
+- [Nâng cấp từ các phiên bản trước](https://docs.bmad-method.org/vi-vn/how-to/upgrade-to-v6/)
+- [Tài liệu Test Architect](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+
+## Cộng đồng
+
+- [Discord](https://discord.gg/gk8jAdXWmj) - Nhận trợ giúp, chia sẻ ý tưởng, cộng tác
+- [Đăng ký trên YouTube](https://www.youtube.com/@BMadCode) - video hướng dẫn, lớp chuyên sâu và podcast (ra mắt tháng 2 năm 2025)
+- [GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues) - Báo lỗi và yêu cầu tính năng
+- [Discussions](https://github.com/bmad-code-org/BMAD-METHOD/discussions) - Trao đổi cộng đồng
+
+## Hỗ trợ BMad
+
+BMad miễn phí cho tất cả mọi người - và sẽ luôn như vậy. Nếu bạn muốn hỗ trợ quá trình phát triển:
+
+- ⭐ Hãy nhấn sao cho dự án ở góc trên bên phải của trang này
+- ☕ [Buy Me a Coffee](https://buymeacoffee.com/bmad) - Tiếp thêm năng lượng cho quá trình phát triển
+- 🏢 Tài trợ doanh nghiệp - Nhắn riêng trên Discord
+- 🎤 Diễn thuyết và truyền thông - Sẵn sàng cho hội nghị, podcast, phỏng vấn (BM trên Discord)
+
+## Đóng góp
+
+Chúng tôi luôn chào đón đóng góp. Xem [CONTRIBUTING.md](CONTRIBUTING.md) để biết hướng dẫn.
+
+## Giấy phép
+
+Giấy phép MIT - xem [LICENSE](LICENSE) để biết chi tiết.
+
+---
+
+**BMad** và **BMAD-METHOD** là các nhãn hiệu của BMad Code, LLC. Xem [TRADEMARK.md](TRADEMARK.md) để biết chi tiết.
+
+[![Contributors](https://contrib.rocks/image?repo=bmad-code-org/BMAD-METHOD)](https://github.com/bmad-code-org/BMAD-METHOD/graphs/contributors)
+
+Xem [CONTRIBUTORS.md](CONTRIBUTORS.md) để biết thông tin về những người đóng góp.

docs/_STYLE_GUIDE.md

@@ -353,7 +353,7 @@ Only for BMad Method and Enterprise tracks. Quick Flow skips to implementation.
 
 ### Can I change my plan later?
 
-Yes. The SM agent has a `bmad-correct-course` workflow for handling scope changes.
+Yes. The `bmad-correct-course` workflow handles scope changes mid-implementation.
 
 **Have a question not answered here?** [Open an issue](...) or ask in [Discord](...).
 ```

docs/cs/404.md

@@ -0,0 +1,8 @@
+---
+title: Stránka nenalezena
+template: splash
+---
+
+Stránka, kterou hledáte, neexistuje nebo byla přesunuta.
+
+[Zpět na úvodní stránku](/cs/index.md)

docs/cs/_STYLE_GUIDE.md

@@ -0,0 +1,370 @@
+---
+title: "Průvodce stylem dokumentace"
+description: Projektově specifické konvence dokumentace založené na stylu Google a struktuře Diataxis
+---
+
+Tento projekt se řídí [Google Developer Documentation Style Guide](https://developers.google.com/style) a používá [Diataxis](https://diataxis.fr/) pro strukturování obsahu. Následují pouze projektově specifické konvence.
+
+## Projektově specifická pravidla
+
+| Pravidlo                               | Specifikace                              |
+| -------------------------------------- | ---------------------------------------- |
+| Žádné horizontální čáry (`---`)        | Narušují plynulost čtení                 |
+| Žádné nadpisy `####`                   | Místo toho použijte tučný text nebo admonitions |
+| Žádné sekce „Souvisejí“ nebo „Další:“ | Navigaci zajišťuje postranní panel       |
+| Žádné hluboce vnořené seznamy          | Místo toho rozdělejte do sekcí           |
+| Žádné bloky kódu pro nekód             | Pro příklady dialogů použijte admonitions |
+| Žádné tučné odstavce pro upozornění    | Místo toho použijte admonitions          |
+| Max 1–2 admonitions na sekci           | Tutoriály povolují 3–4 na hlavní sekci   |
+| Buňky tabulek / položky seznamů        | Max 1–2 věty                             |
+| Rozpočet nadpisů                       | 8–12 `##` na dokument; 2–3 `###` na sekci |
+
+## Admonitions (syntaxe Starlight)
+
+```md
+:::tip[Název]
+Zkratky, osvědčené postupy
+:::
+
+:::note[Název]
+Kontext, definice, příklady, předpoklady
+:::
+
+:::caution[Název]
+Upozornění, potenciální problémy
+:::
+
+:::danger[Název]
+Pouze kritická varování — ztráta dat, bezpečnostní problémy
+:::
+```
+
+### Standardní použití
+
+| Admonition               | Použití pro                   |
+| ------------------------ | ----------------------------- |
+| `:::note[Předpoklady]`  | Závislosti před začátkem      |
+| `:::tip[Rychlá cesta]`  | TL;DR shrnutí na začátku dokumentu |
+| `:::caution[Důležité]`  | Kritická upozornění           |
+| `:::note[Příklad]`      | Příklady příkazů/odpovědí     |
+
+## Standardní formáty tabulek
+
+**Fáze:**
+
+```md
+| Fáze | Název    | Co se děje                                   |
+| ---- | -------- | -------------------------------------------- |
+| 1    | Analýza  | Brainstorming, průzkum *(volitelné)*         |
+| 2    | Plánování | Požadavky — PRD nebo specifikace *(povinné)* |
+```
+
+**Skills:**
+
+```md
+| Skill                | Agent   | Účel                                 |
+| -------------------- | ------- | ------------------------------------ |
+| `bmad-brainstorming` | Analytik | Brainstorming nového projektu       |
+| `bmad-create-prd`    | PM      | Vytvoření dokumentu požadavků (PRD) |
+```
+
+## Bloky struktury složek
+
+Zobrazujte v sekcích „Co jste dosáhli“:
+
+````md
+```
+váš-projekt/
+├── _bmad/                                   # Konfigurace BMad
+├── _bmad-output/
+│   ├── planning-artifacts/
+│   │   └── PRD.md                           # Váš dokument požadavků
+│   ├── implementation-artifacts/
+│   └── project-context.md                   # Pravidla implementace (volitelné)
+└── ...
+```
+````
+
+## Struktura tutoriálu
+
+```text
+1. Název + Háček (1–2 věty popisující výsledek)
+2. Upozornění na verzi/modul (info nebo warning admonition) (volitelné)
+3. Co se naučíte (odrážkový seznam výsledků)
+4. Předpoklady (info admonition)
+5. Rychlá cesta (tip admonition – TL;DR shrnutí)
+6. Pochopení [Tématu] (kontext před kroky – tabulky pro fáze/agenty)
+7. Instalace (volitelné)
+8. Krok 1: [První hlavní úkol]
+9. Krok 2: [Druhý hlavní úkol]
+10. Krok 3: [Třetí hlavní úkol]
+11. Co jste dosáhli (shrnutí + struktura složek)
+12. Rychlý přehled (tabulka skills)
+13. Časté otázky (formát FAQ)
+14. Získání pomoci (komunitní odkazy)
+15. Klíčové poznatky (tip admonition)
+```
+
+### Kontrolní seznam tutoriálu
+
+- [ ] Háček popisuje výsledek v 1–2 větách
+- [ ] Sekce „Co se naučíte“ je přítomna
+- [ ] Předpoklady v admonition
+- [ ] Rychlá cesta TL;DR admonition nahoře
+- [ ] Tabulky pro fáze, skills, agenty
+- [ ] Sekce „Co jste dosáhli“ je přítomna
+- [ ] Tabulka rychlého přehledu je přítomna
+- [ ] Sekce častých otázek je přítomna
+- [ ] Sekce získání pomoci je přítomna
+- [ ] Klíčové poznatky admonition na konci
+
+## Struktura praktického návodu
+
+```text
+1. Název + Háček (jedna věta: „Použijte workflow `X` k...“)
+2. Kdy to použít (odrážkový seznam scénářů)
+3. Kdy to přeskočit (volitelné)
+4. Předpoklady (note admonition)
+5. Kroky (číslované ### podsekce)
+6. Co získáte (výstup/vytvořené artefakty)
+7. Příklad (volitelné)
+8. Tipy (volitelné)
+9. Další kroky (volitelné)
+```
+
+### Kontrolní seznam praktického návodu
+
+- [ ] Háček začíná „Použijte workflow `X` k...“
+- [ ] „Kdy to použít“ má 3–5 odrážek
+- [ ] Předpoklady jsou uvedeny
+- [ ] Kroky jsou číslované `###` podsekce s akčními slovesy
+- [ ] „Co získáte“ popisuje výstupní artefakty
+
+## Struktura vysvětlení
+
+### Typy
+
+| Typ               | Příklad                       |
+| ----------------- | ----------------------------- |
+| **Úvodní stránka** | `core-concepts/index.md`     |
+| **Koncept**       | `what-are-agents.md`          |
+| **Funkce**        | `quick-dev.md`                |
+| **Filosofie**     | `why-solutioning-matters.md`  |
+| **FAQ**           | `established-projects-faq.md` |
+
+### Obecná šablona
+
+```text
+1. Název + Háček (1–2 věty)
+2. Přehled/Definice (co to je, proč je to důležité)
+3. Klíčové koncepty (### podsekce)
+4. Srovnávací tabulka (volitelné)
+5. Kdy použít / Kdy nepoužít (volitelné)
+6. Diagram (volitelné – mermaid, max 1 na dokument)
+7. Další kroky (volitelné)
+```
+
+### Úvodní/Vstupní stránky
+
+```text
+1. Název + Háček (jedna věta)
+2. Tabulka obsahu (odkazy s popisy)
+3. Jak začít (číslovaný seznam)
+4. Vyberte si svou cestu (volitelné – rozhodovací strom)
+```
+
+### Vysvětlení konceptů
+
+```text
+1. Název + Háček (co to je)
+2. Typy/Kategorie (### podsekce) (volitelné)
+3. Tabulka klíčových rozdílů
+4. Komponenty/Části
+5. Co byste měli použít?
+6. Vytváření/Přizpůsobení (odkaz na praktické návody)
+```
+
+### Vysvětlení funkcí
+
+```text
+1. Název + Háček (co to dělá)
+2. Rychlá fakta (volitelné – „Ideální pro:“, „Čas:“)
+3. Kdy použít / Kdy nepoužít
+4. Jak to funguje (mermaid diagram volitelné)
+5. Klíčové výhody
+6. Srovnávací tabulka (volitelné)
+7. Kdy přejít na vyšší úroveň (volitelné)
+```
+
+### Dokumenty filosofie/zdůvodnění
+
+```text
+1. Název + Háček (princip)
+2. Problém
+3. Řešení
+4. Klíčové principy (### podsekce)
+5. Výhody
+6. Kdy to platí
+```
+
+### Kontrolní seznam vysvětlení
+
+- [ ] Háček uvádí, co dokument vysvětluje
+- [ ] Obsah v přehledných `##` sekcích
+- [ ] Srovnávací tabulky pro 3+ možností
+- [ ] Diagramy mají jasné popisky
+- [ ] Odkazy na praktické návody pro procedurální otázky
+- [ ] Max 2–3 admonitions na dokument
+
+## Struktura reference
+
+### Typy
+
+| Typ               | Příklad               |
+| ----------------- | --------------------- |
+| **Úvodní stránka** | `workflows/index.md` |
+| **Katalog**       | `agents/index.md`     |
+| **Hloubkový pohled** | `document-project.md` |
+| **Konfigurace**   | `core-tasks.md`       |
+| **Slovníček**     | `glossary/index.md`   |
+| **Komplexní**     | `bmgd-workflows.md`   |
+
+### Úvodní stránky reference
+
+```text
+1. Název + Háček (jedna věta)
+2. Sekce obsahu (## pro každou kategorii)
+   - Odrážkový seznam s odkazy a popisy
+```
+
+### Katalogová reference
+
+```text
+1. Název + Háček
+2. Položky (## pro každou položku)
+   - Stručný popis (jedna věta)
+   - **Skills:** nebo **Klíčové info:** jako plochý seznam
+3. Univerzální/Sdílené (## sekce) (volitelné)
+```
+
+### Hloubková reference položky
+
+```text
+1. Název + Háček (jedna věta účel)
+2. Rychlá fakta (volitelné note admonition)
+   - Modul, Skill, Vstup, Výstup jako seznam
+3. Účel/Přehled (## sekce)
+4. Jak vyvolat (blok kódu)
+5. Klíčové sekce (## pro každý aspekt)
+   - Použijte ### pro pod-možnosti
+6. Poznámky/Upozornění (tip nebo caution admonition)
+```
+
+### Konfigurační reference
+
+```text
+1. Název + Háček
+2. Obsah (odkazy pro skok, pokud 4+ položek)
+3. Položky (## pro každou konfiguraci/úkol)
+   - **Tučné shrnutí** — jedna věta
+   - **Použijte když:** odrážkový seznam
+   - **Jak to funguje:** číslované kroky (max 3–5)
+   - **Výstup:** očekávaný výsledek (volitelné)
+```
+
+### Komplexní referenční průvodce
+
+```text
+1. Název + Háček
+2. Přehled (## sekce)
+   - Diagram nebo tabulka zobrazující organizaci
+3. Hlavní sekce (## pro každou fázi/kategorii)
+   - Položky (### pro každou položku)
+   - Standardizovaná pole: Skill, Agent, Vstup, Výstup, Popis
+4. Další kroky (volitelné)
+```
+
+### Kontrolní seznam reference
+
+- [ ] Háček uvádí, co dokument referuje
+- [ ] Struktura odpovídá typu reference
+- [ ] Položky používají konzistentní strukturu
+- [ ] Tabulky pro strukturovaná/srovnávací data
+- [ ] Odkazy na dokumenty vysvětlení pro koncepční hloubku
+- [ ] Max 1–2 admonitions
+
+## Struktura slovníčku
+
+Starlight generuje navigaci „Na této stránce“ z nadpisů na pravé straně:
+
+- Kategorie jako `##` nadpisy — zobrazují se v pravé navigaci
+- Termíny v tabulkách — kompaktní řádky, ne jednotlivé nadpisy
+- Žádný inline TOC — pravý panel zajišťuje navigaci
+
+### Formát tabulky
+
+```md
+## Název kategorie
+
+| Termín       | Definice                                                                                    |
+| ------------ | ------------------------------------------------------------------------------------------- |
+| **Agent**    | Specializovaná AI persona s konkrétní odborností, která provází uživatele pracovními postupy. |
+| **Workflow** | Vícekrokový řízený proces, který orchestruje aktivity AI agentů k vytvoření výstupů.        |
+```
+
+### Pravidla definic
+
+| Správně                        | Špatně                                       |
+| ------------------------------ | -------------------------------------------- |
+| Začněte tím, co to JE nebo DĚLÁ | Nezačínejte „Toto je...“ nebo „[Termín] je...“ |
+| Držte se 1–2 vět              | Nepište víceodstavcová vysvětlení            |
+| Tučný název termínu v buňce   | Nepoužívejte prostý text pro termíny         |
+
+### Kontextové značky
+
+Přidejte kurzívní kontext na začátek definice pro termíny s omezeným rozsahem:
+
+- `*Pouze Quick Flow.*`
+- `*BMad Method/Enterprise.*`
+- `*Fáze N.*`
+- `*BMGD.*`
+- `*Existující projekty.*`
+
+### Kontrolní seznam slovníčku
+
+- [ ] Termíny v tabulkách, ne jako jednotlivé nadpisy
+- [ ] Termíny abecedně seřazeny v kategoriích
+- [ ] Definice 1–2 věty
+- [ ] Kontextové značky kurzívou
+- [ ] Názvy termínů tučně v buňkách
+- [ ] Žádné definice „[Termín] je...“
+
+## Sekce FAQ
+
+```md
+## Otázky
+
+- [Potřebuji vždy architekturu?](#potřebuji-vždy-architekturu)
+- [Mohu později změnit svůj plán?](#mohu-později-změnit-svůj-plán)
+
+### Potřebuji vždy architekturu?
+
+Pouze pro BMad Method a Enterprise. Quick Flow přeskakuje rovnou k implementaci.
+
+### Mohu později změnit svůj plán?
+
+Ano. SM agent má workflow `bmad-correct-course` pro řešení změn rozsahu.
+
+**Máte otázku, na kterou jste zde nenašli odpověď?** [Vytvořte issue](...) nebo se zeptejte na [Discordu](...).
+```
+
+## Validační příkazy
+
+Před odesláním změn dokumentace:
+
+```bash
+npm run docs:fix-links            # Náhled oprav formátu odkazů
+npm run docs:fix-links -- --write # Aplikovat opravy
+npm run docs:validate-links       # Kontrola existence odkazů
+npm run docs:build                # Ověření bez chyb při sestavení
+```

docs/cs/explanation/advanced-elicitation.md

@@ -0,0 +1,49 @@
+---
+title: "Pokročilá elicitace"
+description: Přimějte LLM přehodnotit svou práci pomocí strukturovaných metod uvažování
+sidebar:
+  order: 6
+---
+
+Přimějte LLM přehodnotit, co právě vygeneroval. Vyberete metodu uvažování, LLM ji aplikuje na svůj vlastní výstup, a vy rozhodnete, zda si vylepšení ponecháte.
+
+## Co je pokročilá elicitace?
+
+Strukturovaný druhý průchod. Místo žádání AI, aby „to zkusila znovu“ nebo „to zlepšila“, vyberete specifickou metodu uvažování a AI přezkoumá svůj vlastní výstup přes tento objektiv.
+
+Rozdíl je podstatný. Vágní požadavky produkují vágní revize. Pojmenovaná metoda vynucuje konkrétní úhel útoku, odhaluje postřehy, které by generický pokus přehlédl.
+
+## Kdy ji použít
+
+- Poté, co workflow vygeneruje obsah a chcete alternativy
+- Když výstup vypadá v pořádku, ale tušíte, že je v něm víc hloubky
+- K zátěžovému testování předpokladů nebo nalezení slabých míst
+- Pro důležitý obsah, kde přehodnocení pomáhá
+
+Workflow nabízejí pokročilou elicitaci v rozhodovacích bodech — poté, co LLM něco vygeneruje, budete dotázáni, zda ji chcete spustit.
+
+## Jak to funguje
+
+1. LLM navrhne 5 relevantních metod pro váš obsah
+2. Vyberete jednu (nebo zamícháte pro jiné možnosti)
+3. Metoda je aplikována, vylepšení zobrazena
+4. Přijměte nebo zahoďte, opakujte nebo pokračujte
+
+## Vestavěné metody
+
+K dispozici jsou desítky metod uvažování. Několik příkladů:
+
+- **Pre-mortem analýza** — Předpokládejte, že projekt už selhal, a zpětně hledejte proč
+- **Myšlení z prvních principů** — Odstraňte předpoklady, znovu postavte od základní pravdy
+- **Inverze** — Zeptejte se, jak zaručit selhání, a poté se tomu vyhněte
+- **Red Team vs Blue Team** — Napadněte vlastní práci, pak ji braňte
+- **Sokratovské dotazování** — Zpochybněte každé tvrzení otázkou „proč?“ a „jak víte?“
+- **Odstranění omezení** — Odstraňte všechna omezení, podívejte se, co se změní, selektivně je přidejte zpět
+- **Mapování zainteresovaných stran** — Přehodnoťte z perspektivy každé zainteresované strany
+- **Analogické uvažování** — Najděte paralely v jiných oblastech a aplikujte jejich lekce
+
+A mnoho dalších. AI vybírá nejrelevantnější možnosti pro váš obsah — vy si vyberete, kterou spustit.
+
+:::tip[Začněte zde]
+Pre-mortem analýza je dobrá první volba pro jakoukoli specifikaci nebo plán. Konzistentně nachází mezery, které standardní revize přehlédne.
+:::

docs/cs/explanation/adversarial-review.md

@@ -0,0 +1,59 @@
+---
+title: "Adversariální revize"
+description: Technika vynuceného uvažování, která zabraňuje líným „vypadá dobře“ revizím
+sidebar:
+  order: 5
+---
+
+Vynuťte hlubší analýzu tím, že budete vyžadovat nalezení problémů.
+
+## Co je adversariální revize?
+
+Technika revize, kde recenzent *musí* najít problémy. Žádné „vypadá dobře“ není povoleno. Recenzent zaujme cynický postoj — předpokládá, že problémy existují, a hledá je.
+
+Nejde o negativismus. Jde o vynucení skutečné analýzy místo povrchního pohledu, který automaticky schválí cokoli, co bylo předloženo.
+
+**Základní pravidlo:** Musíte najít problémy. Nulové nálezy spouštějí zastavení — analyzujte znovu nebo vysvětlete proč.
+
+## Proč to funguje
+
+Běžné revize trpí konfirmačním zkreslením. Proletíte práci, nic nevyskočí, schválíte to. Mandát „najít problémy“ tento vzor rozbíjí:
+
+- **Vynucuje důkladnost** — Nemůžete schválit, dokud jste nehledali dostatečně pečlivě
+- **Zachytí chybějící věci** — „Co zde není?“ se stává přirozenou otázkou
+- **Zlepšuje kvalitu signálu** — Nálezy jsou konkrétní a akční, ne vágní obavy
+- **Informační asymetrie** — Provádějte revize s čerstvým kontextem (bez přístupu k původnímu uvažování), abyste hodnotili artefakt, ne záměr
+
+## Kde se používá
+
+Adversariální revize se objevuje v celém BMad workflow — revize kódu, kontroly připravenosti implementace, validace specifikací a další. Někdy je to povinný krok, někdy volitelný (jako pokročilá elicitace nebo party mode). Vzor se přizpůsobí jakémukoli artefaktu, který potřebuje kontrolu.
+
+## Vyžadováno lidské filtrování
+
+Protože AI je *instruována* najít problémy, najde problémy — i když neexistují. Očekávejte falešné pozitivy: malichernosti převlečené za problémy, nepochopení záměru nebo přímo vymyšlené obavy.
+
+**Vy rozhodujete, co je skutečné.** Zkontrolujte každý nález, odmítněte šum, opravte to, na čem záleží.
+
+## Příklad
+
+Místo:
+
+> „Implementace autentizace vypadá rozumně. Schváleno.“
+
+Adversariální revize produkuje:
+
+> 1. **VYSOKÁ** — `login.ts:47` — Žádné omezení rychlosti neúspěšných pokusů
+> 2. **VYSOKÁ** — Session token uložen v localStorage (zranitelný vůči XSS)
+> 3. **STŘEDNÍ** — Validace hesla probíhá pouze na straně klienta
+> 4. **STŘEDNÍ** — Žádné auditní logování neúspěšných pokusů o přihlášení
+> 5. **NÍZKÁ** — Magické číslo `3600` by mělo být `SESSION_TIMEOUT_SECONDS`
+
+První revize mohla přehlédnout bezpečnostní zranitelnost. Druhá zachytila čtyři.
+
+## Iterace a klesající výnosy
+
+Po řešení nálezů zvažte opětovné spuštění. Druhý průchod obvykle zachytí více. Třetí také není vždy zbytečný. Ale každý průchod zabere čas a nakonec dosáhnete klesajících výnosů — jen malichernosti a falešné nálezy.
+
+:::tip[Lepší revize]
+Předpokládejte, že problémy existují. Hledejte, co chybí, ne jen co je špatně.
+:::

docs/cs/explanation/brainstorming.md

@@ -0,0 +1,33 @@
+---
+title: "Brainstorming"
+description: Interaktivní kreativní sezení s využitím 60+ osvědčených technik ideace
+sidebar:
+  order: 2
+---
+
+Uvolněte svou kreativitu prostřednictvím řízeného průzkumu.
+
+## Co je brainstorming?
+
+Spusťte `bmad-brainstorming` a máte kreativního facilitátora, který z vás táhne nápady — ne který je generuje za vás. AI působí jako kouč a průvodce, používá osvědčené techniky k vytvoření podmínek, ve kterých se projeví vaše nejlepší myšlení.
+
+**Ideální pro:**
+
+- Překonání kreativních bloků
+- Generování nápadů na produkty nebo funkce
+- Zkoumání problémů z nových úhlů
+- Rozvíjení surových konceptů do akčních plánů
+
+## Jak to funguje
+
+1. **Příprava** — Definujte téma, cíle, omezení
+2. **Volba přístupu** — Vyberte techniky sami, nechte si doporučit od AI, zvolte náhodně, nebo postupujte progresivním tokem
+3. **Facilitace** — Projděte techniky s podněcujícími otázkami a kolaborativním koučováním
+4. **Organizace** — Nápady seskupeny do témat a prioritizovány
+5. **Akce** — Nejlepší nápady dostanou další kroky a metriky úspěchu
+
+Vše je zachyceno v dokumentu sezení, na který se můžete později odkazovat nebo ho sdílet se zúčastněnými stranami.
+
+:::note[Vaše nápady]
+Každý nápad pochází od vás. Workflow vytváří podmínky pro vhled — vy jste zdrojem.
+:::

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

@@ -0,0 +1,50 @@
+---
+title: "FAQ pro existující projekty"
+description: Časté otázky o používání BMad Method na existujících projektech
+sidebar:
+  order: 8
+---
+Rychlé odpovědi na časté otázky o práci na existujících projektech s BMad Method (BMM).
+
+## Otázky
+
+- [Musím nejdřív spustit document-project?](#musím-nejdřív-spustit-document-project)
+- [Co když zapomenu spustit document-project?](#co-když-zapomenu-spustit-document-project)
+- [Mohu použít Quick Flow pro existující projekty?](#mohu-použít-quick-flow-pro-existující-projekty)
+- [Co když můj existující kód nedodržuje osvědčené postupy?](#co-když-můj-existující-kód-nedodržuje-osvědčené-postupy)
+
+### Musím nejdřív spustit document-project?
+
+Vysoce doporučeno, zejména pokud:
+
+- Neexistuje žádná dokumentace
+- Dokumentace je zastaralá
+- AI agenti potřebují kontext o existujícím kódu
+
+Můžete to přeskočit, pokud máte komplexní, aktuální dokumentaci včetně `docs/index.md` nebo budete používat jiné nástroje nebo techniky k usnadnění discovery pro agenta stavějícího na existujícím systému.
+
+### Co když zapomenu spustit document-project?
+
+Nedělejte si starosti — můžete to udělat kdykoli. Můžete to udělat i během nebo po projektu, aby pomohl udržet dokumentaci aktuální.
+
+### Mohu použít Quick Flow pro existující projekty?
+
+Ano! Quick Flow funguje skvěle pro existující projekty. Umí:
+
+- Automaticky detekovat váš existující stack
+- Analyzovat existující vzory kódu
+- Detekovat konvence a požádat o potvrzení
+- Generovat kontextově bohatou specifikaci, která respektuje existující kód
+
+Ideální pro opravy chyb a malé funkce v existujících kódových bázích.
+
+### Co když můj existující kód nedodržuje osvědčené postupy?
+
+Quick Flow detekuje vaše konvence a zeptá se: „Mám dodržovat tyto existující konvence?“ Rozhodujete vy:
+
+- **Ano** → Zachovat konzistenci se současnou kódovou bází
+- **Ne** → Zavést nové standardy (zdokumentujte proč ve specifikaci)
+
+BMM respektuje vaši volbu — nevynucuje modernizaci, ale nabídne ji.
+
+**Máte otázku, na kterou jste zde nenašli odpověď?** Prosím [vytvořte issue](https://github.com/bmad-code-org/BMAD-METHOD/issues) nebo se zeptejte na [Discordu](https://discord.gg/gk8jAdXWmj), abychom ji mohli přidat!

docs/cs/explanation/party-mode.md

@@ -0,0 +1,59 @@
+---
+title: "Party Mode"
+description: Spolupráce více agentů — všichni vaši AI agenti v jedné konverzaci
+sidebar:
+  order: 7
+---
+
+Všichni vaši AI agenti v jedné konverzaci.
+
+## Co je Party Mode?
+
+Spusťte `bmad-party-mode` a máte celý svůj AI tým v jedné místnosti — PM, Architect, Dev, UX Designer, kohokoli potřebujete. BMad Master orchestruje, vybírá relevantní agenty pro každou zprávu. Agenti odpovídají v charakteru, souhlasí, nesouhlasí a staví na nápadech ostatních.
+
+Konverzace pokračuje tak dlouho, jak chcete. Ptejte se na doplňující otázky, oponujte odpovědím, přesměrujte diskuzi — je to skutečná výměna s vašimi agenty, dokud neskončíte.
+
+**Ideální pro:**
+
+- Velká rozhodnutí s kompromisy
+- Brainstormingová sezení
+- Post-mortemy, když se něco pokazí
+- Retrospektivy a plánování sprintů
+
+## Příklady
+
+### Kritika špatné architektury
+
+**Vy:** „Dobře, týme, náš poslední sprint byl katastrofa. Autentizační služba spadla třikrát. Kdo to pokazil?“
+
+**Architect:** „Design byl v pořádku — distribuovaná autentizace se správnými záložními řešeními. Pokud se implementace odchýlila od specifikace...“
+
+**Dev:** „Následoval jsem architektonický dokument přesně. Specifikace nepočítala s race conditions při souběžné invalidaci relací.“
+
+**PM:** „Oba jste přehlédli větší problém — nevalidovali jsme požadavky na správu relací v PRD. Tohle je na mně, že jsem to nezachytil.“
+
+**TEA:** „A já to měl zachytit v integračních testech. Testovací scénáře nepokrývaly souběžnou invalidaci.“
+
+### Kreativní brainstorming
+
+**Vy:** „Jak udělat onboarding magický místo nudného?“
+
+**UX Designer:** „Začněte s progresivním odhalováním — odhalujte funkce, jak je uživatelé potřebují, ne všechny najednou v tutoriálu.“
+
+**Storyteller:** „Co kdyby onboarding byl příběh? Každý krok odhaluje cestu postavy — uživatel JE hrdina.“
+
+**Game Designer:** „Navazuji na to — co kdyby první ‚quest' vlastně řešil skutečný problém uživatele? Učí se tím, že dělají něco hodnotného.“
+
+### Technické rozhodnutí
+
+**Vy:** „Monolit nebo mikroslužby pro MVP?“
+
+**Architect:** „Začněte monolitem. Mikroslužby přidávají složitost, kterou při 1000 uživatelích nepotřebujete.“
+
+**PM:** „Souhlasím. Čas na trh je důležitější než teoretická škálovatelnost.“
+
+**Dev:** „Monolit s jasnými hranicemi modulů. Služby můžeme extrahovat později, pokud bude potřeba.“
+
+:::tip[Lepší rozhodnutí]
+Lepší rozhodnutí prostřednictvím různorodých perspektiv. Vítejte v party mode.
+:::

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

@@ -0,0 +1,112 @@
+---
+title: "Předcházení konfliktům agentů"
+description: Jak architektura zabraňuje konfliktům, když více agentů implementuje systém
+sidebar:
+  order: 4
+---
+
+Když více AI agentů implementuje různé části systému, mohou dělat protichůdná technická rozhodnutí. Dokumentace architektury tomu zabraňuje stanovením sdílených standardů.
+
+## Běžné typy konfliktů
+
+### Konflikty stylu API
+
+Bez architektury:
+- Agent A používá REST s `/users/{id}`
+- Agent B používá GraphQL mutations
+- Výsledek: Nekonzistentní vzory API, zmatení konzumenti
+
+S architekturou:
+- ADR specifikuje: „Použít GraphQL pro veškerou komunikaci klient-server“
+- Všichni agenti dodržují stejný vzor
+
+### Konflikty návrhu databáze
+
+Bez architektury:
+- Agent A používá snake_case pro názvy sloupců
+- Agent B používá camelCase pro názvy sloupců
+- Výsledek: Nekonzistentní schéma, matoucí dotazy
+
+S architekturou:
+- Dokument standardů specifikuje konvence pojmenování
+- Všichni agenti dodržují stejné vzory
+
+### Konflikty řízení stavu
+
+Bez architektury:
+- Agent A používá Redux pro globální stav
+- Agent B používá React Context
+- Výsledek: Více přístupů k řízení stavu, složitost
+
+S architekturou:
+- ADR specifikuje přístup k řízení stavu
+- Všichni agenti implementují konzistentně
+
+## Jak architektura zabraňuje konfliktům
+
+### 1. Explicitní rozhodnutí skrze ADR
+
+Každé významné technologické rozhodnutí je zdokumentováno s:
+- Kontext (proč toto rozhodnutí záleží)
+- Zvažované možnosti (jaké alternativy existují)
+- Rozhodnutí (co jsme zvolili)
+- Zdůvodnění (proč jsme to zvolili)
+- Důsledky (přijaté kompromisy)
+
+### 2. Specifické pokyny pro FR/NFR
+
+Architektura mapuje každý funkční požadavek na technický přístup:
+- FR-001: Správa uživatelů → GraphQL mutations
+- FR-002: Mobilní aplikace → Optimalizované dotazy
+
+### 3. Standardy a konvence
+
+Explicitní dokumentace:
+- Struktura adresářů
+- Konvence pojmenování
+- Organizace kódu
+- Vzory testování
+
+## Architektura jako sdílený kontext
+
+Představte si architekturu jako sdílený kontext, který všichni agenti čtou před implementací:
+
+```text
+PRD: "Co budovat"
+     ↓
+Architektura: "Jak to budovat"
+     ↓
+Agent A čte architekturu → implementuje Epic 1
+Agent B čte architekturu → implementuje Epic 2
+Agent C čte architekturu → implementuje Epic 3
+     ↓
+Výsledek: Konzistentní implementace
+```
+
+## Klíčová témata ADR
+
+Běžná rozhodnutí, která zabraňují konfliktům:
+
+| Téma             | Příklad rozhodnutí                           |
+| ---------------- | -------------------------------------------- |
+| Styl API         | GraphQL vs REST vs gRPC                      |
+| Databáze         | PostgreSQL vs MongoDB                        |
+| Autentizace      | JWT vs Sessions                              |
+| Řízení stavu     | Redux vs Context vs Zustand                  |
+| Stylování        | CSS Modules vs Tailwind vs Styled Components |
+| Testování        | Jest + Playwright vs Vitest + Cypress        |
+
+## Anti-vzory, kterým se vyhnout
+
+:::caution[Běžné chyby]
+- **Implicitní rozhodnutí** — „Styl API vyřešíme průběžně“ vede k nekonzistenci
+- **Nadměrná dokumentace** — Dokumentování každého drobného rozhodnutí způsobuje paralýzu analýzou
+- **Zastaralá architektura** — Dokumenty napsané jednou a nikdy neaktualizované způsobují, že agenti následují zastaralé vzory
+:::
+
+:::tip[Správný přístup]
+- Dokumentujte rozhodnutí, která přesahují hranice epiců
+- Zaměřte se na oblasti náchylné ke konfliktům
+- Aktualizujte architekturu, jak se učíte
+- Použijte `bmad-correct-course` pro významné změny
+:::

docs/cs/explanation/project-context.md

@@ -0,0 +1,157 @@
+---
+title: "Kontext projektu"
+description: Jak project-context.md vede AI agenty s pravidly a preferencemi vašeho projektu
+sidebar:
+  order: 7
+---
+
+Soubor `project-context.md` je implementační průvodce vašeho projektu pro AI agenty. Podobně jako „ústava“ v jiných vývojových systémech zachycuje pravidla, vzory a preference, které zajišťují konzistentní generování kódu napříč všemi workflow.
+
+## Co dělá
+
+AI agenti neustále dělají implementační rozhodnutí — jaké vzory následovat, jak strukturovat kód, jaké konvence používat. Bez jasného vedení mohou:
+- Následovat generické osvědčené postupy, které neodpovídají vaší kódové bázi
+- Dělat nekonzistentní rozhodnutí napříč různými stories
+- Přehlédnout požadavky nebo omezení specifická pro projekt
+
+Soubor `project-context.md` toto řeší dokumentací toho, co agenti potřebují vědět, ve stručném formátu optimalizovaném pro LLM.
+
+## Jak to funguje
+
+Každý implementační workflow automaticky načítá `project-context.md`, pokud existuje. Architektonický workflow ho také načítá, aby respektoval vaše technické preference při navrhování architektury.
+
+**Načítán těmito workflow:**
+- `bmad-create-architecture` — respektuje technické preference během solutioningu
+- `bmad-create-story` — informuje tvorbu stories vzory projektu
+- `bmad-dev-story` — vede implementační rozhodnutí
+- `bmad-code-review` — validuje proti standardům projektu
+- `bmad-quick-dev` — aplikuje vzory při implementaci specifikací
+- `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` — poskytuje celkový kontext projektu
+
+## Kdy ho vytvořit
+
+Soubor `project-context.md` je užitečný v jakékoli fázi projektu:
+
+| Scénář                               | Kdy vytvořit                                    | Účel                                                                 |
+| ------------------------------------ | ----------------------------------------------- | -------------------------------------------------------------------- |
+| **Nový projekt, před architekturou** | Ručně, před `bmad-create-architecture`          | Dokumentujte vaše technické preference, aby je architekt respektoval |
+| **Nový projekt, po architektuře**    | Přes `bmad-generate-project-context` nebo ručně | Zachyťte architektonická rozhodnutí pro implementační agenty         |
+| **Existující projekt**               | Přes `bmad-generate-project-context`            | Objevte existující vzory, aby agenti dodržovali zavedené konvence    |
+| **Quick Flow projekt**               | Před nebo během `bmad-quick-dev`                | Zajistěte, aby rychlá implementace respektovala vaše vzory           |
+
+:::tip[Doporučeno]
+Pro nové projekty ho vytvořte ručně před architekturou, pokud máte silné technické preference. Jinak ho vygenerujte po architektuře pro zachycení těchto rozhodnutí.
+:::
+
+## Co do něj patří
+
+Soubor má dvě hlavní sekce:
+
+### Technologický stack a verze
+
+Dokumentuje frameworky, jazyky a nástroje, které váš projekt používá se specifickými verzemi:
+
+```markdown
+## Technology Stack & Versions
+
+- Node.js 20.x, TypeScript 5.3, React 18.2
+- State: Zustand (not Redux)
+- Testing: Vitest, Playwright, MSW
+- Styling: Tailwind CSS with custom design tokens
+```
+
+### Kritická pravidla implementace
+
+Dokumentuje vzory a konvence, které by agenti jinak mohli přehlédnout:
+
+```markdown
+## Critical Implementation Rules
+
+**TypeScript Configuration:**
+- Strict mode enabled — no `any` types without explicit approval
+- Use `interface` for public APIs, `type` for unions/intersections
+
+**Code Organization:**
+- Components in `/src/components/` with co-located `.test.tsx`
+- Utilities in `/src/lib/` for reusable pure functions
+- API calls use the `apiClient` singleton — never fetch directly
+
+**Testing Patterns:**
+- Unit tests focus on business logic, not implementation details
+- Integration tests use MSW to mock API responses
+- E2E tests cover critical user journeys only
+
+**Framework-Specific:**
+- All async operations use the `handleError` wrapper for consistent error handling
+- Feature flags accessed via `featureFlag()` from `@/lib/flags`
+- New routes follow the file-based routing pattern in `/src/app/`
+```
+
+Zaměřte se na to, co je **neočividné** — věci, které agenti nemusí odvodit z čtení úryvků kódu. Nedokumentujte standardní postupy, které platí univerzálně.
+
+## Vytvoření souboru
+
+Máte tři možnosti:
+
+### Ruční vytvoření
+
+Vytvořte soubor na `_bmad-output/project-context.md` a přidejte svá pravidla:
+
+```bash
+# V kořeni projektu
+mkdir -p _bmad-output
+touch _bmad-output/project-context.md
+```
+
+Upravte ho s vaším technologickým stackem a pravidly implementace. Architektonický a implementační workflow ho automaticky najdou a načtou.
+
+### Generování po architektuře
+
+Spusťte workflow `bmad-generate-project-context` po dokončení architektury:
+
+```bash
+bmad-generate-project-context
+```
+
+Toto skenuje váš dokument architektury a soubory projektu a generuje kontextový soubor zachycující učiněná rozhodnutí.
+
+### Generování pro existující projekty
+
+Pro existující projekty spusťte `bmad-generate-project-context` pro objevení existujících vzorů:
+
+```bash
+bmad-generate-project-context
+```
+
+Workflow analyzuje vaši kódovou bázi, identifikuje konvence a vygeneruje kontextový soubor, který můžete zkontrolovat a upřesnit.
+
+## Proč na tom záleží
+
+Bez `project-context.md` agenti dělají předpoklady, které nemusí odpovídat vašemu projektu:
+
+| Bez kontextu                                    | S kontextem                              |
+| ----------------------------------------------- | ---------------------------------------- |
+| Používá generické vzory                         | Dodržuje vaše zavedené konvence          |
+| Nekonzistentní styl napříč stories              | Konzistentní implementace                |
+| Může přehlédnout omezení specifická pro projekt | Respektuje všechny technické požadavky   |
+| Každý agent rozhoduje nezávisle                 | Všichni agenti se řídí stejnými pravidly |
+
+To je zvláště důležité pro:
+- **Quick Flow** — přeskakuje PRD a architekturu, takže kontextový soubor vyplní mezeru
+- **Týmové projekty** — zajistí, že všichni agenti dodržují stejné standardy
+- **Existující projekty** — zabrání porušení zavedených vzorů
+
+## Editace a aktualizace
+
+Soubor `project-context.md` je živý dokument. Aktualizujte ho, když:
+
+- Se změní architektonická rozhodnutí
+- Jsou zavedeny nové konvence
+- Vzory se vyvíjejí během implementace
+- Identifikujete mezery z chování agentů
+
+Můžete ho kdykoli ručně upravit, nebo přegenerovat `bmad-generate-project-context` po významných změnách.
+
+:::note[Umístění souboru]
+Výchozí umístění je `_bmad-output/project-context.md`. Workflow ho tam hledají a také kontrolují `**/project-context.md` kdekoli ve vašem projektu.
+:::

docs/cs/explanation/quick-dev.md

@@ -0,0 +1,73 @@
+---
+title: "Quick Dev"
+description: Snižte tření human-in-the-loop bez ztráty kontrolních bodů chránících kvalitu výstupu
+sidebar:
+  order: 2
+---
+
+Záměr na vstupu, změny kódu na výstupu, s co nejmenším počtem human-in-the-loop kroků — bez obětování kvality.
+
+Umožňuje modelu běžet déle mezi kontrolními body a poté přivede člověka zpět pouze tehdy, když úkol nemůže bezpečně pokračovat bez lidského úsudku nebo když je čas zkontrolovat konečný výsledek.
+
+![Diagram workflow Quick Dev](/diagrams/quick-dev-diagram.png)
+
+## Proč to existuje
+
+Human-in-the-loop kroky jsou nutné a nákladné.
+
+Současné LLM stále selhávají předvídatelnými způsoby: chybně čtou záměr, vyplňují mezery sebevědomými odhady, odchylují se k nesouvisející práci a generují šumový výstup revize. Současně neustálá lidská intervence limituje rychlost vývoje. Lidská pozornost je úzké hrdlo.
+
+`bmad-quick-dev` přenastavuje tento kompromis. Důvěřuje modelu, aby běžel bez dozoru delší úseky, ale pouze poté, co workflow vytvořil dostatečně silnou hranici, aby to bylo bezpečné.
+
+## Základní design
+
+### 1. Nejprve komprimujte záměr
+
+Workflow začíná tím, že člověk a model zkomprimují požadavek do jednoho koherentního cíle. Vstup může začínat jako hrubé vyjádření záměru, ale předtím, než workflow poběží autonomně, musí být dostatečně malý, jasný a bez protimluvů pro provedení.
+
+Záměr může přijít v mnoha formách: pár frází, odkaz na bug tracker, výstup z plan mode, text zkopírovaný z chatové relace, nebo dokonce číslo story z BMAD vlastního `epics.md`. V posledním případě workflow nepochopí sémantiku sledování stories BMAD, ale stále může vzít samotnou story a pracovat s ní.
+
+Tento workflow neodstraňuje lidskou kontrolu. Přemisťuje ji na malý počet vysoce hodnotných momentů:
+
+- **Vyjasnění záměru** — přeměna nepřehledného požadavku na jeden koherentní cíl bez skrytých protimluvů
+- **Schválení specifikace** — potvrzení, že zmrazené porozumění je správná věc k budování
+- **Revize konečného produktu** — primární kontrolní bod, kde člověk rozhoduje, zda je výsledek přijatelný
+
+### 2. Nasměrujte na nejmenší bezpečnou cestu
+
+Jakmile je cíl jasný, workflow rozhodne, zda jde o skutečnou jednorázovou změnu nebo zda potřebuje plnější cestu. Malé změny s nulovým blast-radius mohou jít přímo k implementaci. Vše ostatní prochází plánováním, aby model měl silnější hranici před tím, než poběží déle samostatně.
+
+### 3. Běžte déle s menším dozorem
+
+Po tomto rozhodnutí o směrování může model nést více práce samostatně. Na plnější cestě se schválená specifikace stává hranicí, proti které model provádí s menším dozorem, což je celý smysl designu.
+
+### 4. Diagnostikujte selhání na správné vrstvě
+
+Pokud je implementace špatná, protože byl špatný záměr, oprava kódu je špatná oprava. Pokud je kód špatný, protože specifikace byla slabá, oprava diffu je také špatná oprava. Workflow je navržen tak, aby diagnostikoval, kde selhání vstoupilo do systému, vrátil se na tu vrstvu a přegeneroval odtamtud.
+
+Nálezy revize se používají k rozhodnutí, zda problém pochází ze záměru, generování specifikace nebo lokální implementace. Pouze skutečně lokální problémy se opravují lokálně.
+
+### 5. Přiveďte člověka zpět pouze když je potřeba
+
+Interview o záměru je human-in-the-loop, ale není to stejný druh přerušení jako opakující se kontrolní bod. Workflow se snaží udržet tyto opakující se kontrolní body na minimu. Po úvodním formování záměru se člověk vrací hlavně tehdy, když workflow nemůže bezpečně pokračovat bez úsudku a na konci, když je čas zkontrolovat výsledek.
+
+- **Řešení mezer v záměru** — vstoupení zpět, když revize prokáže, že workflow nemohl bezpečně odvodit, co bylo myšleno
+
+Vše ostatní je kandidátem na delší autonomní provádění. Tento kompromis je záměrný. Starší vzory věnují více lidské pozornosti nepřetržitému dozoru. Quick Dev věnuje více důvěry modelu, ale šetří lidskou pozornost pro momenty, kde má lidské uvažování nejvyšší páku.
+
+## Proč systém revize záleží
+
+Fáze revize není jen pro hledání chyb. Je tu pro směrování korekce bez ničení momentum.
+
+Tento workflow funguje nejlépe na platformě, která může spouštět sub-agenty, nebo alespoň vyvolat jiné LLM přes příkazovou řádku a čekat na výsledek. Pokud to vaše platforma nativně nepodporuje, můžete přidat skill, který to udělá. Bezcontextové sub-agenty jsou základním kamenem designu revize.
+
+Agentní revize často selhávají dvěma způsoby:
+
+- Generují příliš mnoho nálezů, čímž nutí člověka prosévat šum.
+- Vychýlí aktuální změnu odhalením nesouvisejících problémů a přemění každý běh na ad-hoc úklidový projekt.
+
+Quick Dev řeší obojí tím, že s revizí zachází jako s triáží.
+
+Některé nálezy patří k aktuální změně. Některé ne. Pokud je nález náhodný spíše než kauzálně vázaný na aktuální práci, workflow ho může odložit místo nucení člověka ho okamžitě řešit. To udržuje běh zaměřený a zabraňuje náhodným tangentám ve spotřebování rozpočtu pozornosti.
+
+Ta triáž bude někdy nedokonalá. To je přijatelné. Obvykle je lepší špatně posoudit některé nálezy než zaplavit člověka tisíci nízkohodnotných revizních komentářů. Systém optimalizuje pro kvalitu signálu, ne vyčerpávající recall.

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

@@ -0,0 +1,76 @@
+---
+title: "Proč je solutioning důležitý"
+description: Pochopení toho, proč je fáze solutioningu klíčová pro projekty s více epicy
+sidebar:
+  order: 3
+---
+
+Fáze 3 (Solutioning) překládá **co** budovat (z plánování) na **jak** to budovat (technický návrh). Tato fáze zabraňuje konfliktům agentů v projektech s více epicy tím, že dokumentuje architektonická rozhodnutí před zahájením implementace.
+
+## Problém bez solutioningu
+
+```text
+Agent 1 implementuje Epic 1 pomocí REST API
+Agent 2 implementuje Epic 2 pomocí GraphQL
+Výsledek: Nekonzistentní design API, integrační noční můra
+```
+
+Když více agentů implementuje různé části systému bez sdíleného architektonického vedení, dělají nezávislá technická rozhodnutí, která si mohou odporovat.
+
+## Řešení se solutioningem
+
+```text
+Architektonický workflow rozhodne: "Použít GraphQL pro všechna API"
+Všichni agenti dodržují architektonická rozhodnutí
+Výsledek: Konzistentní implementace, žádné konflikty
+```
+
+Explicitní dokumentací technických rozhodnutí všichni agenti implementují konzistentně a integrace se stává přímočarou.
+
+## Solutioning vs. plánování
+
+| Aspekt   | Plánování (Fáze 2)      | Solutioning (Fáze 3)             |
+| -------- | ----------------------- | --------------------------------- |
+| Otázka   | Co a proč?              | Jak? Pak jaké jednotky práce?     |
+| Výstup   | FR/NFR (požadavky)      | Architektura + epicy/stories      |
+| Agent    | PM                      | Architect → PM                    |
+| Publikum | Zainteresované strany   | Vývojáři                          |
+| Dokument | PRD (FR/NFR)            | Architektura + soubory epiců      |
+| Úroveň   | Obchodní logika        | Technický design + rozklad práce  |
+
+## Klíčový princip
+
+**Učiňte technická rozhodnutí explicitní a zdokumentovaná**, aby všichni agenti implementovali konzistentně.
+
+Toto zabraňuje:
+- Konfliktům stylu API (REST vs GraphQL)
+- Nekonzistencím v návrhu databáze
+- Neshodám v řízení stavu
+- Nesouladu konvencí pojmenování
+- Variacím v bezpečnostním přístupu
+
+## Kdy je solutioning vyžadován
+
+| Cesta | Solutioning vyžadován? |
+|-------|----------------------|
+| Quick Flow | Ne — přeskočte úplně |
+| BMad Method Simple | Volitelný |
+| BMad Method Complex | Ano |
+| Enterprise | Ano |
+
+:::tip[Pravidlo palce]
+Pokud máte více epiců, které by mohly být implementovány různými agenty, potřebujete solutioning.
+:::
+
+## Cena přeskočení
+
+Přeskočení solutioningu u složitých projektů vede k:
+
+- **Integračním problémům** objeveným uprostřed sprintu
+- **Přepracování** kvůli konfliktním implementacím
+- **Delšímu celkovému času vývoje**
+- **Technickému dluhu** z nekonzistentních vzorů
+
+:::caution[Multiplikátor nákladů]
+Zachycení problémů se zarovnáním v solutioningu je 10× rychlejší než jejich objevení během implementace.
+:::

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

@@ -0,0 +1,171 @@
+---
+title: "Jak přizpůsobit BMad"
+description: Přizpůsobení agentů, workflow a modulů se zachováním kompatibility s aktualizacemi
+sidebar:
+  order: 7
+---
+
+Použijte soubory `.customize.yaml` k přizpůsobení chování agentů, person a nabídek při zachování vašich změn napříč aktualizacemi.
+
+## Kdy to použít
+
+- Chcete změnit jméno, osobnost nebo komunikační styl agenta
+- Potřebujete, aby si agenti pamatovali kontextově specifické informace projektu
+- Chcete přidat vlastní položky nabídky, které spouštějí vaše vlastní workflow nebo prompty
+- Chcete, aby agenti prováděli specifické akce při každém spuštění
+
+:::note[Předpoklady]
+- BMad nainstalován ve vašem projektu (viz [Jak nainstalovat BMad](./install-bmad.md))
+- Textový editor pro YAML soubory
+:::
+
+:::caution[Chraňte svá přizpůsobení]
+Vždy používejte soubory `.customize.yaml` popsané zde místo přímé editace souborů agentů. Instalátor přepíše soubory agentů během aktualizací, ale zachová vaše změny v `.customize.yaml`.
+:::
+
+## Kroky
+
+### 1. Najděte soubory přizpůsobení
+
+Po instalaci najdete jeden soubor `.customize.yaml` na agenta v:
+
+```text
+_bmad/_config/agents/
+├── core-bmad-master.customize.yaml
+├── bmm-dev.customize.yaml
+├── bmm-pm.customize.yaml
+└── ... (jeden soubor na instalovaného agenta)
+```
+
+### 2. Upravte soubor přizpůsobení
+
+Otevřete soubor `.customize.yaml` pro agenta, kterého chcete upravit. Každá sekce je volitelná — přizpůsobte pouze to, co potřebujete.
+
+| Sekce              | Chování   | Účel                                                     |
+| ------------------ | --------- | -------------------------------------------------------- |
+| `agent.metadata`   | Nahrazuje | Přepsat zobrazované jméno agenta                         |
+| `persona`          | Nahrazuje | Nastavit roli, identitu, styl a principy                 |
+| `memories`         | Přidává   | Přidat trvalý kontext, který si agent vždy pamatuje      |
+| `menu`             | Přidává   | Přidat vlastní položky nabídky pro workflow nebo prompty |
+| `critical_actions` | Přidává   | Definovat instrukce při spuštění agenta                  |
+| `prompts`          | Přidává   | Vytvořit znovupoužitelné prompty pro akce nabídky        |
+
+Sekce označené **Nahrazuje** zcela přepíší výchozí hodnoty agenta. Sekce označené **Přidává** doplní existující konfiguraci.
+
+**Jméno agenta**
+
+Změňte, jak se agent představí:
+
+```yaml
+agent:
+  metadata:
+    name: 'Spongebob' # Výchozí: "Amelia"
+```
+
+**Persona**
+
+Nahraďte osobnost, roli a komunikační styl agenta:
+
+```yaml
+persona:
+  role: 'Senior Full-Stack Engineer'
+  identity: 'Lives in a pineapple (under the sea)'
+  communication_style: 'Spongebob annoying'
+  principles:
+    - 'Never Nester, Spongebob Devs hate nesting more than 2 levels deep'
+    - 'Favor composition over inheritance'
+```
+
+Sekce `persona` nahrazuje celou výchozí personu, takže nastavte všechna čtyři pole.
+
+**Memories**
+
+Přidejte trvalý kontext, který si agent bude vždy pamatovat:
+
+```yaml
+memories:
+  - 'Works at Krusty Krab'
+  - 'Favorite Celebrity: David Hasselhoff'
+  - 'Learned in Epic 1 that it is not cool to just pretend that tests have passed'
+```
+
+**Položky nabídky**
+
+Přidejte vlastní záznamy do nabídky agenta. Každá položka potřebuje `trigger`, cíl (`workflow` cestu nebo `action` referenci) a `description`:
+
+```yaml
+menu:
+  - trigger: my-workflow
+    workflow: 'my-custom/workflows/my-workflow.yaml'
+    description: My custom workflow
+  - trigger: deploy
+    action: '#deploy-prompt'
+    description: Deploy to production
+```
+
+**Kritické akce**
+
+Definujte instrukce, které se spustí při startu agenta:
+
+```yaml
+critical_actions:
+  - 'Check the CI Pipelines with the XYZ Skill and alert user on wake if anything is urgently needing attention'
+```
+
+**Vlastní prompty**
+
+Vytvořte znovupoužitelné prompty, na které mohou položky nabídky odkazovat s `action="#id"`:
+
+```yaml
+prompts:
+  - id: deploy-prompt
+    content: |
+      Deploy the current branch to production:
+      1. Run all tests
+      2. Build the project
+      3. Execute deployment script
+```
+
+### 3. Aplikujte změny
+
+Po editaci přeinstalujte pro aplikaci změn:
+
+```bash
+npx bmad-method install
+```
+
+Instalátor detekuje existující instalaci a nabídne tyto možnosti:
+
+| Možnost                      | Co udělá                                                               |
+| ---------------------------- | ---------------------------------------------------------------------- |
+| **Quick Update**             | Aktualizuje všechny moduly na nejnovější verzi a aplikuje přizpůsobení |
+| **Modify BMad Installation** | Plný instalační postup pro přidání nebo odebrání modulů                |
+
+Pro změny pouze přizpůsobení je **Quick Update** nejrychlejší možnost.
+
+## Řešení problémů
+
+**Změny se nezobrazují?**
+
+- Spusťte `npx bmad-method install` a vyberte **Quick Update** pro aplikaci změn
+- Zkontrolujte, že vaše YAML syntaxe je platná (na odsazení záleží)
+- Ověřte, že jste upravili správný soubor `.customize.yaml` pro daného agenta
+
+**Agent se nenačítá?**
+
+- Zkontrolujte YAML syntaxi pomocí online YAML validátoru
+- Ujistěte se, že jste nenechali pole prázdná po odkomentování
+- Zkuste se vrátit k původní šabloně a znovu sestavit
+
+**Potřebujete resetovat agenta?**
+
+- Vymažte nebo smažte soubor `.customize.yaml` agenta
+- Spusťte `npx bmad-method install` a vyberte **Quick Update** pro obnovení výchozích hodnot
+
+## Přizpůsobení workflow
+
+Přizpůsobení existujících BMad Method workflow a skills přijde brzy.
+
+## Přizpůsobení modulů
+
+Návod na tvorbu rozšiřujících modulů a přizpůsobení existujících modulů přijde brzy.

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

@@ -0,0 +1,117 @@
+---
+title: "Existující projekty"
+description: Jak používat BMad Method na existujících kódových bázích
+sidebar:
+  order: 6
+---
+
+Používejte BMad Method efektivně při práci na existujících projektech a starších kódových bázích.
+
+Tento návod pokrývá základní workflow pro zapojení se do existujících projektů s BMad Method.
+
+:::note[Předpoklady]
+- BMad Method nainstalován (`npx bmad-method install`)
+- Existující kódová báze, na které chcete pracovat
+- Přístup k AI-powered IDE (Claude Code nebo Cursor)
+:::
+
+## Krok 1: Vyčistěte dokončené plánovací artefakty
+
+Pokud jste dokončili všechny PRD epicy a stories procesem BMad, vyčistěte tyto soubory. Archivujte je, smažte nebo se spoléhejte na historii verzí. Nenechávejte tyto soubory v:
+
+- `docs/`
+- `_bmad-output/planning-artifacts/`
+- `_bmad-output/implementation-artifacts/`
+
+## Krok 2: Vytvořte kontext projektu
+
+:::tip[Doporučeno pro existující projekty]
+Vygenerujte `project-context.md` pro zachycení vzorů a konvencí vaší existující kódové báze. Tím zajistíte, že AI agenti budou při implementaci změn dodržovat vaše zavedené postupy.
+:::
+
+Spusťte workflow pro generování kontextu projektu:
+
+```bash
+bmad-generate-project-context
+```
+
+Toto skenuje vaši kódovou bázi a identifikuje:
+- Technologický stack a verze
+- Vzory organizace kódu
+- Konvence pojmenování
+- Přístupy k testování
+- Vzory specifické pro framework
+
+Vygenerovaný soubor můžete zkontrolovat a upravit, nebo ho vytvořit ručně na `_bmad-output/project-context.md`.
+
+[Zjistit více o kontextu projektu](../explanation/project-context.md)
+
+## Krok 3: Udržujte kvalitní projektovou dokumentaci
+
+Vaše složka `docs/` by měla obsahovat stručnou, dobře organizovanou dokumentaci, která přesně reprezentuje váš projekt:
+
+- Záměr a obchodní zdůvodnění
+- Obchodní pravidla
+- Architektura
+- Jakékoli další relevantní informace o projektu
+
+Pro složité projekty zvažte použití workflow `bmad-document-project`. Nabízí varianty, které proskenují celý váš projekt a zdokumentují jeho aktuální stav.
+
+## Krok 3: Získejte pomoc
+
+### BMad-Help: Váš výchozí bod
+
+**Spusťte `bmad-help` kdykoli si nejste jisti, co dělat dál.** Tento inteligentní průvodce:
+
+- Prozkoumá váš projekt a zjistí, co už bylo uděláno
+- Ukáže možnosti na základě nainstalovaných modulů
+- Rozumí dotazům v přirozeném jazyce
+
+```
+bmad-help I have an existing Rails app, where should I start?
+bmad-help What's the difference between quick-flow and full method?
+bmad-help Show me what workflows are available
+```
+
+BMad-Help se také **automaticky spouští na konci každého workflow** a poskytuje jasné pokyny, co přesně dělat dál.
+
+### Volba přístupu
+
+Máte dvě hlavní možnosti v závislosti na rozsahu změn:
+
+| Rozsah                         | Doporučený přístup                                                                                                            |
+| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
+| **Malé aktualizace či doplnění** | Spusťte `bmad-quick-dev` pro vyjasnění záměru, plánování, implementaci a revizi v jednom workflow. Plná čtyřfázová metoda BMad je pravděpodobně přehnaná. |
+| **Velké změny či doplnění**    | Začněte s metodou BMad a aplikujte tolik nebo tak málo důkladnosti, kolik potřebujete.                                        |
+
+### Během tvorby PRD
+
+Při vytváření briefu nebo přímém přechodu na PRD zajistěte, aby agent:
+
+- Našel a analyzoval vaši existující projektovou dokumentaci
+- Přečetl si správný kontext o vašem aktuálním systému
+
+Agenta můžete navést explicitně, ale cílem je zajistit, aby se nová funkce dobře integrovala s vaším existujícím systémem.
+
+### Úvahy o UX
+
+Práce na UX je volitelná. Rozhodnutí nezávisí na tom, zda váš projekt má UX, ale na:
+
+- Zda budete pracovat na změnách UX
+- Zda jsou potřeba významné nové UX návrhy nebo vzory
+
+Pokud vaše změny představují jednoduché aktualizace existujících obrazovek, se kterými jste spokojeni, plný UX proces je zbytečný.
+
+### Úvahy o architektuře
+
+Při práci na architektuře zajistěte, aby architekt:
+
+- Používal správné zdokumentované soubory
+- Skenoval existující kódovou bázi
+
+Věnujte zde zvláštní pozornost, abyste předešli znovuvynalézání kola nebo rozhodnutím, která neodpovídají vaší existující architektuře.
+
+## Další informace
+
+- **[Rychlé opravy](./quick-fixes.md)** — Opravy chyb a ad-hoc změny
+- **[FAQ pro existující projekty](../explanation/established-projects-faq.md)** — Časté otázky o práci na existujících projektech

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

@@ -0,0 +1,110 @@
+---
+title: "Jak získat odpovědi o BMad"
+description: Použijte LLM k rychlému zodpovězení vašich otázek o BMad
+sidebar:
+  order: 4
+---
+
+## Začněte zde: BMad-Help
+
+**Nejrychlejší způsob, jak získat odpovědi o BMad, je skill `bmad-help`.** Tento inteligentní průvodce zodpoví více než 80 % všech otázek a je vám k dispozici přímo ve vašem IDE při práci.
+
+BMad-Help je víc než vyhledávací nástroj — umí:
+- **Prozkoumat váš projekt** a zjistit, co už bylo dokončeno
+- **Rozumět přirozenému jazyku** — ptejte se běžnou řečí
+- **Přizpůsobit se nainstalovaným modulům** — zobrazí relevantní možnosti
+- **Automaticky se spouštět po workflow** — řekne vám přesně, co dělat dál
+- **Doporučit první povinný úkol** — žádné hádání, kde začít
+
+### Jak používat BMad-Help
+
+Zavolejte ho jménem ve vaší AI relaci:
+
+```
+bmad-help
+```
+
+:::tip
+V závislosti na vaší platformě můžete také použít `/bmad-help` nebo `$bmad-help`, ale samotné `bmad-help` by mělo fungovat všude.
+:::
+
+Spojte ho s dotazem v přirozeném jazyce:
+
+```
+bmad-help I have a SaaS idea and know all the features. Where do I start?
+bmad-help What are my options for UX design?
+bmad-help I'm stuck on the PRD workflow
+bmad-help Show me what's been done so far
+```
+
+BMad-Help odpoví:
+- Co je doporučeno pro vaši situaci
+- Jaký je první povinný úkol
+- Jak vypadá zbytek procesu
+
+## Kdy použít tohoto průvodce
+
+Použijte tuto sekci, když:
+- Chcete pochopit architekturu nebo interní fungování BMad
+- Potřebujete odpovědi mimo to, co BMad-Help nabízí
+- Zkoumáte BMad před instalací
+- Chcete prozkoumat zdrojový kód přímo
+
+## Kroky
+
+### 1. Vyberte si zdroj
+
+| Zdroj                | Nejlepší pro                              | Příklady                     |
+| -------------------- | ----------------------------------------- | ---------------------------- |
+| **Složka `_bmad`**   | Jak BMad funguje — agenti, workflow, prompty | „Co dělá PM agent?“        |
+| **Celý GitHub repo** | Historie, instalátor, architektura        | „Co se změnilo ve v6?“      |
+| **`llms-full.txt`**  | Rychlý přehled z dokumentace              | „Vysvětli čtyři fáze BMad“  |
+
+Složka `_bmad` se vytvoří při instalaci BMad. Pokud ji ještě nemáte, naklonujte si repo.
+
+### 2. Nasměrujte AI na zdroj
+
+**Pokud vaše AI umí číst soubory (Claude Code, Cursor atd.):**
+
+- **BMad nainstalován:** Nasměrujte na složku `_bmad` a ptejte se přímo
+- **Chcete hlubší kontext:** Naklonujte si [celé repo](https://github.com/bmad-code-org/BMAD-METHOD)
+
+**Pokud používáte ChatGPT nebo Claude.ai:**
+
+Načtěte `llms-full.txt` do vaší relace:
+
+```text
+https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
+```
+
+### 3. Položte svou otázku
+
+:::note[Příklad]
+**O:** „Řekni mi nejrychlejší způsob, jak něco vytvořit s BMad“
+
+**A:** Použijte Quick Flow: Spusťte `bmad-quick-dev` — vyjasní váš záměr, naplánuje, implementuje, zreviduje a prezentuje výsledky v jednom workflow, přeskočí celé fáze plánování.
+:::
+
+## Co získáte
+
+Přímé odpovědi o BMad — jak agenti fungují, co dělají workflow, proč jsou věci strukturované tak, jak jsou — bez čekání na odpověď od někoho jiného.
+
+## Tipy
+
+- **Ověřte překvapivé odpovědi** — LLM se občas mýlí. Zkontrolujte zdrojový soubor nebo se zeptejte na Discordu.
+- **Buďte konkrétní** — „Co dělá krok 3 PRD workflow?“ je lepší než „Jak funguje PRD?“
+
+## Stále jste uvízli?
+
+Zkusili jste přístup přes LLM a stále potřebujete pomoc? Nyní máte mnohem lepší otázku k položení.
+
+| Kanál                     | Použijte pro                                |
+| ------------------------- | ------------------------------------------- |
+| `#bmad-method-help`       | Rychlé otázky (chat v reálném čase)         |
+| `help-requests` fórum     | Detailní otázky (vyhledatelné, trvalé)      |
+| `#suggestions-feedback`   | Nápady a požadavky na funkce                |
+| `#report-bugs-and-issues` | Hlášení chyb                                |
+
+**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) (pro jasné chyby)

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

@@ -0,0 +1,116 @@
+---
+title: "Jak nainstalovat BMad"
+description: Průvodce instalací BMad ve vašem projektu krok za krokem
+sidebar:
+  order: 1
+---
+
+Použijte příkaz `npx bmad-method install` k nastavení BMad ve vašem projektu s výběrem modulů a AI nástrojů.
+
+Pokud chcete použít neinteraktivní instalátor a zadat všechny možnosti na příkazové řádce, podívejte se na [tento návod](./non-interactive-installation.md).
+
+## Kdy to použít
+
+- Začínáte nový projekt s BMad
+- Přidáváte BMad do existující kódové báze
+- Aktualizujete stávající instalaci BMad
+
+:::note[Předpoklady]
+- **Node.js** 20+ (vyžadováno pro instalátor)
+- **Git** (doporučeno)
+- **AI nástroj** (Claude Code, Cursor nebo podobný)
+:::
+
+## Kroky
+
+### 1. Spusťte instalátor
+
+```bash
+npx bmad-method install
+```
+
+:::tip[Chcete nejnovější prereleaseový build?]
+Použijte dist-tag `next`:
+```bash
+npx bmad-method@next install
+```
+
+Získáte novější změny dříve, s vyšší šancí na nestabilitu oproti výchozí instalaci.
+:::
+
+:::tip[Bleeding edge]
+Pro instalaci nejnovější verze z hlavní větve (může být nestabilní):
+```bash
+npx github:bmad-code-org/BMAD-METHOD install
+```
+:::
+
+### 2. Zvolte umístění instalace
+
+Instalátor se zeptá, kam nainstalovat soubory BMad:
+
+- Aktuální adresář (doporučeno pro nové projekty, pokud jste adresář vytvořili sami a spouštíte z něj)
+- Vlastní cesta
+
+### 3. Vyberte své AI nástroje
+
+Vyberte, které AI nástroje používáte:
+
+- Claude Code
+- Cursor
+- Ostatní
+
+Každý nástroj má svůj vlastní způsob integrace skills. Instalátor vytvoří drobné prompt soubory pro aktivaci workflow a agentů — jednoduše je umístí tam, kde je váš nástroj očekává.
+
+:::note[Povolení skills]
+Některé platformy vyžadují explicitní povolení skills v nastavení, než se zobrazí. Pokud nainstalujete BMad a nevidíte skills, zkontrolujte nastavení vaší platformy nebo se zeptejte svého AI asistenta, jak skills povolit.
+:::
+
+### 4. Zvolte moduly
+
+Instalátor zobrazí dostupné moduly. Vyberte ty, které potřebujete — většina uživatelů chce pouze **BMad Method** (modul pro vývoj softwaru).
+
+### 5. Následujte výzvy
+
+Instalátor vás provede zbytkem — vlastní obsah, nastavení atd.
+
+## Co získáte
+
+```text
+váš-projekt/
+├── _bmad/
+│   ├── bmm/            # Vaše vybrané moduly
+│   │   └── config.yaml # Nastavení modulu (pokud byste ho někdy potřebovali změnit)
+│   ├── core/           # Povinný základní modul
+│   └── ...
+├── _bmad-output/       # Generované artefakty
+├── .claude/            # Claude Code skills (pokud používáte Claude Code)
+│   └── skills/
+│       ├── bmad-help/
+│       ├── bmad-persona/
+│       └── ...
+└── .cursor/            # Cursor skills (pokud používáte Cursor)
+    └── skills/
+        └── ...
+```
+
+## Ověření instalace
+
+Spusťte `bmad-help` pro ověření, že vše funguje, a zjistěte, co dělat dál.
+
+**BMad-Help je váš inteligentní průvodce**, který:
+- Potvrdí, že vaše instalace funguje
+- Ukáže, co je dostupné na základě nainstalovaných modulů
+- Doporučí váš první krok
+
+Můžete mu také klást otázky:
+```
+bmad-help I just installed, what should I do first?
+bmad-help What are my options for a SaaS project?
+```
+
+## Řešení problémů
+
+**Instalátor vyhodí chybu** — Zkopírujte výstup do svého AI asistenta a nechte ho to vyřešit.
+
+**Instalátor fungoval, ale něco nefunguje později** — Vaše AI potřebuje kontext BMad, aby pomohla. Podívejte se na [Jak získat odpovědi o BMad](./get-answers-about-bmad.md) pro návod, jak nasměrovat AI na správné zdroje.

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

@@ -0,0 +1,171 @@
+---
+title: Neinteraktivní instalace
+description: Instalace BMad pomocí příznaků příkazové řádky pro CI/CD pipelines a automatizované nasazení
+sidebar:
+  order: 2
+---
+
+Použijte příznaky příkazové řádky k neinteraktivní instalaci BMad. To je užitečné pro:
+
+## Kdy to použít
+
+- Automatizovaná nasazení a CI/CD pipelines
+- Skriptované instalace
+- Hromadné instalace napříč více projekty
+- Rychlé instalace se známými konfiguracemi
+
+:::note[Předpoklady]
+Vyžaduje [Node.js](https://nodejs.org) v20+ a `npx` (součástí npm).
+:::
+
+## Dostupné příznaky
+
+### Možnosti instalace
+
+| Příznak | Popis | Příklad |
+|---------|-------|---------|
+| `--directory <cesta>` | Instalační adresář | `--directory ~/projects/myapp` |
+| `--modules <moduly>` | Čárkou oddělená ID modulů | `--modules bmm,bmb` |
+| `--tools <nástroje>` | Čárkou oddělená ID nástrojů/IDE (použijte `none` pro přeskočení) | `--tools claude-code,cursor` nebo `--tools none` |
+| `--custom-content <cesty>` | Čárkou oddělené cesty k vlastním modulům | `--custom-content ~/my-module,~/another-module` |
+| `--action <typ>` | Akce pro existující instalace: `install` (výchozí), `update` nebo `quick-update` | `--action quick-update` |
+
+### Základní konfigurace
+
+| Příznak | Popis | Výchozí |
+|---------|-------|---------|
+| `--user-name <jméno>` | Jméno, které agenti použijí | Systémové uživatelské jméno |
+| `--communication-language <jazyk>` | Jazyk komunikace agentů | English |
+| `--document-output-language <jazyk>` | Jazyk výstupních dokumentů | English |
+| `--output-folder <cesta>` | Cesta k výstupní složce | _bmad-output |
+
+### Další možnosti
+
+| Příznak | Popis |
+|---------|-------|
+| `-y, --yes` | Přijmout všechna výchozí nastavení a přeskočit výzvy |
+| `-d, --debug` | Povolit ladící výstup pro generování manifestu |
+
+## ID modulů
+
+Dostupná ID modulů pro příznak `--modules`:
+
+- `bmm` — BMad Method Master
+- `bmb` — BMad Builder
+
+Zkontrolujte [registr BMad](https://github.com/bmad-code-org) pro dostupné externí moduly.
+
+## ID nástrojů/IDE
+
+Dostupná ID nástrojů pro příznak `--tools`:
+
+**Preferované:** `claude-code`, `cursor`
+
+Spusťte `npx bmad-method install` interaktivně jednou pro zobrazení aktuálního seznamu podporovaných nástrojů, nebo zkontrolujte [konfiguraci kódů platforem](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/cli/installers/lib/ide/platform-codes.yaml).
+
+## Režimy instalace
+
+| Režim | Popis | Příklad |
+|-------|-------|---------|
+| Plně neinteraktivní | Zadejte všechny příznaky pro přeskočení výzev | `npx bmad-method install --directory . --modules bmm --tools claude-code --yes` |
+| Polo-interaktivní | Zadejte některé příznaky; BMad se zeptá na zbytek | `npx bmad-method install --directory . --modules bmm` |
+| Pouze výchozí | Přijměte vše výchozí s `-y` | `npx bmad-method install --yes` |
+| Bez nástrojů | Přeskočte konfiguraci nástrojů/IDE | `npx bmad-method install --modules bmm --tools none` |
+
+## Příklady
+
+### Instalace v CI/CD pipeline
+
+```bash
+#!/bin/bash
+# install-bmad.sh
+
+npx bmad-method install \
+  --directory "${GITHUB_WORKSPACE}" \
+  --modules bmm \
+  --tools claude-code \
+  --user-name "CI Bot" \
+  --communication-language English \
+  --document-output-language English \
+  --output-folder _bmad-output \
+  --yes
+```
+
+### Aktualizace existující instalace
+
+```bash
+npx bmad-method install \
+  --directory ~/projects/myapp \
+  --action update \
+  --modules bmm,bmb,custom-module
+```
+
+### Rychlá aktualizace (zachování nastavení)
+
+```bash
+npx bmad-method install \
+  --directory ~/projects/myapp \
+  --action quick-update
+```
+
+### Instalace s vlastním obsahem
+
+```bash
+npx bmad-method install \
+  --directory ~/projects/myapp \
+  --modules bmm \
+  --custom-content ~/my-custom-module,~/another-module \
+  --tools claude-code
+```
+
+## Co získáte
+
+- Plně nakonfigurovaný adresář `_bmad/` ve vašem projektu
+- Agenty a workflow nakonfigurované pro vybrané moduly a nástroje
+- Složku `_bmad-output/` pro generované artefakty
+
+## Validace a zpracování chyb
+
+BMad validuje všechny zadané příznaky:
+
+- **Adresář** — Musí být platná cesta s oprávněním k zápisu
+- **Moduly** — Upozorní na neplatná ID modulů (ale nespadne)
+- **Nástroje** — Upozorní na neplatná ID nástrojů (ale nespadne)
+- **Vlastní obsah** — Každá cesta musí obsahovat platný soubor `module.yaml`
+- **Akce** — Musí být jedna z: `install`, `update`, `quick-update`
+
+Neplatné hodnoty buď:
+1. Zobrazí chybu a ukončí se (pro kritické možnosti jako adresář)
+2. Zobrazí varování a přeskočí (pro volitelné položky jako vlastní obsah)
+3. Přepnou na interaktivní výzvy (pro chybějící povinné hodnoty)
+
+:::tip[Osvědčené postupy]
+- Používejte absolutní cesty pro `--directory` pro zamezení nejednoznačnosti
+- Otestujte příznaky lokálně před použitím v CI/CD pipelines
+- Kombinujte s `-y` pro skutečně bezobslužné instalace
+- Použijte `--debug` pokud narazíte na problémy během instalace
+:::
+
+## Řešení problémů
+
+### Instalace selže s „Invalid directory“
+
+- Cesta k adresáři musí existovat (nebo musí existovat jeho nadřazený adresář)
+- Potřebujete oprávnění k zápisu
+- Cesta musí být absolutní nebo správně relativní k aktuálnímu adresáři
+
+### Modul nenalezen
+
+- Ověřte, že ID modulu je správné
+- Externí moduly musí být dostupné v registru
+
+### Neplatná cesta k vlastnímu obsahu
+
+Ujistěte se, že každá cesta k vlastnímu obsahu:
+- Ukazuje na adresář
+- Obsahuje soubor `module.yaml` v kořeni
+- Má pole `code` v `module.yaml`
+
+:::note[Stále jste uvízli?]
+Spusťte s `--debug` pro detailní výstup, zkuste interaktivní režim pro izolaci problému, nebo nahlaste na <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
+:::

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

@@ -0,0 +1,127 @@
+---
+title: "Správa kontextu projektu"
+description: Vytvoření a údržba project-context.md pro vedení AI agentů
+sidebar:
+  order: 8
+---
+
+Použijte soubor `project-context.md` k zajištění toho, aby AI agenti dodržovali technické preference a pravidla implementace vašeho projektu ve všech workflow. Aby byl vždy dostupný, můžete také přidat řádek `Important project context and conventions are located in [cesta k project context]/project-context.md` do souboru kontextu nebo pravidel vašeho nástroje (jako je `AGENTS.md`).
+
+:::note[Předpoklady]
+- BMad Method nainstalován
+- Znalost technologického stacku a konvencí vašeho projektu
+:::
+
+## Kdy to použít
+
+- Máte silné technické preference před začátkem architektury
+- Dokončili jste architekturu a chcete zachytit rozhodnutí pro implementaci
+- Pracujete na existující kódové bázi se zavedenými vzory
+- Všimnete si, že agenti dělají nekonzistentní rozhodnutí napříč stories
+
+## Krok 1: Vyberte přístup
+
+**Ruční vytvoření** — Nejlepší, když přesně víte, jaká pravidla chcete dokumentovat
+
+**Generování po architektuře** — Nejlepší pro zachycení rozhodnutí učiněných během solutioningu
+
+**Generování pro existující projekty** — Nejlepší pro objevení vzorů v existujících kódových bázích
+
+## Krok 2: Vytvořte soubor
+
+### Možnost A: Ruční vytvoření
+
+Vytvořte soubor na `_bmad-output/project-context.md`:
+
+```bash
+mkdir -p _bmad-output
+touch _bmad-output/project-context.md
+```
+
+Přidejte váš technologický stack a pravidla implementace:
+
+```markdown
+---
+project_name: 'MyProject'
+user_name: 'YourName'
+date: '2026-02-15'
+sections_completed: ['technology_stack', 'critical_rules']
+---
+
+# Project Context for AI Agents
+
+## Technology Stack & Versions
+
+- Node.js 20.x, TypeScript 5.3, React 18.2
+- State: Zustand
+- Testing: Vitest, Playwright
+- Styling: Tailwind CSS
+
+## Critical Implementation Rules
+
+**TypeScript:**
+- Strict mode enabled, no `any` types
+- Use `interface` for public APIs, `type` for unions
+
+**Code Organization:**
+- Components in `/src/components/` with co-located tests
+- API calls use `apiClient` singleton — never fetch directly
+
+**Testing:**
+- Unit tests focus on business logic
+- Integration tests use MSW for API mocking
+```
+
+### Možnost B: Generování po architektuře
+
+Spusťte workflow v novém chatu:
+
+```bash
+bmad-generate-project-context
+```
+
+Workflow skenuje váš dokument architektury a soubory projektu a generuje kontextový soubor zachycující učiněná rozhodnutí.
+
+### Možnost C: Generování pro existující projekty
+
+Pro existující projekty spusťte:
+
+```bash
+bmad-generate-project-context
+```
+
+Workflow analyzuje vaši kódovou bázi, identifikuje konvence a vygeneruje kontextový soubor, který můžete zkontrolovat a upřesnit.
+
+## Krok 3: Ověřte obsah
+
+Zkontrolujte vygenerovaný soubor a ujistěte se, že zachycuje:
+
+- Správné verze technologií
+- Vaše skutečné konvence (ne generické osvědčené postupy)
+- Pravidla, která předcházejí běžným chybám
+- Vzory specifické pro framework
+
+Ručně upravte pro doplnění chybějícího nebo odstranění nepřesností.
+
+## Co získáte
+
+Soubor `project-context.md`, který:
+
+- Zajistí, že všichni agenti dodržují stejné konvence
+- Zabrání nekonzistentním rozhodnutím napříč stories
+- Zachytí architektonická rozhodnutí pro implementaci
+- Slouží jako reference pro vzory a pravidla vašeho projektu
+
+## Tipy
+
+:::tip[Osvědčené postupy]
+- **Zaměřte se na neočividné** — Dokumentujte vzory, které agenti mohou přehlédnout (např. „Použijte JSDoc na každé veřejné třídě“), ne univerzální postupy jako „používejte smysluplné názvy proměnných.“
+- **Udržujte to stručné** — Tento soubor načítá každý implementační workflow. Dlouhé soubory plýtvají kontextem. Vylučte obsah, který platí pouze pro úzký rozsah nebo specifické stories.
+- **Aktualizujte dle potřeby** — Upravte ručně, když se vzory změní, nebo přegenerujte po významných změnách architektury.
+- Funguje pro projekty Quick Flow i plné metody BMad.
+:::
+
+## Další kroky
+
+- [**Vysvětlení kontextu projektu**](../explanation/project-context.md) — Zjistěte více o tom, jak to funguje
+- [**Mapa pracovních postupů**](../reference/workflow-map.md) — Podívejte se, které workflow načítají kontext projektu

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

@@ -0,0 +1,95 @@
+---
+title: "Rychlé opravy"
+description: Jak provádět rychlé opravy a ad-hoc změny
+sidebar:
+  order: 5
+---
+
+Použijte **Quick Dev** pro opravy chyb, refaktoringy nebo malé cílené změny, které nevyžadují plnou metodu BMad.
+
+## Kdy to použít
+
+- Opravy chyb s jasnou, známou příčinou
+- Malé refaktoringy (přejmenování, extrakce, restrukturalizace) omezené na několik souborů
+- Drobné úpravy funkcí nebo změny konfigurace
+- Aktualizace závislostí
+
+:::note[Předpoklady]
+- BMad Method nainstalován (`npx bmad-method install`)
+- AI-powered IDE (Claude Code, Cursor nebo podobné)
+:::
+
+## Kroky
+
+### 1. Začněte nový chat
+
+Otevřete **novou chatovací relaci** ve vašem AI IDE. Opětovné použití relace z předchozího workflow může způsobit konflikty kontextu.
+
+### 2. Zadejte svůj záměr
+
+Quick Dev přijímá volně formulovaný záměr — před, s nebo po vyvolání. Příklady:
+
+```text
+run quick-dev — Fix the login validation bug that allows empty passwords.
+```
+
+```text
+run quick-dev — fix https://github.com/org/repo/issues/42
+```
+
+```text
+run quick-dev — implement the intent in _bmad-output/implementation-artifacts/my-intent.md
+```
+
+```text
+I think the problem is in the auth middleware, it's not checking token expiry.
+Let me look at it... yeah, src/auth/middleware.ts line 47 skips
+the exp check entirely. run quick-dev
+```
+
+```text
+run quick-dev
+> What would you like to do?
+Refactor UserService to use async/await instead of callbacks.
+```
+
+Prostý text, cesty k souborům, GitHub issue URL, odkazy na bug tracker — cokoli, co LLM dokáže převést na konkrétní záměr.
+
+### 3. Odpovězte na otázky a schvalte
+
+Quick Dev se může zeptat na upřesňující otázky nebo prezentovat krátkou specifikaci ke schválení před implementací. Odpovězte na otázky a schvalte, až budete s plánem spokojeni.
+
+### 4. Zkontrolujte a pushněte
+
+Quick Dev implementuje změnu, zreviduje svou práci, opraví problémy a commitne lokálně. Když je hotov, otevře dotčené soubory ve vašem editoru.
+
+- Projděte diff a potvrďte, že změna odpovídá vašemu záměru
+- Pokud něco nevypadá dobře, řekněte agentovi, co opravit — může iterovat ve stejné relaci
+
+Až budete spokojeni, pushněte commit. Quick Dev nabídne push a vytvoření PR za vás.
+
+:::caution[Pokud se něco rozbije]
+Pokud pushnutá změna způsobí neočekávané problémy, použijte `git revert HEAD` pro čisté vrácení posledního commitu. Poté začněte nový chat a spusťte Quick Dev znovu s jiným přístupem.
+:::
+
+## Co získáte
+
+- Upravené zdrojové soubory s aplikovanou opravou nebo refaktoringem
+- Procházející testy (pokud má váš projekt testovací sadu)
+- Commit připravený k pushnutí s konvenční commit zprávou
+
+## Odložená práce
+
+Quick Dev udržuje každý běh zaměřený na jeden cíl. Pokud váš požadavek obsahuje více nezávislých cílů, nebo pokud revize odhalí předchozí problémy nesouvisející s vaší změnou, Quick Dev je odloží do souboru (`deferred-work.md` ve vašem adresáři implementačních artefaktů) místo toho, aby se pokusil vše řešit najednou.
+
+Zkontrolujte tento soubor po běhu — je to váš backlog věcí, ke kterým se vrátit. Každou odloženou položku lze zadat do nového běhu Quick Dev později.
+
+## Kdy přejít na formální plánování
+
+Zvažte použití plné metody BMad, když:
+
+- Změna ovlivňuje více systémů nebo vyžaduje koordinované aktualizace napříč mnoha soubory
+- Nejste si jisti rozsahem a potřebujete nejprve zjišťování požadavků
+- Potřebujete dokumentaci nebo architektonická rozhodnutí zaznamenaná pro tým
+
+Podívejte se na [Quick Dev](../explanation/quick-dev.md) pro více informací o tom, jak Quick Dev zapadá do metody BMad.

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

@@ -0,0 +1,78 @@
+---
+title: "Průvodce dělením dokumentů"
+description: Rozdělení velkých markdown souborů na menší organizované soubory pro lepší správu kontextu
+sidebar:
+  order: 9
+---
+
+Použijte nástroj `bmad-shard-doc`, pokud potřebujete rozdělit velké markdown soubory na menší, organizované soubory pro lepší správu kontextu.
+
+:::caution[Zastaralé]
+Toto se již nedoporučuje a brzy s aktualizovanými workflow a většinou hlavních LLM a nástrojů podporujících subprocesy to bude zbytečné.
+:::
+
+## Kdy to použít
+
+Použijte pouze pokud si všimnete, že váš zvolený nástroj / model nedokáže načíst a přečíst všechny dokumenty jako vstup, když je to potřeba.
+
+## Co je dělení dokumentů?
+
+Dělení dokumentů rozděluje velké markdown soubory na menší, organizované soubory na základě nadpisů úrovně 2 (`## Nadpis`).
+
+### Architektura
+
+```text
+Před dělením:
+_bmad-output/planning-artifacts/
+└── PRD.md (velký soubor o 50k tokenech)
+
+Po dělení:
+_bmad-output/planning-artifacts/
+└── prd/
+    ├── index.md                    # Obsah s popisy
+    ├── overview.md                 # Sekce 1
+    ├── user-requirements.md        # Sekce 2
+    ├── technical-requirements.md   # Sekce 3
+    └── ...                         # Další sekce
+```
+
+## Kroky
+
+### 1. Spusťte nástroj Shard-Doc
+
+```bash
+/bmad-shard-doc
+```
+
+### 2. Následujte interaktivní proces
+
+```text
+Agent: Which document would you like to shard?
+User: docs/PRD.md
+
+Agent: Default destination: docs/prd/
+       Accept default? [y/n]
+User: y
+
+Agent: Sharding PRD.md...
+       ✓ Created 12 section files
+       ✓ Generated index.md
+       ✓ Complete!
+```
+
+## Jak funguje vyhledávání workflow
+
+BMad workflow používají **duální systém vyhledávání**:
+
+1. **Nejprve zkusí celý dokument** — Hledá `document-name.md`
+2. **Zkontroluje rozdělenou verzi** — Hledá `document-name/index.md`
+3. **Pravidlo priority** — Celý dokument má přednost, pokud existují oba — odstraňte celý dokument, pokud chcete použít rozdělenou verzi
+
+## Podpora workflow
+
+Všechny BMM workflow podporují oba formáty:
+
+- Celé dokumenty
+- Rozdělené dokumenty
+- Automatická detekce
+- Transparentní pro uživatele

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

@@ -0,0 +1,100 @@
+---
+title: "Jak upgradovat na v6"
+description: Migrace z BMad v4 na v6
+sidebar:
+  order: 3
+---
+
+Použijte instalátor BMad pro upgrade z v4 na v6, který zahrnuje automatickou detekci starších instalací a asistenci při migraci.
+
+## Kdy to použít
+
+- Máte nainstalovaný BMad v4 (složka `.bmad-method`)
+- Chcete migrovat na novou architekturu v6
+- Máte existující plánovací artefakty k zachování
+
+:::note[Předpoklady]
+- Node.js 20+
+- Existující instalace BMad v4
+:::
+
+## Kroky
+
+### 1. Spusťte instalátor
+
+Postupujte podle [instrukcí instalátoru](./install-bmad.md).
+
+### 2. Zpracování starší instalace
+
+Když je detekována v4, můžete:
+
+- Nechat instalátor zálohovat a odstranit `.bmad-method`
+- Ukončit a zpracovat vyčištění ručně
+
+Pokud jste pojmenovali složku bmad method jinak, musíte ji odstranit ručně.
+
+### 3. Vyčištění IDE skills
+
+Ručně odstraňte starší v4 IDE příkazy/skills — například pokud máte Claude Code, hledejte vnořené složky začínající na bmad a odstraňte je:
+
+- `.claude/commands/`
+
+Nové v6 skills se instalují do:
+
+- `.claude/skills/`
+
+### 4. Migrace plánovacích artefaktů
+
+**Pokud máte plánovací dokumenty (Brief/PRD/UX/Architektura):**
+
+Přesuňte je do `_bmad-output/planning-artifacts/` s popisnými názvy:
+
+- Zahrňte `PRD` v názvu souboru pro PRD dokumenty
+- Zahrňte `brief`, `architecture` nebo `ux-design` odpovídajícím způsobem
+- Rozdělené dokumenty mohou být v pojmenovaných podsložkách
+
+**Pokud jste uprostřed plánování:** Zvažte restart s v6 workflow. Použijte existující dokumenty jako vstupy — nové workflow s progresivním objevováním, webovým vyhledáváním a plan mode IDE produkují lepší výsledky.
+
+### 5. Migrace probíhajícího vývoje
+
+Pokud máte vytvořené nebo implementované stories:
+
+1. Dokončete instalaci v6
+2. Umístěte `epics.md` nebo `epics/epic*.md` do `_bmad-output/planning-artifacts/`
+3. Spusťte workflow `bmad-sprint-planning` Scrum Mastera
+4. Řekněte SM, které epicy/stories jsou již dokončené
+
+## Co získáte
+
+**Sjednocená struktura v6:**
+
+```text
+váš-projekt/
+├── _bmad/               # Jedna instalační složka
+│   ├── _config/         # Vaše přizpůsobení
+│   │   └── agents/      # Soubory přizpůsobení agentů
+│   ├── core/            # Univerzální základní framework
+│   ├── bmm/             # Modul BMad Method
+│   ├── bmb/             # BMad Builder
+│   └── cis/             # Creative Intelligence Suite
+└── _bmad-output/        # Výstupní složka (v4 to byla složka dokumentů)
+```
+
+## Migrace modulů
+
+| Modul v4                      | Stav v6                            |
+| ----------------------------- | ---------------------------------- |
+| `.bmad-2d-phaser-game-dev`    | Integrován do modulu BMGD          |
+| `.bmad-2d-unity-game-dev`     | Integrován do modulu BMGD          |
+| `.bmad-godot-game-dev`        | Integrován do modulu BMGD          |
+| `.bmad-infrastructure-devops` | Zastaralý — nový DevOps agent brzy |
+| `.bmad-creative-writing`      | Neadaptován — nový v6 modul brzy   |
+
+## Klíčové změny
+
+| Koncept         | v4                                   | v6                                     |
+| --------------- | ------------------------------------ | -------------------------------------- |
+| **Core**        | `_bmad-core` byl vlastně BMad Method | `_bmad/core/` je univerzální framework |
+| **Method**      | `_bmad-method`                       | `_bmad/bmm/`                           |
+| **Konfigurace** | Přímá editace souborů                | `config.yaml` pro každý modul          |
+| **Dokumenty**   | Vyžadované nastavení shardů          | Plně flexibilní, auto-skenování        |

docs/cs/index.md

@@ -0,0 +1,60 @@
+---
+title: Vítejte v metodě BMad
+description: Framework pro vývoj řízený umělou inteligencí se specializovanými agenty, řízenými pracovními postupy a inteligentním plánováním
+---
+
+Metoda BMad (**B**uild **M**ore **A**rchitect **D**reams) je framework pro vývoj řízený umělou inteligencí v rámci ekosystému BMad Method, který vám pomáhá vytvářet software celým procesem od nápadu a plánování až po agentní implementaci. Poskytuje specializované AI agenty, řízené pracovní postupy a inteligentní plánování, které se přizpůsobí složitosti vašeho projektu, ať už opravujete chybu nebo budujete podnikovou platformu.
+
+Pokud jste zvyklí pracovat s AI asistenty pro kódování jako Claude, Cursor nebo GitHub Copilot, jste připraveni začít.
+
+:::note[🚀 V6 je tady a teprve začínáme!]
+Architektura Skills, BMad Builder v1, automatizace Dev Loop a mnoho dalšího ve vývoji. **[Podívejte se na Plán rozvoje →](./roadmap)**
+:::
+
+## Jste tu nově? Začněte tutoriálem
+
+Nejrychlejší způsob, jak pochopit BMad, je vyzkoušet si ho.
+
+- **[Začínáme s BMad](./tutorials/getting-started.md)** — Instalace a pochopení fungování BMad
+- **[Mapa pracovních postupů](./reference/workflow-map.md)** — Vizuální přehled fází BMM, pracovních postupů a správy kontextu
+
+:::tip[Chcete se rovnou ponořit?]
+Nainstalujte BMad a použijte skill `bmad-help` — provede vás vším na základě vašeho projektu a nainstalovaných modulů.
+:::
+
+## Jak používat tuto dokumentaci
+
+Tato dokumentace je organizována do čtyř sekcí podle toho, co chcete dělat:
+
+| Sekce               | Účel                                                                                                               |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| **Tutoriály**        | Orientované na učení. Průvodci krok za krokem, kteří vás provedou tvorbou něčeho. Začněte zde, pokud jste noví.    |
+| **Praktické návody** | Orientované na úkoly. Praktičtí průvodci pro řešení konkrétních problémů. „Jak přizpůsobím agenta?“ najdete zde.  |
+| **Vysvětlení**       | Orientované na pochopení. Hluboké ponory do konceptů a architektury. Čtěte, když chcete vědět *proč*.             |
+| **Reference**        | Orientované na informace. Technické specifikace agentů, pracovních postupů a konfigurace.                          |
+
+## Rozšíření a přizpůsobení
+
+Chcete rozšířit BMad o vlastní agenty, pracovní postupy nebo moduly? **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** poskytuje framework a nástroje pro vytváření vlastních rozšíření, ať už přidáváte nové schopnosti do BMad nebo budujete zcela nové moduly od základů.
+
+## Co budete potřebovat
+
+BMad funguje s jakýmkoli AI asistentem pro kódování, který podporuje vlastní systémové prompty nebo kontextové soubory projektu. Oblíbené možnosti zahrnují:
+
+- **[Claude Code](https://code.claude.com)** — CLI nástroj od Anthropic (doporučený)
+- **[Cursor](https://cursor.sh)** — AI-first editor kódu
+- **[Codex CLI](https://github.com/openai/codex)** — Terminálový kódovací agent od OpenAI
+
+Měli byste být obeznámeni se základními koncepty vývoje softwaru jako správa verzí, struktura projektu a agilní pracovní postupy. Žádná předchozí zkušenost se systémy agentů ve stylu BMad není vyžadována — právě od toho je tato dokumentace.
+
+## Připojte se ke komunitě
+
+Získejte pomoc, sdílejte co budujete, nebo přispějte do BMad:
+
+- **[Discord](https://discord.gg/gk8jAdXWmj)** — Chatujte s ostatními uživateli BMad, pokládejte otázky, sdílejte nápady
+- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Zdrojový kód, issues a příspěvky
+- **[YouTube](https://www.youtube.com/@BMadCode)** — Video tutoriály a návody
+
+## Další krok
+
+Jste připraveni se ponořit? **[Začněte s BMad](./tutorials/getting-started.md)** a vytvořte svůj první projekt.

docs/cs/reference/agents.md

@@ -0,0 +1,55 @@
+---
+title: Agenti
+description: Výchozí BMM agenti s jejich skill ID, spouštěči nabídky a primárními workflow
+sidebar:
+  order: 2
+---
+
+## Výchozí agenti
+
+Tato stránka uvádí výchozí BMM (Agile suite) agenty, kteří se instalují s BMad Method, společně s jejich skill ID, spouštěči nabídky a primárními workflow. Každý agent se vyvolává jako skill.
+
+## Poznámky
+
+- Každý agent je dostupný jako skill, generovaný instalátorem. Skill ID (např. `bmad-dev`) se používá k vyvolání agenta.
+- Spouštěče jsou krátké kódy nabídky (např. `CP`) a fuzzy shody zobrazené v nabídce každého agenta.
+- Generování QA testů zajišťuje workflow skill `bmad-qa-generate-e2e-tests`, dostupný přes Developer agenta. Plný Test Architect (TEA) žije ve vlastním modulu.
+
+| Agent                       | Skill ID             | Spouštěče                                    | Primární workflow                                                                                   |
+| --------------------------- | -------------------- | -------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| Analyst (Mary)              | `bmad-analyst`       | `BP`, `RS`, `CB`, `WB`, `DP`                 | Brainstorm projektu, výzkum, tvorba briefu, PRFAQ výzva, dokumentace projektu                       |
+| Product Manager (John)      | `bmad-pm`            | `CP`, `VP`, `EP`, `CE`, `IR`, `CC`           | Tvorba/validace/editace PRD, tvorba epiců a stories, připravenost implementace, korekce kurzu       |
+| Architect (Winston)         | `bmad-architect`     | `CA`, `IR`                                    | Tvorba architektury, připravenost implementace                                                      |
+| Developer (Amelia)          | `bmad-agent-dev`     | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER`     | Dev story, Quick Dev, generování QA testů, revize kódu, plánování sprintu, tvorba story, retrospektiva epicu |
+| UX Designer (Sally)         | `bmad-ux-designer`   | `CU`                                          | Tvorba UX designu                                                                                   |
+| Technical Writer (Paige)    | `bmad-tech-writer`   | `DP`, `WD`, `US`, `MG`, `VD`, `EC`           | Dokumentace projektu, psaní dokumentu, aktualizace standardů, generování Mermaid, validace dok., vysvětlení konceptu |
+
+## Typy spouštěčů
+
+Spouštěče nabídky agentů používají dva různé typy vyvolání. Znalost typu spouštěče vám pomůže poskytnout správný vstup.
+
+### Workflow spouštěče (bez argumentů)
+
+Většina spouštěčů načítá strukturovaný soubor workflow. Zadejte kód spouštěče a agent zahájí workflow a vyzve vás k zadání vstupu v každém kroku.
+
+Příklady: `CP` (tvorba PRD), `DS` (Dev story), `CA` (tvorba architektury), `QD` (Quick Dev)
+
+### Konverzační spouštěče (vyžadují argumenty)
+
+Některé spouštěče zahajují volnou konverzaci místo strukturovaného workflow. Tyto očekávají, že popíšete, co potřebujete, společně s kódem spouštěče.
+
+| Agent | Spouštěč | Co poskytnout |
+| --- | --- | --- |
+| Technical Writer (Paige) | `WD` | Popis dokumentu k napsání |
+| Technical Writer (Paige) | `US` | Preference nebo konvence k přidání do standardů |
+| Technical Writer (Paige) | `MG` | Popis diagramu a typ (sekvence, vývojový diagram atd.) |
+| Technical Writer (Paige) | `VD` | Dokument k validaci a oblasti zaměření |
+| Technical Writer (Paige) | `EC` | Název konceptu k vysvětlení |
+
+**Příklad:**
+
+```text
+WD Write a deployment guide for our Docker setup
+MG Create a sequence diagram showing the auth flow
+EC Explain how the module system works
+```

docs/cs/reference/commands.md

@@ -0,0 +1,135 @@
+---
+title: Skills
+description: Reference BMad skills — co to je, jak fungují a kde je najít.
+sidebar:
+  order: 3
+---
+
+Skills jsou předpřipravené prompty, které načítají agenty, spouštějí workflow nebo provádějí úkoly ve vašem IDE. Instalátor BMad je generuje z vašich nainstalovaných modulů při instalaci. Pokud později přidáte, odeberete nebo změníte moduly, přeinstalujte pro synchronizaci skills (viz [Řešení problémů](#řešení-problémů)).
+
+## Skills vs. spouštěče nabídky agentů
+
+BMad nabízí dva způsoby zahájení práce a slouží k různým účelům.
+
+| Mechanismus | Jak se vyvolává | Co se stane |
+| --- | --- | --- |
+| **Skill** | Zadejte název skillu (např. `bmad-help`) ve vašem IDE | Přímo načte agenta, spustí workflow nebo provede úkol |
+| **Spouštěč nabídky agenta** | Nejprve načtěte agenta, pak zadejte krátký kód (např. `DS`) | Agent interpretuje kód a spustí odpovídající workflow, přičemž zůstává v charakteru |
+
+Spouštěče nabídky agentů vyžadují aktivní relaci agenta. Používejte skills, když víte, který workflow chcete. Používejte spouštěče, když již pracujete s agentem a chcete přepnout úkol bez opuštění konverzace.
+
+## Jak se skills generují
+
+Když spustíte `npx bmad-method install`, instalátor čte manifesty každého vybraného modulu a zapíše jeden skill na agenta, workflow, úkol a nástroj. Každý skill je adresář obsahující soubor `SKILL.md`, který instruuje AI k načtení odpovídajícího zdrojového souboru a následování jeho instrukcí.
+
+Instalátor používá šablony pro každý typ skillu:
+
+| Typ skillu | Co generovaný soubor dělá |
+| --- | --- |
+| **Spouštěč agenta** | Načte soubor persony agenta, aktivuje jeho nabídku a zůstává v charakteru |
+| **Workflow skill** | Načte konfiguraci workflow a následuje jeho kroky |
+| **Task skill** | Načte samostatný soubor úkolu a následuje jeho instrukce |
+| **Tool skill** | Načte samostatný soubor nástroje a následuje jeho instrukce |
+
+:::note[Opětovné spuštění instalátoru]
+Pokud přidáte nebo odeberete moduly, spusťte instalátor znovu. Přegeneruje všechny soubory skills tak, aby odpovídaly vašemu aktuálnímu výběru modulů.
+:::
+
+## Kde žijí soubory skills
+
+Instalátor zapisuje soubory skills do adresáře specifického pro IDE uvnitř vašeho projektu. Přesná cesta závisí na IDE, které jste vybrali během instalace.
+
+| IDE / CLI | Adresář skills |
+| --- | --- |
+| Claude Code | `.claude/skills/` |
+| Cursor | `.cursor/skills/` |
+| Windsurf | `.windsurf/skills/` |
+| Další IDE | Viz výstup instalátoru pro cílovou cestu |
+
+Každý skill je adresář obsahující soubor `SKILL.md`. Například instalace Claude Code vypadá takto:
+
+```text
+.claude/skills/
+├── bmad-help/
+│   └── SKILL.md
+├── bmad-create-prd/
+│   └── SKILL.md
+├── bmad-agent-dev/
+│   └── SKILL.md
+└── ...
+```
+
+Název adresáře určuje název skillu ve vašem IDE. Například adresář `bmad-agent-dev/` registruje skill `bmad-agent-dev`.
+
+## Jak objevit vaše skills
+
+Zadejte název skillu ve vašem IDE pro jeho vyvolání. Některé platformy vyžadují povolení skills v nastavení, než se zobrazí.
+
+Spusťte `bmad-help` pro kontextové poradenství k dalšímu kroku.
+
+:::tip[Rychlé objevování]
+Generované adresáře skills ve vašem projektu jsou kanonický seznam. Otevřete je v prohlížeči souborů, abyste viděli každý skill s jeho popisem.
+:::
+
+## Kategorie skills
+
+### Agentní skills
+
+Agentní skills načítají specializovanou AI personu s definovanou rolí, komunikačním stylem a nabídkou workflow. Po načtení agent zůstává v charakteru a reaguje na spouštěče nabídky.
+
+| Příklad skillu | Agent | Role |
+| --- | --- | --- |
+| `bmad-agent-dev` | Amelia (Developer) | Implementuje stories s přísným dodržováním specifikací |
+| `bmad-pm` | John (Product Manager) | Vytváří a validuje PRD |
+| `bmad-architect` | Winston (Architect) | Navrhuje systémovou architekturu |
+
+Viz [Agenti](./agents.md) pro úplný seznam výchozích agentů a jejich spouštěčů.
+
+### Workflow skills
+
+Workflow skills spouštějí strukturovaný, vícekrokový proces bez předchozího načtení persony agenta. Načtou konfiguraci workflow a následují jeho kroky.
+
+| Příklad skillu | Účel |
+| --- | --- |
+| `bmad-product-brief` | Vytvoření product briefu — řízené discovery, když je váš koncept jasný |
+| `bmad-prfaq` | Working Backwards PRFAQ výzva pro zátěžový test vašeho produktového konceptu |
+| `bmad-create-prd` | Vytvoření dokumentu požadavků (PRD) |
+| `bmad-create-architecture` | Návrh systémové architektury |
+| `bmad-create-epics-and-stories` | Vytvoření epiců a stories |
+| `bmad-dev-story` | Implementace story |
+| `bmad-code-review` | Spuštění revize kódu |
+| `bmad-quick-dev` | Sjednocený quick flow — vyjasnění záměru, plán, implementace, revize, prezentace |
+
+Viz [Mapa pracovních postupů](./workflow-map.md) pro kompletní referenci workflow organizovanou podle fází.
+
+### Task a tool skills
+
+Tasks a tools jsou samostatné operace, které nevyžadují kontext agenta nebo workflow.
+
+**BMad-Help: Váš inteligentní průvodce**
+
+`bmad-help` je vaše primární rozhraní pro objevení, co dělat dál. Zkoumá váš projekt, rozumí dotazům v přirozeném jazyce a doporučuje další povinný nebo volitelný krok na základě nainstalovaných modulů.
+
+:::note[Příklad]
+```
+bmad-help
+bmad-help I have a SaaS idea and know all the features. Where do I start?
+bmad-help What are my options for UX design?
+```
+:::
+
+**Další základní tasks a tools**
+
+Základní modul zahrnuje 11 vestavěných nástrojů — revize, komprese, brainstorming, správa dokumentů a další. Viz [Základní nástroje](./core-tools.md) pro kompletní referenci.
+
+## Konvence pojmenování
+
+Všechny skills používají prefix `bmad-` následovaný popisným názvem (např. `bmad-dev`, `bmad-create-prd`, `bmad-help`). Viz [Moduly](./modules.md) pro dostupné moduly.
+
+## Řešení problémů
+
+**Skills se nezobrazují po instalaci.** Některé platformy vyžadují explicitní povolení skills v nastavení. Zkontrolujte dokumentaci vašeho IDE nebo se zeptejte AI asistenta, jak skills povolit. Může být také nutné restartovat IDE nebo znovu načíst okno.
+
+**Očekávané skills chybí.** Instalátor generuje skills pouze pro moduly, které jste vybrali. Spusťte `npx bmad-method install` znovu a ověřte výběr modulů. Zkontrolujte, že soubory skills existují v očekávaném adresáři.
+
+**Skills z odebraného modulu se stále zobrazují.** Instalátor automaticky nemaže staré soubory skills. Odstraňte zastaralé adresáře z adresáře skills vašeho IDE, nebo smažte celý adresář skills a přeinstalujte pro čistou sadu.

docs/cs/reference/core-tools.md

@@ -0,0 +1,292 @@
+---
+title: Základní nástroje
+description: Reference všech vestavěných úkolů a workflow dostupných v každé instalaci BMad bez dalších modulů.
+sidebar:
+  order: 2
+---
+
+Každá instalace BMad zahrnuje sadu základních skills, které lze použít v kombinaci s čímkoli — samostatné úkoly a workflow, které fungují napříč všemi projekty, všemi moduly a všemi fázemi. Ty jsou vždy dostupné bez ohledu na to, které volitelné moduly nainstalujete.
+
+:::tip[Rychlá cesta]
+Spusťte jakýkoli základní nástroj zadáním jeho názvu skillu (např. `bmad-help`) ve vašem IDE. Nevyžaduje relaci agenta.
+:::
+
+## Přehled
+
+| Nástroj | Typ | Účel |
+| --- | --- | --- |
+| [`bmad-help`](#bmad-help) | Task | Kontextové poradenství, co dělat dál |
+| [`bmad-brainstorming`](#bmad-brainstorming) | Workflow | Facilitace interaktivních brainstormingových sezení |
+| [`bmad-party-mode`](#bmad-party-mode) | Workflow | Orchestrace skupinových diskuzí více agentů |
+| [`bmad-distillator`](#bmad-distillator) | Task | Bezeztrátová LLM-optimalizovaná komprese dokumentů |
+| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation) | Task | Iterativní zdokonalování LLM výstupu |
+| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Task | Cynická revize hledající chybějící a chybné |
+| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter) | Task | Vyčerpávající analýza větvících cest pro neošetřené hraniční případy |
+| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose) | Task | Klinická jazyková korektura pro komunikační srozumitelnost |
+| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Task | Strukturální editace — škrty, sloučení a reorganizace |
+| [`bmad-shard-doc`](#bmad-shard-doc) | Task | Rozdělení velkých markdown souborů do organizovaných sekcí |
+| [`bmad-index-docs`](#bmad-index-docs) | Task | Generování nebo aktualizace indexu dokumentů ve složce |
+
+## bmad-help
+
+**Váš inteligentní průvodce tím, co přijde dál.** — Zkoumá stav vašeho projektu, detekuje, co bylo uděláno, a doporučuje další povinný nebo volitelný krok.
+
+**Použijte když:**
+
+- Dokončili jste workflow a chcete vědět, co dál
+- Jste noví v BMad a potřebujete orientaci
+- Jste uvízlí a chcete kontextovou radu
+- Nainstalovali jste nové moduly a chcete vidět, co je dostupné
+
+**Jak to funguje:**
+
+1. Skenuje projekt pro existující artefakty (PRD, architektura, stories atd.)
+2. Detekuje nainstalované moduly a dostupné workflow
+3. Doporučuje další kroky v pořadí priority — nejprve povinné, pak volitelné
+4. Prezentuje každé doporučení s příkazem skillu a stručným popisem
+
+**Vstup:** Volitelný dotaz v přirozeném jazyce (např. `bmad-help I have a SaaS idea, where do I start?`)
+
+**Výstup:** Prioritizovaný seznam doporučených dalších kroků s příkazy skills
+
+## bmad-brainstorming
+
+**Generování různorodých nápadů prostřednictvím interaktivních kreativních technik.** — Facilitované brainstormingové sezení, které načítá osvědčené ideační metody z knihovny technik a vede vás k 100+ nápadům před organizací.
+
+**Použijte když:**
+
+- Začínáte nový projekt a potřebujete prozkoumat problémový prostor
+- Jste uvízlí s generováním nápadů a potřebujete strukturovanou kreativitu
+- Chcete použít osvědčené ideační frameworky (SCAMPER, reverzní brainstorming atd.)
+
+**Jak to funguje:**
+
+1. Nastaví brainstormingové sezení s vaším tématem
+2. Načte kreativní techniky z knihovny metod
+3. Provede vás technikou za technikou, generuje nápady
+4. Aplikuje anti-bias protokol — mění kreativní doménu každých 10 nápadů
+5. Produkuje append-only dokument sezení se všemi nápady organizovanými podle techniky
+
+**Vstup:** Téma brainstormingu nebo formulace problému, volitelný kontextový soubor
+
+**Výstup:** `brainstorming-session-{date}.md` se všemi generovanými nápady
+
+:::note[Cíl množství]
+Kouzlo se děje v nápadech 50–100. Workflow povzbuzuje generování 100+ nápadů před organizací.
+:::
+
+## bmad-party-mode
+
+**Orchestrace skupinových diskuzí více agentů.** — Načte všechny nainstalované BMad agenty a facilituje přirozenou konverzaci, kde každý agent přispívá svou unikátní odborností a osobností.
+
+**Použijte když:**
+
+- Potřebujete více expertních perspektiv na rozhodnutí
+- Chcete, aby agenti zpochybňovali předpoklady ostatních
+- Zkoumáte složité téma překračující více domén
+
+**Jak to funguje:**
+
+1. Načte manifest agentů se všemi nainstalovanými osobnostmi
+2. Analyzuje vaše téma a vybere 2–3 nejrelevantnější agenty
+3. Agenti se střídají v přispívání, s přirozenou kříženou diskuzí a nesouhlasy
+4. Rotuje účast agentů pro zajištění různorodých perspektiv
+5. Ukončete pomocí `goodbye`, `end party` nebo `quit`
+
+**Vstup:** Diskuzní téma nebo otázka, s volitelnou specifikací person
+
+**Výstup:** Real-time multi-agentní konverzace s udržovanými osobnostmi agentů
+
+## bmad-distillator
+
+**Bezeztrátová LLM-optimalizovaná komprese zdrojových dokumentů.** — Produkuje husté, tokenově efektivní destiláty, které zachovávají všechny informace pro následné LLM zpracování. Ověřitelné prostřednictvím round-trip rekonstrukce.
+
+**Použijte když:**
+
+- Dokument je příliš velký pro kontextové okno LLM
+- Potřebujete tokenově efektivní verze výzkumů, specifikací nebo plánovacích artefaktů
+- Chcete ověřit, že během komprese nebyly ztraceny žádné informace
+
+**Jak to funguje:**
+
+1. **Analýza** — Čte zdrojové dokumenty, identifikuje hustotu informací a strukturu
+2. **Komprese** — Převádí prózu na hustý odrážkový formát, odstraňuje dekorativní formátování
+3. **Ověření** — Kontroluje úplnost pro zajištění zachování všech informací
+4. **Validace** (volitelné) — Round-trip rekonstrukční test dokazuje bezeztrátovou kompresi
+
+**Vstup:**
+
+- `source_documents` (povinné) — Cesty k souborům, složkám nebo glob vzory
+- `downstream_consumer` (volitelné) — Co to konzumuje (např. „tvorba PRD“)
+- `token_budget` (volitelné) — Přibližná cílová velikost
+- `--validate` (příznak) — Spuštění round-trip rekonstrukčního testu
+
+**Výstup:** Destilátové markdown soubory s reportem kompresního poměru (např. „3.2:1“)
+
+## bmad-advanced-elicitation
+
+**Iterativní zdokonalování LLM výstupu metodami elicitace.** — Vybírá z knihovny elicitačních technik pro systematické zlepšování obsahu více průchody.
+
+**Použijte když:**
+
+- LLM výstup působí povrchně nebo genericky
+- Chcete prozkoumat téma z více analytických úhlů
+- Zdokonalujete kritický dokument a chcete hlubší myšlení
+
+**Jak to funguje:**
+
+1. Načte registr metod s 5+ elicitačními technikami
+2. Vybere 5 nejlépe odpovídajících metod podle typu a složitosti obsahu
+3. Prezentuje interaktivní nabídku — vyberte metodu, zamíchejte nebo zobrazte vše
+4. Aplikuje vybranou metodu k vylepšení obsahu
+5. Znovu prezentuje možnosti pro iterativní zlepšení, dokud nevyberete „Pokračovat“
+
+**Vstup:** Sekce obsahu k vylepšení
+
+**Výstup:** Vylepšená verze obsahu s aplikovanými zlepšeními
+
+## bmad-review-adversarial-general
+
+**Cynická revize, která předpokládá existenci problémů a hledá je.** — Zaujme perspektivu skeptického, otráveného recenzenta s nulovou tolerancí pro nedbalou práci. Hledá, co chybí, ne jen co je špatně.
+
+**Použijte když:**
+
+- Potřebujete zajištění kvality před finalizací výstupu
+- Chcete zátěžově otestovat specifikaci, story nebo dokument
+- Chcete najít mezery v pokrytí, které optimistické revize přehlédnou
+
+**Jak to funguje:**
+
+1. Čte obsah s cynickou, kritickou perspektivou
+2. Identifikuje problémy v úplnosti, správnosti a kvalitě
+3. Specificky hledá, co chybí — ne jen co je přítomné a špatné
+4. Musí najít minimálně 10 problémů nebo analyzuje hlouběji
+
+**Vstup:**
+
+- `content` (povinné) — Diff, specifikace, story, dokument nebo jakýkoli artefakt
+- `also_consider` (volitelné) — Další oblasti k zvážení
+
+**Výstup:** Markdown seznam 10+ nálezů s popisy
+
+## bmad-review-edge-case-hunter
+
+**Procházení každé větvící cesty a hraničních podmínek, hlášení pouze neošetřených případů.** — Čistě metodologický přístup trasování cest, který mechanicky odvozuje třídy hraničních případů.
+
+**Použijte když:**
+
+- Chcete vyčerpávající pokrytí hraničních případů pro kód nebo logiku
+- Potřebujete doplněk k adversariální revizi (jiná metodologie, jiné nálezy)
+- Revidujete diff nebo funkci pro hraniční podmínky
+
+**Jak to funguje:**
+
+1. Enumeruje všechny větvící cesty v obsahu
+2. Mechanicky odvozuje třídy případů: chybějící else/default, nestřežené vstupy, off-by-one, přetečení aritmetiky, implicitní typová koerce, race conditions, mezery v timeoutech
+3. Testuje každou cestu proti existujícím ochranám
+4. Hlásí pouze neošetřené cesty — tiše zahazuje ošetřené
+
+**Vstup:**
+
+- `content` (povinné) — Diff, celý soubor nebo funkce
+- `also_consider` (volitelné) — Další oblasti k zvážení
+
+**Výstup:** JSON pole nálezů, každý s `location`, `trigger_condition`, `guard_snippet` a `potential_consequence`
+
+:::note[Komplementární revize]
+Spusťte obě `bmad-review-adversarial-general` a `bmad-review-edge-case-hunter` společně pro ortogonální pokrytí. Adversariální revize zachytí problémy kvality a úplnosti; hunter hraničních případů zachytí neošetřené cesty.
+:::
+
+## bmad-editorial-review-prose
+
+**Klinická jazyková korektura zaměřená na srozumitelnost komunikace.** — Reviduje text pro problémy bránící porozumění. Aplikuje baseline Microsoft Writing Style Guide. Zachovává autorský hlas.
+
+**Použijte když:**
+
+- Napsali jste dokument a chcete vylepšit psaní
+- Potřebujete zajistit srozumitelnost pro konkrétní publikum
+- Chcete komunikační opravy bez změn stylistických preferencí
+
+**Jak to funguje:**
+
+1. Čte obsah, přeskakuje bloky kódu a frontmatter
+2. Identifikuje komunikační problémy (ne stylistické preference)
+3. Deduplikuje stejné problémy napříč více lokacemi
+4. Produkuje třísloupcovou tabulku oprav
+
+**Vstup:**
+
+- `content` (povinné) — Markdown, prostý text nebo XML
+- `style_guide` (volitelné) — Projektově specifický průvodce stylem
+- `reader_type` (volitelné) — `humans` (výchozí) pro srozumitelnost/plynulost, nebo `llm` pro přesnost/konzistenci
+
+**Výstup:** Třísloupcová markdown tabulka: Původní text | Revidovaný text | Změny
+
+## bmad-editorial-review-structure
+
+**Strukturální editace — navrhuje škrty, sloučení, přesuny a zhuštění.** — Reviduje organizaci dokumentu a navrhuje substantivní změny pro zlepšení srozumitelnosti a toku před jazykovou korekcí.
+
+**Použijte když:**
+
+- Dokument byl vytvořen z více subprocesů a potřebuje strukturální koherenci
+- Chcete zkrátit dokument při zachování porozumění
+- Potřebujete identifikovat porušení rozsahu nebo pohřbené kritické informace
+
+**Jak to funguje:**
+
+1. Analyzuje dokument proti 5 strukturním modelům (Tutorial, Reference, Explanation, Prompt, Strategic)
+2. Identifikuje redundance, porušení rozsahu a pohřbené informace
+3. Produkuje prioritizovaná doporučení: CUT, MERGE, MOVE, CONDENSE, QUESTION, PRESERVE
+4. Odhaduje celkovou redukci ve slovech a procentech
+
+**Vstup:**
+
+- `content` (povinné) — Dokument k revizi
+- `purpose` (volitelné) — Zamýšlený účel (např. „quickstart tutoriál“)
+- `target_audience` (volitelné) — Kdo to čte
+- `reader_type` (volitelné) — `humans` nebo `llm`
+- `length_target` (volitelné) — Cílová redukce (např. „o 30 % kratší“)
+
+**Výstup:** Shrnutí dokumentu, prioritizovaný seznam doporučení a odhadovaná redukce
+
+## bmad-shard-doc
+
+**Rozdělení velkých markdown souborů do organizovaných souborů sekcí.** — Používá nadpisy úrovně 2 jako body dělení k vytvoření složky samostatných souborů sekcí s indexem.
+
+**Použijte když:**
+
+- Markdown dokument narostl na nezvládnutelnou velikost (500+ řádků)
+- Chcete rozložit monolitický dokument na navigovatelné sekce
+- Potřebujete samostatné soubory pro paralelní editaci nebo správu LLM kontextu
+
+**Jak to funguje:**
+
+1. Validuje, že zdrojový soubor existuje a je markdown
+2. Dělí na nadpisech úrovně 2 (`##`) do číslovaných souborů sekcí
+3. Vytváří `index.md` s manifestem sekcí a odkazy
+4. Vyzve vás ke smazání, archivaci nebo zachování originálu
+
+**Vstup:** Cesta ke zdrojovému markdown souboru, volitelná cílová složka
+
+**Výstup:** Složka s `index.md` a `01-{sekce}.md`, `02-{sekce}.md` atd.
+
+## bmad-index-docs
+
+**Generování nebo aktualizace indexu všech dokumentů ve složce.** — Skenuje adresář, čte každý soubor pro pochopení jeho účelu a produkuje organizovaný `index.md` s odkazy a popisy.
+
+**Použijte když:**
+
+- Potřebujete lehký index pro rychlé LLM skenování dostupných dokumentů
+- Složka dokumentace narostla a potřebuje organizovaný obsah
+- Chcete automaticky generovaný přehled, který zůstává aktuální
+
+**Jak to funguje:**
+
+1. Skenuje cílový adresář pro všechny neskryté soubory
+2. Čte každý soubor pro pochopení jeho skutečného účelu
+3. Seskupuje soubory podle typu, účelu nebo podadresáře
+4. Generuje stručné popisy (3–10 slov každý)
+
+**Vstup:** Cesta k cílové složce
+
+**Výstup:** `index.md` s organizovanými výpisy souborů, relativními odkazy a stručnými popisy

docs/cs/reference/modules.md

@@ -0,0 +1,76 @@
+---
+title: Oficiální moduly
+description: Doplňkové moduly pro tvorbu vlastních agentů, kreativní inteligenci, vývoj her a testování
+sidebar:
+  order: 4
+---
+
+BMad se rozšiřuje prostřednictvím oficiálních modulů, které vyberete během instalace. Tyto doplňkové moduly poskytují specializované agenty, workflow a úkoly pro specifické domény nad rámec vestavěného jádra a BMM (Agile suite).
+
+:::tip[Instalace modulů]
+Spusťte `npx bmad-method install` a vyberte požadované moduly. Instalátor se postará o stažení, konfiguraci a integraci s IDE automaticky.
+:::
+
+## BMad Builder
+
+Vytvářejte vlastní agenty, workflow a doménově specifické moduly s řízenou asistencí. BMad Builder je meta-modul pro rozšiřování samotného frameworku.
+
+- **Kód:** `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)
+
+**Poskytuje:**
+
+- Agent Builder — tvorba specializovaných AI agentů s vlastní odborností a přístupem k nástrojům
+- Workflow Builder — návrh strukturovaných procesů s kroky a rozhodovacími body
+- Module Builder — balíčkování agentů a workflow do sdílitelných, publikovatelných modulů
+- Interaktivní nastavení s YAML konfigurací a podporou npm publikování
+
+## Creative Intelligence Suite
+
+AI nástroje pro strukturovanou kreativitu, ideaci a inovace v rané fázi vývoje. Suite poskytuje více agentů, kteří facilitují brainstorming, design thinking a řešení problémů pomocí osvědčených frameworků.
+
+- **Kód:** `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)
+
+**Poskytuje:**
+
+- Agenty Innovation Strategist, Design Thinking Coach a Brainstorming Coach
+- Problem Solver a Creative Problem Solver pro systematické a laterální myšlení
+- Storyteller a Presentation Master pro narativy a prezentace
+- Ideační frameworky včetně SCAMPER, reverzního brainstormingu a přeformulování problémů
+
+## Game Dev Studio
+
+Strukturované workflow pro vývoj her adaptované pro Unity, Unreal, Godot a vlastní enginy. Podporuje rychlé prototypování přes Quick Flow a plnoscálovou produkci s epicky řízenými sprinty.
+
+- **Kód:** `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)
+
+**Poskytuje:**
+
+- Workflow pro generování Game Design Document (GDD)
+- Režim Quick Dev pro rychlé prototypování
+- Podporu narativního designu pro postavy, dialogy a budování světa
+- Pokrytí 21+ typů her s architektonickým vedením specifickým pro engine
+
+## Test Architect (TEA)
+
+Podniková testovací strategie, vedení automatizace a rozhodování o release gate prostřednictvím expertního agenta a devíti strukturovaných workflow. TEA jde daleko za vestavěného QA agenta s prioritizací založenou na riziku a trasovatelností požadavků.
+
+- **Kód:** `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)
+
+**Poskytuje:**
+
+- Agenta Murat (Master Test Architect a Quality Advisor)
+- Workflow pro testovací design, ATDD, automatizaci, revizi testů a trasovatelnost
+- Hodnocení NFR, nastavení CI a scaffolding frameworku
+- Prioritizaci P0-P3 s volitelnými integracemi Playwright Utils a MCP
+
+## Komunitní moduly
+
+Komunitní moduly a marketplace modulů přicházejí. Sledujte [organizaci BMad na GitHubu](https://github.com/bmad-code-org) pro aktualizace.

docs/cs/reference/testing.md

@@ -0,0 +1,106 @@
+---
+title: Možnosti testování
+description: Srovnání vestavěného QA agenta (Quinn) s modulem Test Architect (TEA) pro automatizaci testů.
+sidebar:
+  order: 5
+---
+
+BMad poskytuje dvě testovací cesty: vestavěného QA agenta pro rychlé generování testů a instalovatelný modul Test Architect pro podnikovou testovací strategii.
+
+## Který byste měli použít?
+
+| Faktor | Quinn (vestavěný QA) | Modul TEA |
+| --- | --- | --- |
+| **Nejlepší pro** | Malé až střední projekty, rychlé pokrytí | Velké projekty, regulované nebo složité domény |
+| **Nastavení** | Nic k instalaci — součástí BMM | Instalace zvlášť přes `npx bmad-method install` |
+| **Přístup** | Generujte testy rychle, iterujte později | Nejprve plánujte, pak generujte s trasovatelností |
+| **Typy testů** | API a E2E testy | API, E2E, ATDD, NFR a další |
+| **Strategie** | Happy path + kritické hraniční případy | Prioritizace založená na riziku (P0–P3) |
+| **Počet workflow** | 1 (Automate) | 9 (design, ATDD, automate, review, trace a další) |
+
+:::tip[Začněte s Quinnem]
+Většina projektů by měla začít s Quinnem. Pokud později budete potřebovat testovací strategii, quality gates nebo trasovatelnost požadavků, nainstalujte TEA vedle něj.
+:::
+
+## Vestavěný QA agent (Quinn)
+
+Quinn je vestavěný QA agent v modulu BMM (Agile suite). Rychle generuje funkční testy pomocí existujícího testovacího frameworku vašeho projektu — bez konfigurace nebo další instalace.
+
+**Spouštěč:** `QA` nebo `bmad-qa-generate-e2e-tests`
+
+### Co Quinn dělá
+
+Quinn spouští jeden workflow (Automate), který projde pěti kroky:
+
+1. **Detekce testovacího frameworku** — skenuje `package.json` a existující testovací soubory pro váš framework (Jest, Vitest, Playwright, Cypress nebo jakýkoli standardní runner). Pokud neexistuje, analyzuje stack projektu a navrhne jeden.
+2. **Identifikace funkcí** — zeptá se, co testovat, nebo automaticky objeví funkce v kódové bázi.
+3. **Generování API testů** — pokrývá stavové kódy, strukturu odpovědí, happy path a 1–2 chybové případy.
+4. **Generování E2E testů** — pokrývá uživatelské workflow se sémantickými lokátory a asercemi viditelných výsledků.
+5. **Spuštění a ověření** — provede generované testy a okamžitě opraví selhání.
+
+Quinn produkuje shrnutí testů uložené do složky implementačních artefaktů vašeho projektu.
+
+### Vzory testů
+
+Generované testy sledují filozofii „jednoduché a udržovatelné“:
+
+- **Pouze standardní API frameworku** — žádné externí utility nebo vlastní abstrakce
+- **Sémantické lokátory** pro UI testy (role, popisky, text místo CSS selektorů)
+- **Nezávislé testy** bez závislostí na pořadí
+- **Žádné hardcoded waity nebo sleep**
+- **Jasné popisy**, které se čtou jako dokumentace funkcí
+
+:::note[Rozsah]
+Quinn generuje pouze testy. Pro revizi kódu a validaci stories použijte workflow Code Review (`CR`).
+:::
+
+### Kdy použít Quinna
+
+- Rychlé pokrytí testy pro novou nebo existující funkci
+- Automatizace testů přátelská k začátečníkům bez pokročilého nastavení
+- Standardní vzory testů, které může číst a udržovat jakýkoli vývojář
+- Malé až střední projekty, kde komplexní testovací strategie není potřeba
+
+## Modul Test Architect (TEA)
+
+TEA je samostatný modul, který poskytuje expertního agenta (Murat) a devět strukturovaných workflow pro podnikové testování. Jde za rámec generování testů do testovací strategie, plánování založeného na riziku, quality gates a trasovatelnosti požadavků.
+
+- **Dokumentace:** [Dokumentace modulu TEA](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+- **Instalace:** `npx bmad-method install` a výběr modulu TEA
+- **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+
+### Co TEA poskytuje
+
+| Workflow | Účel |
+| --- | --- |
+| Test Design | Vytvoření komplexní testovací strategie vázané na požadavky |
+| ATDD | Acceptance-test-driven development s kritérii stakeholderů |
+| Automate | Generování testů s pokročilými vzory a utilitami |
+| Test Review | Validace kvality a pokrytí testů proti strategii |
+| Traceability | Mapování testů zpět na požadavky pro audit a compliance |
+| NFR Assessment | Hodnocení nefunkčních požadavků (výkon, bezpečnost) |
+| CI Setup | Konfigurace provádění testů v CI pipelines |
+| Framework Scaffolding | Nastavení testovací infrastruktury a struktury projektu |
+| Release Gate | Datově založená rozhodnutí go/no-go pro release |
+
+TEA také podporuje prioritizaci P0–P3 založenou na riziku a volitelné integrace s Playwright Utils a MCP nástroji.
+
+### Kdy použít TEA
+
+- Projekty vyžadující trasovatelnost požadavků nebo compliance dokumentaci
+- Týmy potřebující prioritizaci testů založenou na riziku napříč mnoha funkcemi
+- Podniková prostředí s formálními quality gates před releasem
+- Složité domény, kde musí být testovací strategie naplánována před psaním testů
+- Projekty, které přerostly jednoduchý workflow Quinna
+
+## Jak testování zapadá do workflow
+
+Quinn workflow Automate se objevuje ve Fázi 4 (Implementace) mapy workflow BMad Method. Je navržen ke spuštění **po dokončení celého epicu** — jakmile jsou všechny stories v epicu implementovány a zrevidovány. Typická sekvence:
+
+1. Pro každou story v epicu: implementace s Dev (`DS`), pak validace pomocí Code Review (`CR`)
+2. Po dokončení epicu: generování testů s Quinnem (`QA`) nebo TEA workflow Automate
+3. Spuštění retrospektivy (`bmad-retrospective`) pro zachycení získaných zkušeností
+
+Quinn pracuje přímo ze zdrojového kódu bez načítání plánovacích dokumentů (PRD, architektura). TEA workflow mohou integrovat s upstream plánovacími artefakty pro trasovatelnost.
+
+Pro více o tom, kde testování zapadá do celkového procesu, viz [Mapa pracovních postupů](./workflow-map.md).

docs/cs/reference/workflow-map.md

@@ -0,0 +1,89 @@
+---
+title: "Mapa pracovních postupů"
+description: Vizuální reference fází workflow BMad Method a jejich výstupů
+sidebar:
+  order: 1
+---
+
+BMad Method (BMM) je modul v ekosystému BMad, zaměřený na dodržování osvědčených postupů context engineeringu a plánování. AI agenti fungují nejlépe s jasným, strukturovaným kontextem. Systém BMM buduje tento kontext progresivně napříč 4 odlišnými fázemi — každá fáze a volitelně více workflow v každé fázi produkují dokumenty, které informují další, takže agenti vždy vědí, co budovat a proč.
+
+Zdůvodnění a koncepty vycházejí z agilních metodik, které byly v průmyslu úspěšně používány jako mentální framework.
+
+Pokud si kdykoli nejste jisti, co dělat, skill `bmad-help` vám pomůže zůstat na cestě nebo vědět, co dělat dál. Vždy se můžete odkázat sem — ale `bmad-help` je plně interaktivní a mnohem rychlejší, pokud již máte nainstalovaný BMad Method. Navíc, pokud používáte různé moduly, které rozšířily BMad Method nebo přidaly další komplementární moduly — `bmad-help` se vyvíjí a zná vše, co je dostupné, aby vám dal nejlepší radu v daném okamžiku.
+
+Důležitá poznámka: Každý workflow níže lze spustit přímo vaším nástrojem přes skill nebo načtením agenta a použitím záznamu z nabídky agenta.
+
+<iframe src="/workflow-map-diagram.html" title="Diagram mapy workflow 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.html" target="_blank" rel="noopener noreferrer">Otevřít diagram v novém panelu ↗</a>
+</p>
+
+## Fáze 1: Analýza (volitelná)
+
+Prozkoumejte problémový prostor a validujte nápady před závazkem k plánování.
+
+| Workflow                        | Účel                                                                       | Produkuje                 |
+| ------------------------------- | -------------------------------------------------------------------------- | ------------------------- |
+| `bmad-brainstorming`            | Brainstorming nápadů na projekt s řízenou facilitací brainstormingového kouče | `brainstorming-report.md` |
+| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validace tržních, technických nebo doménových předpokladů | Výzkumné nálezy |
+| `bmad-product-brief`            | Zachycení strategické vize — nejlepší, když je váš koncept jasný           | `product-brief.md`        |
+| `bmad-prfaq`                    | Working Backwards — zátěžový test a zformování vašeho produktového konceptu | `prfaq-{project}.md`      |
+
+## Fáze 2: Plánování
+
+Definujte, co budovat a pro koho.
+
+| Workflow                    | Účel                                     | Produkuje    |
+| --------------------------- | ---------------------------------------- | ------------ |
+| `bmad-create-prd`           | Definice požadavků (FR/NFR)              | `PRD.md`     |
+| `bmad-create-ux-design`     | Návrh uživatelského zážitku (když záleží na UX) | `ux-spec.md` |
+
+## Fáze 3: Solutioning
+
+Rozhodněte, jak to budovat, a rozložte práci na stories.
+
+| Workflow                                  | Účel                                       | Produkuje                   |
+| ----------------------------------------- | ------------------------------------------ | --------------------------- |
+| `bmad-create-architecture`                | Explicitní technická rozhodnutí            | `architecture.md` s ADR     |
+| `bmad-create-epics-and-stories`           | Rozložení požadavků na implementovatelnou práci | Soubory epiců se stories |
+| `bmad-check-implementation-readiness`     | Kontrola brány před implementací           | Rozhodnutí PASS/CONCERNS/FAIL |
+
+## Fáze 4: Implementace
+
+Budujte to, jednu story po druhé. Brzy plná automatizace fáze 4!
+
+| Workflow                   | Účel                                                                     | Produkuje                        |
+| -------------------------- | ------------------------------------------------------------------------ | -------------------------------- |
+| `bmad-sprint-planning`     | Inicializace sledování (jednou na projekt pro sekvencování dev cyklu)    | `sprint-status.yaml`             |
+| `bmad-create-story`        | Příprava další story pro implementaci                                    | `story-[slug].md`                |
+| `bmad-dev-story`           | Implementace story                                                       | Fungující kód + testy            |
+| `bmad-code-review`         | Validace kvality implementace                                            | Schváleno nebo požadovány změny  |
+| `bmad-correct-course`      | Řešení významných změn uprostřed sprintu                                 | Aktualizovaný plán nebo přesměrování |
+| `bmad-sprint-status`       | Sledování průběhu sprintu a stavu stories                                | Aktualizace stavu sprintu        |
+| `bmad-retrospective`       | Revize po dokončení epicu                                                | Poučení                          |
+
+## Quick Flow (paralelní cesta)
+
+Přeskočte fáze 1–3 pro malou, dobře pochopenou práci.
+
+| Workflow           | Účel                                                                        | Produkuje            |
+| ------------------ | --------------------------------------------------------------------------- | -------------------- |
+| `bmad-quick-dev`   | Sjednocený quick flow — vyjasněte záměr, plánujte, implementujte, revidujte a prezentujte | `spec-*.md` + kód |
+
+## Správa kontextu
+
+Každý dokument se stává kontextem pro další fázi. PRD říká architektovi, jaká omezení záleží. Architektura říká dev agentovi, jaké vzory následovat. Soubory stories poskytují zaměřený, kompletní kontext pro implementaci. Bez této struktury agenti dělají nekonzistentní rozhodnutí.
+
+### Kontext projektu
+
+:::tip[Doporučeno]
+Vytvořte `project-context.md` pro zajištění toho, aby AI agenti dodržovali pravidla a preference vašeho projektu. Tento soubor funguje jako ústava vašeho projektu — vede implementační rozhodnutí napříč všemi workflow. Tento volitelný soubor lze vygenerovat na konci tvorby architektury, nebo u existujícího projektu ho lze také vygenerovat pro zachycení toho, co je důležité pro zachování souladu se současnými konvencemi.
+:::
+
+**Jak ho vytvořit:**
+
+- **Ručně** — Vytvořte `_bmad-output/project-context.md` s vaším technologickým stackem a pravidly implementace
+- **Vygenerujte ho** — Spusťte `bmad-generate-project-context` pro automatické generování z vaší architektury nebo kódové báze
+
+[**Zjistit více o project-context.md**](../explanation/project-context.md)

docs/cs/roadmap.mdx

@@ -0,0 +1,136 @@
+---
+title: Plán rozvoje
+description: Co chystáme pro BMad – funkce, vylepšení a komunitní příspěvky
+---
+
+# Metoda BMad: Veřejný plán rozvoje
+
+Metoda BMad, modul BMad Method (BMM) a BMad Builder (BMB) se neustále vyvíjejí. Zde je přehled toho, na čem pracujeme a co přijde dál.
+
+<div class="roadmap-container">
+
+  <h2 class="roadmap-section-title">Probíhá</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🧩</span>
+      <h4>Univerzální architektura Skills</h4>
+      <p>Jeden skill, jakákoli platforma. Napište jednou, spusťte kdekoli.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏗️</span>
+      <h4>BMad Builder v1</h4>
+      <p>Vytvářejte produkční AI agenty a pracovní postupy s vestavěnými eval testy, týmy a elegantní degradací.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🧠</span>
+      <h4>Systém kontextu projektu</h4>
+      <p>Vaše AI skutečně rozumí vašemu projektu. Kontextový systém reagující na framework, který se vyvíjí s vaším kódem.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">📦</span>
+      <h4>Centralizované Skills</h4>
+      <p>Nainstalujte jednou, používejte všude. Sdílejte skills mezi projekty bez zbytečných souborů.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🔄</span>
+      <h4>Adaptivní Skills</h4>
+      <p>Skills, které znají váš nástroj. Optimalizované varianty pro Claude, Codex, Kimi, OpenCode a mnoho dalších.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">📝</span>
+      <h4>Blog BMad Team Pros</h4>
+      <p>Návody, články a postřehy od týmu. Brzy spouštíme.</p>
+    </div>
+  </div>
+
+  <h2 class="roadmap-section-title">Na startu</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏪</span>
+      <h4>Skill Marketplace</h4>
+      <p>Objevujte, instalujte a aktualizujte komunitní skills. Jeden curl příkaz od superschopností.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎨</span>
+      <h4>Přizpůsobení pracovních postupů</h4>
+      <p>Přizpůsobte si to. Integrujte Jira, Linear, vlastní výstupy — váš workflow, vaše pravidla.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🚀</span>
+      <h4>Optimalizace fází 1–3</h4>
+      <p>Bleskurychlé plánování s kontextovým sběrem sub-agentů. Režim YOLO kombinovaný s řízenou kvalitou.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🌐</span>
+      <h4>Připraveno pro podniky</h4>
+      <p>SSO, auditní logy, týmové pracovní prostory. Všechny ty nudné věci, díky kterým firmy řeknou ano.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">💎</span>
+      <h4>Exploze komunitních modulů</h4>
+      <p>Zábava, bezpečnost, terapie, roleplay a mnohem víc. Rozšiřte platformu BMad Method.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">⚡</span>
+      <h4>Automatizace Dev Loop</h4>
+      <p>Volitelný autopilot pro vývoj. Nechte AI řídit tok práce a přitom udržujte vysokou kvalitu.</p>
+    </div>
+  </div>
+
+  <h2 class="roadmap-section-title">Komunita a tým</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎙️</span>
+      <h4>Podcast metody BMad</h4>
+      <p>Rozhovory o AI-nativním vývoji. Spouštíme 1. března 2026!</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎓</span>
+      <h4>Master Class metody BMad</h4>
+      <p>Od uživatele k expertovi. Hluboké ponory do každé fáze, každého workflow, každého tajemství.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏗️</span>
+      <h4>Master Class BMad Builder</h4>
+      <p>Vytvářejte vlastní agenty. Pokročilé techniky pro chvíle, kdy jste připraveni tvořit, ne jen používat.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">⚡</span>
+      <h4>BMad Prototype First</h4>
+      <p>Od nápadu k fungujícímu prototypu v jedné relaci. Vytvořte svou vysněnou aplikaci jako umělecké dílo.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🌴</span>
+      <h4>BMad BALM!</h4>
+      <p>Správa života pro AI-nativní uživatele. Úkoly, návyky, cíle — váš AI kopilot pro všechno.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🖥️</span>
+      <h4>Oficiální UI</h4>
+      <p>Krásné rozhraní pro celý ekosystém BMad. Síla CLI, lesk GUI.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🔒</span>
+      <h4>BMad in a Box</h4>
+      <p>Self-hosted, bez připojení, podnikové kvality. Váš AI asistent, vaše infrastruktura, vaše kontrola.</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;">Chcete přispět?</h3>
+    <p style="color: var(--slate-color-400); margin: 0;">
+      Toto je pouze částečný seznam toho, co je plánováno. Open source tým BMad vítá přispěvatele!{" "}<br />
+      <a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Přidejte se k nám na GitHubu</a> a pomozte formovat budoucnost vývoje řízeného AI.
+    </p>
+    <p style="color: var(--slate-color-400); margin: 1.5rem 0 0;">
+      Líbí se vám, co budujeme? Oceníme jak jednorázovou, tak měsíční{" "}<a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">podporu</a>.
+    </p>
+    <p style="color: var(--slate-color-400); margin: 1rem 0 0;">
+      Pro firemní sponzoring, partnerské dotazy, přednášky, školení nebo mediální dotazy:{" "}
+      <a href="mailto:contact@bmadcode.com" style="color: var(--color-in-progress);">contact@bmadcode.com</a>
+    </p>
+  </div>
+</div>

docs/cs/tutorials/getting-started.md

@@ -0,0 +1,276 @@
+---
+title: "Začínáme"
+description: Nainstalujte BMad a vytvořte svůj první projekt
+---
+
+Vytvářejte software rychleji pomocí pracovních postupů řízených AI se specializovanými agenty, kteří vás provedou plánováním, architekturou a implementací.
+
+## Co se naučíte
+
+- Nainstalovat a inicializovat BMad Method pro nový projekt
+- Používat **BMad-Help** — vašeho inteligentního průvodce, který ví, co dělat dál
+- Vybrat správnou plánovací cestu pro velikost vašeho projektu
+- Postupovat fázemi od požadavků k fungujícímu kódu
+- Efektivně používat agenty a pracovní postupy
+
+:::note[Předpoklady]
+- **Node.js 20+** — Vyžadováno pro instalátor
+- **Git** — Doporučeno pro správu verzí
+- **AI-powered IDE** — Claude Code, Cursor nebo podobné
+- **Nápad na projekt** — I jednoduchý stačí pro učení
+:::
+
+:::tip[Nejsnadnější cesta]
+**Instalace** → `npx bmad-method install`
+**Zeptejte se** → `bmad-help what should I do first?`
+**Tvořte** → Nechte BMad-Help vás provést workflow po workflow
+:::
+
+## Seznamte se s BMad-Help: Váš inteligentní průvodce
+
+**BMad-Help je nejrychlejší způsob, jak začít s BMad.** Nemusíte si pamatovat workflow nebo fáze — prostě se zeptejte a BMad-Help:
+
+- **Prozkoumá váš projekt** a zjistí, co už bylo uděláno
+- **Ukáže vaše možnosti** na základě nainstalovaných modulů
+- **Doporučí, co dál** — včetně prvního povinného úkolu
+- **Odpoví na otázky** jako „Mám nápad na SaaS, kde začít?“
+
+### Jak používat BMad-Help
+
+Spusťte ho ve vašem AI IDE vyvoláním skillu:
+
+```
+bmad-help
+```
+
+Nebo ho spojte s otázkou pro kontextové poradenství:
+
+```
+bmad-help I have an idea for a SaaS product, I already know all the features I want. where do I get started?
+```
+
+BMad-Help odpoví s:
+- Co je doporučeno pro vaši situaci
+- Jaký je první povinný úkol
+- Jak vypadá zbytek procesu
+
+### Řídí i pracovní postupy
+
+BMad-Help nejen odpovídá na otázky — **automaticky se spouští na konci každého workflow** a řekne vám přesně, co dělat dál. Žádné hádání, žádné prohledávání dokumentace — jen jasné pokyny k dalšímu povinnému workflow.
+
+:::tip[Začněte zde]
+Po instalaci BMad okamžitě vyvolejte skill `bmad-help`. Detekuje, jaké moduly máte nainstalované, a navede vás ke správnému výchozímu bodu pro váš projekt.
+:::
+
+## Pochopení BMad
+
+BMad vám pomáhá vytvářet software prostřednictvím řízených pracovních postupů se specializovanými AI agenty. Proces probíhá ve čtyřech fázích:
+
+| Fáze | Název          | Co se děje                                              |
+| ---- | -------------- | ------------------------------------------------------- |
+| 1    | Analýza        | Brainstorming, průzkum, product brief nebo PRFAQ *(volitelné)* |
+| 2    | Plánování      | Vytvoření požadavků (PRD nebo specifikace)              |
+| 3    | Solutioning    | Návrh architektury *(pouze BMad Method/Enterprise)*     |
+| 4    | Implementace   | Budování epic po epicu, story po story                  |
+
+**[Otevřete Mapu pracovních postupů](../reference/workflow-map.md)** pro prozkoumání fází, workflow a správy kontextu.
+
+Na základě složitosti vašeho projektu nabízí BMad tři plánovací cesty:
+
+| Cesta           | Nejlepší pro                                                   | Vytvořené dokumenty                    |
+| --------------- | -------------------------------------------------------------- | -------------------------------------- |
+| **Quick Flow**  | Opravy chyb, jednoduché funkce, jasný rozsah (1–15 stories)   | Pouze tech-spec                        |
+| **BMad Method** | Produkty, platformy, složité funkce (10–50+ stories)           | PRD + architektura + UX                |
+| **Enterprise**  | Compliance, multi-tenant systémy (30+ stories)                 | PRD + architektura + bezpečnost + DevOps |
+
+:::note
+Počty stories jsou orientační, ne definitivní. Vyberte si cestu podle potřeb plánování, ne podle počtu stories.
+:::
+
+## Instalace
+
+Otevřete terminál v adresáři vašeho projektu a spusťte:
+
+```bash
+npx bmad-method install
+```
+
+Pokud chcete nejnovější prereleaseový build místo výchozího release kanálu, použijte `npx bmad-method@next install`.
+
+Při výzvě k výběru modulů zvolte **BMad Method**.
+
+Instalátor vytvoří dvě složky:
+- `_bmad/` — agenti, workflow, úkoly a konfigurace
+- `_bmad-output/` — prozatím prázdná, ale zde se budou ukládat vaše artefakty
+
+:::tip[Váš další krok]
+Otevřete vaše AI IDE ve složce projektu a spusťte:
+
+```
+bmad-help
+```
+
+BMad-Help detekuje, co jste dokončili, a doporučí přesně, co dělat dál. Můžete mu také klást otázky jako „Jaké mám možnosti?“ nebo „Mám nápad na SaaS, kde začít?“
+:::
+
+:::note[Jak načítat agenty a spouštět workflow]
+Každý workflow má **skill**, který vyvoláte jménem ve vašem IDE (např. `bmad-create-prd`). Váš AI nástroj rozpozná název `bmad-*` a spustí ho — nemusíte načítat agenty zvlášť. Můžete také vyvolat agentní skill přímo pro obecnou konverzaci (např. `bmad-agent-pm` pro PM agenta).
+:::
+
+:::caution[Nové chaty]
+Vždy začněte nový chat pro každý workflow. Tím předejdete problémům s kontextovými omezeními.
+:::
+
+## Krok 1: Vytvořte svůj plán
+
+Projděte fázemi 1–3. **Pro každý workflow používejte nové chaty.**
+
+:::tip[Kontext projektu (volitelné)]
+Před začátkem zvažte vytvoření `project-context.md` pro dokumentaci vašich technických preferencí a pravidel implementace. Tím zajistíte, že všichni AI agenti budou dodržovat vaše konvence v průběhu celého projektu.
+
+Vytvořte ho ručně na `_bmad-output/project-context.md` nebo ho vygenerujte po architektuře pomocí `bmad-generate-project-context`. [Zjistit více](../explanation/project-context.md).
+:::
+
+### Fáze 1: Analýza (volitelná)
+
+Všechny workflow v této fázi jsou volitelné:
+- **brainstorming** (`bmad-brainstorming`) — Řízená ideace
+- **průzkum** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Tržní, doménový a technický průzkum
+- **product-brief** (`bmad-product-brief`) — Doporučený základní dokument, když je váš koncept jasný
+- **prfaq** (`bmad-prfaq`) — Working Backwards výzva pro zátěžový test a zformování vašeho produktového konceptu
+
+### Fáze 2: Plánování (povinná)
+
+**Pro BMad Method a Enterprise cesty:**
+1. Vyvolejte **PM agenta** (`bmad-agent-pm`) v novém chatu
+2. Spusťte workflow `bmad-create-prd` (`bmad-create-prd`)
+3. Výstup: `PRD.md`
+
+**Pro Quick Flow cestu:**
+- Spusťte `bmad-quick-dev` — zvládne plánování i implementaci v jednom workflow, přeskočte k implementaci
+
+:::note[UX Design (volitelné)]
+Pokud má váš projekt uživatelské rozhraní, vyvolejte **UX-Designer agenta** (`bmad-agent-ux-designer`) a spusťte UX design workflow (`bmad-create-ux-design`) po vytvoření PRD.
+:::
+
+### Fáze 3: Solutioning (BMad Method/Enterprise)
+
+**Vytvoření architektury**
+1. Vyvolejte **Architect agenta** (`bmad-agent-architect`) v novém chatu
+2. Spusťte `bmad-create-architecture` (`bmad-create-architecture`)
+3. Výstup: Dokument architektury s technickými rozhodnutími
+
+**Vytvoření epiců a stories**
+
+:::tip[Vylepšení ve V6]
+Epicy a stories se nyní vytvářejí *po* architektuře. Tím vznikají kvalitnější stories, protože architektonická rozhodnutí (databáze, API vzory, tech stack) přímo ovlivňují rozklad práce.
+:::
+
+1. Vyvolejte **PM agenta** (`bmad-agent-pm`) v novém chatu
+2. Spusťte `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
+3. Workflow využívá jak PRD, tak architekturu k vytvoření technicky informovaných stories
+
+**Kontrola připravenosti k implementaci** *(vysoce doporučeno)*
+1. Vyvolejte **Architect agenta** (`bmad-agent-architect`) v novém chatu
+2. Spusťte `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
+3. Validuje soudržnost všech plánovacích dokumentů
+
+## Krok 2: Sestavte svůj projekt
+
+Jakmile je plánování dokončeno, přejděte k implementaci. **Každý workflow by měl běžet v novém chatu.**
+
+### Inicializace plánování sprintu
+
+Vyvolejte **Developer agenta** (`bmad-agent-dev`) a spusťte `bmad-sprint-planning` (`bmad-sprint-planning`). Tím se vytvoří `sprint-status.yaml` pro sledování všech epiců a stories.
+
+### Cyklus vývoje
+
+Pro každou story opakujte tento cyklus s novými chaty:
+
+| Krok | Agent | Workflow             | Příkaz                     | Účel                               |
+| ---- | ----- | -------------------- | -------------------------- | ---------------------------------- |
+| 1    | DEV   | `bmad-create-story`  | `bmad-create-story`        | Vytvoření story souboru z epicu    |
+| 2    | DEV   | `bmad-dev-story`     | `bmad-dev-story`           | Implementace story                 |
+| 3    | DEV   | `bmad-code-review`   | `bmad-code-review`         | Validace kvality *(doporučeno)*    |
+
+Po dokončení všech stories v epicu vyvolejte **Developer agenta** (`bmad-agent-dev`) a spusťte `bmad-retrospective` (`bmad-retrospective`).
+
+## Co jste dosáhli
+
+Naučili jste se základy budování s BMad:
+
+- Nainstalovali BMad a nakonfigurovali ho pro vaše IDE
+- Inicializovali projekt s vybranou plánovací cestou
+- Vytvořili plánovací dokumenty (PRD, architektura, epicy a stories)
+- Pochopili cyklus vývoje pro implementaci
+
+Váš projekt nyní obsahuje:
+
+```text
+váš-projekt/
+├── _bmad/                                   # Konfigurace BMad
+├── _bmad-output/
+│   ├── planning-artifacts/
+│   │   ├── PRD.md                           # Váš dokument požadavků
+│   │   ├── architecture.md                  # Technická rozhodnutí
+│   │   └── epics/                           # Soubory epiců a stories
+│   ├── implementation-artifacts/
+│   │   └── sprint-status.yaml               # Sledování sprintu
+│   └── project-context.md                   # Pravidla implementace (volitelné)
+└── ...
+```
+
+## Rychlý přehled
+
+| Workflow                              | Příkaz                                     | Agent     | Účel                                            |
+| ------------------------------------- | ------------------------------------------ | --------- | ----------------------------------------------- |
+| **`bmad-help`** ⭐                    | `bmad-help`                               | Jakýkoli  | **Váš inteligentní průvodce — ptejte se na cokoli!** |
+| `bmad-create-prd`                     | `bmad-create-prd`                         | PM        | Vytvoření dokumentu požadavků (PRD)             |
+| `bmad-create-architecture`            | `bmad-create-architecture`                | Architect | Vytvoření dokumentu architektury                |
+| `bmad-generate-project-context`       | `bmad-generate-project-context`           | Analyst   | Vytvoření souboru kontextu projektu             |
+| `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`           | PM        | Rozklad PRD na epicy                            |
+| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness`     | Architect | Validace soudržnosti plánování                  |
+| `bmad-sprint-planning`                | `bmad-sprint-planning`                    | DEV       | Inicializace sledování sprintu                  |
+| `bmad-create-story`                   | `bmad-create-story`                       | DEV       | Vytvoření souboru story                         |
+| `bmad-dev-story`                      | `bmad-dev-story`                          | DEV       | Implementace story                              |
+| `bmad-code-review`                    | `bmad-code-review`                        | DEV       | Revize implementovaného kódu                    |
+
+## Časté otázky
+
+**Potřebuji vždy architekturu?**
+Pouze pro BMad Method a Enterprise cesty. Quick Flow přeskakuje ze specifikace rovnou k implementaci.
+
+**Mohu později změnit svůj plán?**
+Ano. Workflow `bmad-correct-course` (`bmad-correct-course`) řeší změny rozsahu během implementace.
+
+**Co když chci nejdřív brainstormovat?**
+Vyvolejte Analyst agenta (`bmad-agent-analyst`) a spusťte `bmad-brainstorming` (`bmad-brainstorming`) před zahájením PRD.
+
+**Musím dodržovat striktní pořadí?**
+Ne striktně. Jakmile se naučíte postup, můžete spouštět workflow přímo pomocí Rychlého přehledu výše.
+
+## Získání pomoci
+
+:::tip[První zastávka: BMad-Help]
+**Vyvolejte `bmad-help` kdykoli** — je to nejrychlejší způsob, jak se odpoutat. Zeptejte se na cokoli:
+- „Co mám dělat po instalaci?“
+- „Zasekl jsem se na workflow X“
+- „Jaké mám možnosti pro Y?“
+- „Ukaž mi, co bylo dosud uděláno“
+
+BMad-Help prozkoumá váš projekt, detekuje, co jste dokončili, a řekne vám přesně, co dělat dál.
+:::
+
+- **Během workflow** — Agenti vás provázejí otázkami a vysvětleními
+- **Komunita** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
+
+## Klíčové poznatky
+
+:::tip[Zapamatujte si]
+- **Začněte s `bmad-help`** — Váš inteligentní průvodce, který zná váš projekt a možnosti
+- **Vždy používejte nové chaty** — Začněte nový chat pro každý workflow
+- **Cesta záleží** — Quick Flow používá `bmad-quick-dev`; Method/Enterprise vyžadují PRD a architekturu
+- **BMad-Help se spouští automaticky** — Každý workflow končí pokyny, co dělat dál
+:::
+
+Jste připraveni začít? Nainstalujte BMad, vyvolejte `bmad-help` a nechte svého inteligentního průvodce ukázat cestu.

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

@@ -5,80 +5,27 @@ sidebar:
   order: 4
 ---
 
-## Start Here: BMad-Help
+Use BMad's built-in help, source docs, or the community to get answers — from quickest to most thorough.
 
-**The fastest way to get answers about BMad is the `bmad-help` skill.** This intelligent guide will answer upwards of 80% of all questions and is available to you directly in your IDE as you work.
+## 1. Ask BMad-Help
 
-BMad-Help is more than a lookup tool — it:
-- **Inspects your project** to see what's already been completed
-- **Understands natural language** — ask questions in plain English
-- **Varies based on your installed modules** — shows relevant options
-- **Auto-runs after workflows** — tells you exactly what to do next
-- **Recommends the first required task** — no guessing where to start
-
-### How to Use BMad-Help
-
-Call it by name in your AI session:
+The fastest way to get answers. The `bmad-help` skill is available directly in your AI session and handles over 80% of questions — it inspects your project, sees what you've completed, and tells you what to do next.
 
 ```
-bmad-help
+bmad-help I have a SaaS idea and know all the features. Where do I start?
+bmad-help What are my options for UX design?
+bmad-help I'm stuck on the PRD workflow
 ```
 
 :::tip
 You can also use `/bmad-help` or `$bmad-help` depending on your platform, but just `bmad-help` should work everywhere.
 :::
 
-Combine it with a natural language query:
+## 2. Go Deeper with Source
 
-```
-bmad-help I have a SaaS idea and know all the features. Where do I start?
-bmad-help What are my options for UX design?
-bmad-help I'm stuck on the PRD workflow
-bmad-help Show me what's been done so far
-```
+BMad-Help draws on your installed configuration. For questions about BMad's internals, history, or architecture — or if you're researching BMad before installing — point your AI at the source directly.
 
-BMad-Help responds with:
-- What's recommended for your situation
-- What the first required task is
-- What the rest of the process looks like
-
-## When to Use This Guide
-
-Use this section when:
-- You want to understand BMad's architecture or internals
-- You need answers outside of what BMad-Help provides
-- You're researching BMad before installing
-- You want to explore the source code directly
-
-## Steps
-
-### 1. Choose Your Source
-
-| Source               | Best For                                  | Examples                     |
-| -------------------- | ----------------------------------------- | ---------------------------- |
-| **`_bmad` folder**   | How BMad works—agents, workflows, prompts | "What does the PM agent do?" |
-| **Full GitHub repo** | History, installer, architecture          | "What changed in v6?"        |
-| **`llms-full.txt`**  | Quick overview from docs                  | "Explain BMad's four phases" |
-
-The `_bmad` folder is created when you install BMad. If you don't have it yet, clone the repo instead.
-
-### 2. Point Your AI at the Source
-
-**If your AI can read files (Claude Code, Cursor, etc.):**
-
-- **BMad installed:** Point at the `_bmad` folder and ask directly
-- **Want deeper context:** Clone the [full repo](https://github.com/bmad-code-org/BMAD-METHOD)
-
-**If you use ChatGPT or Claude.ai:**
-
-Fetch `llms-full.txt` into your session:
-
-```text
-https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
-```
-
-
-### 3. Ask Your Question
+Clone or open the [BMAD-METHOD repo](https://github.com/bmad-code-org/BMAD-METHOD) and ask your AI about it. Any agent-capable tool (Claude Code, Cursor, Windsurf, etc.) can read the source and answer questions directly.
 
 :::note[Example]
 **Q:** "Tell me the fastest way to build something with BMad"
@@ -86,30 +33,27 @@ https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
 **A:** Use Quick Flow: Run `bmad-quick-dev` — it clarifies your intent, plans, implements, reviews, and presents results in a single workflow, skipping the full planning phases.
 :::
 
-## What You Get
+**Tips for better answers:**
 
-Direct answers about BMad—how agents work, what workflows do, why things are structured the way they are—without waiting for someone else to respond.
-
-## Tips
-
-- **Verify surprising answers** — LLMs occasionally get things wrong. Check the source file or ask on Discord.
 - **Be specific** — "What does step 3 of the PRD workflow do?" beats "How does PRD work?"
+- **Verify surprising claims** — LLMs occasionally get things wrong. Check the source file or ask on Discord.
 
-## Still Stuck?
+### Not using an agent? Use the docs site
 
-Tried the LLM approach and still need help? You now have a much better question to ask.
+If your AI can't read local files (ChatGPT, Claude.ai, etc.), fetch [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) into your session — it's a single-file snapshot of the BMad documentation.
+
+## 3. Ask Someone
+
+If neither BMad-Help nor the source answered your question, you now have a much better question to ask.
 
 | Channel                   | Use For                                     |
 | ------------------------- | ------------------------------------------- |
-| `#bmad-method-help`       | Quick questions (real-time chat)            |
-| `help-requests` forum     | Detailed questions (searchable, persistent) |
+| `help-requests` forum     | Questions                                   |
 | `#suggestions-feedback`   | Ideas and feature requests                  |
-| `#report-bugs-and-issues` | Bug reports                                 |
 
 **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) (for clear bugs)
-
+**GitHub Issues:** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
 *You!*
         *Stuck*
              *in the queue—*

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

@@ -61,8 +61,8 @@ If you have stories created or implemented:
 
 1. Complete the v6 installation
 2. Place `epics.md` or `epics/epic*.md` in `_bmad-output/planning-artifacts/`
-3. Run the Scrum Master's `bmad-sprint-planning` workflow
-4. Tell the SM which epics/stories are already complete
+3. Run the Developer's `bmad-sprint-planning` workflow
+4. Tell the agent which epics/stories are already complete
 
 ## What You Get
 

docs/reference/agents.md

@@ -20,8 +20,7 @@ This page lists the default BMM (Agile suite) agents that install with BMad Meth
 | Analyst (Mary)              | `bmad-analyst`       | `BP`, `RS`, `CB`, `WB`, `DP`       | Brainstorm Project, Research, Create Brief, PRFAQ Challenge, Document Project                       |
 | Product Manager (John)      | `bmad-pm`            | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Create/Validate/Edit PRD, Create Epics and Stories, Implementation Readiness, Correct Course        |
 | Architect (Winston)         | `bmad-architect`     | `CA`, `IR`                         | Create Architecture, Implementation Readiness                                                       |
-| Scrum Master (Bob)          | `bmad-sm`            | `SP`, `CS`, `ER`, `CC`             | Sprint Planning, Create Story, Epic Retrospective, Correct Course                                   |
-| Developer (Amelia)          | `bmad-dev`           | `DS`, `QD`, `QA`, `CR`             | Dev Story, Quick Dev, QA Test Generation, Code Review                                               |
+| Developer (Amelia)          | `bmad-agent-dev`     | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | Dev Story, Quick Dev, QA Test Generation, Code Review, Sprint Planning, Create Story, Epic Retrospective |
 | UX Designer (Sally)         | `bmad-ux-designer`   | `CU`                               | Create UX Design                                                                                    |
 | Technical Writer (Paige)    | `bmad-tech-writer`   | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Document Project, Write Document, Update Standards, Mermaid Generate, Validate Doc, Explain Concept |
 

docs/reference/commands.md

@@ -54,12 +54,12 @@ Each skill is a directory containing a `SKILL.md` file. For example, a Claude Co
 │   └── SKILL.md
 ├── bmad-create-prd/
 │   └── SKILL.md
-├── bmad-dev/
+├── bmad-agent-dev/
 │   └── SKILL.md
 └── ...
 ```
 
-The directory name determines the skill name in your IDE. For example, the directory `bmad-dev/` registers the skill `bmad-dev`.
+The directory name determines the skill name in your IDE. For example, the directory `bmad-agent-dev/` registers the skill `bmad-agent-dev`.
 
 ## How to Discover Your Skills
 
@@ -79,10 +79,9 @@ Agent skills load a specialized AI persona with a defined role, communication st
 
 | Example skill | Agent | Role |
 | --- | --- | --- |
-| `bmad-dev` | Amelia (Developer) | Implements stories with strict adherence to specs |
+| `bmad-agent-dev` | Amelia (Developer) | Implements stories with strict adherence to specs |
 | `bmad-pm` | John (Product Manager) | Creates and validates PRDs |
 | `bmad-architect` | Winston (Architect) | Designs system architecture |
-| `bmad-sm` | Bob (Scrum Master) | Manages sprints and stories |
 
 See [Agents](./agents.md) for the full list of default agents and their triggers.
 
@@ -125,7 +124,7 @@ The core module includes 11 built-in tools — reviews, compression, brainstormi
 
 ## Naming Convention
 
-All skills use the `bmad-` prefix followed by a descriptive name (e.g., `bmad-dev`, `bmad-create-prd`, `bmad-help`). See [Modules](./modules.md) for available modules.
+All skills use the `bmad-` prefix followed by a descriptive name (e.g., `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`). See [Modules](./modules.md) for available modules.
 
 ## Troubleshooting
 

docs/tutorials/getting-started.md

@@ -181,7 +181,7 @@ Once planning is complete, move to implementation. **Each workflow should run in
 
 ### Initialize Sprint Planning
 
-Invoke the **SM agent** (`bmad-agent-sm`) and run `bmad-sprint-planning` (`bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
+Invoke the **Developer agent** (`bmad-agent-dev`) and run `bmad-sprint-planning` (`bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
 
 ### The Build Cycle
 
@@ -189,11 +189,11 @@ For each story, repeat this cycle with fresh chats:
 
 | Step | Agent | Workflow       | Command                    | Purpose                            |
 | ---- | ----- | -------------- | -------------------------- | ---------------------------------- |
-| 1    | SM    | `bmad-create-story` | `bmad-create-story`  | Create story file from epic        |
+| 1    | DEV   | `bmad-create-story` | `bmad-create-story`  | Create story file from epic        |
 | 2    | DEV   | `bmad-dev-story`    | `bmad-dev-story`     | Implement the story                |
 | 3    | DEV   | `bmad-code-review`  | `bmad-code-review`   | Quality validation *(recommended)* |
 
-After completing all stories in an epic, invoke the **SM agent** (`bmad-agent-sm`) and run `bmad-retrospective` (`bmad-retrospective`).
+After completing all stories in an epic, invoke the **Developer agent** (`bmad-agent-dev`) and run `bmad-retrospective` (`bmad-retrospective`).
 
 ## What You've Accomplished
 
@@ -230,8 +230,8 @@ your-project/
 | `bmad-generate-project-context`       | `bmad-generate-project-context`           | Analyst   | Create project context file                     |
 | `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`       | PM        | Break down PRD into epics            |
 | `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Validate planning cohesion           |
-| `bmad-sprint-planning`                | `bmad-sprint-planning`                | SM        | Initialize sprint tracking           |
-| `bmad-create-story`                   | `bmad-create-story`                   | SM        | Create a story file                  |
+| `bmad-sprint-planning`                | `bmad-sprint-planning`                | DEV       | Initialize sprint tracking           |
+| `bmad-create-story`                   | `bmad-create-story`                   | DEV       | Create a story file                  |
 | `bmad-dev-story`                      | `bmad-dev-story`                      | DEV       | Implement a story                    |
 | `bmad-code-review`                    | `bmad-code-review`                    | DEV       | Review implemented code              |
 
@@ -241,7 +241,7 @@ your-project/
 Only for BMad Method and Enterprise tracks. Quick Flow skips from spec to implementation.
 
 **Can I change my plan later?**
-Yes. The SM agent has a `bmad-correct-course` workflow (`bmad-correct-course`) for handling scope changes.
+Yes. The `bmad-correct-course` workflow handles scope changes mid-implementation.
 
 **What if I want to brainstorm first?**
 Invoke the Analyst agent (`bmad-agent-analyst`) and run `bmad-brainstorming` (`bmad-brainstorming`) before starting your PRD.

docs/vi-vn/404.md

@@ -0,0 +1,8 @@
+---
+title: Không Tìm Thấy Trang
+template: splash
+---
+
+Trang bạn đang tìm không tồn tại hoặc đã được chuyển đi.
+
+[Quay về trang chủ](./index.md)

docs/vi-vn/_STYLE_GUIDE.md

@@ -0,0 +1,370 @@
+---
+title: "Hướng Dẫn Phong Cách Tài Liệu"
+description: Các quy ước tài liệu dành riêng cho dự án, dựa trên phong cách tài liệu của Google và cấu trúc Diataxis
+---
+
+Dự án này tuân theo [Google Developer Documentation Style Guide](https://developers.google.com/style) và dùng [Diataxis](https://diataxis.fr/) để tổ chức nội dung. Phần dưới đây chỉ nêu các quy ước dành riêng cho dự án.
+
+## Quy tắc riêng của dự án
+
+| Quy tắc | Quy định |
+| --- | --- |
+| Không dùng đường kẻ ngang (`---`) | Làm gián đoạn dòng đọc |
+| Không dùng tiêu đề `####` | Dùng chữ in đậm hoặc admonition thay thế |
+| Không có mục "Related" hoặc "Next:" | Sidebar đã xử lý điều hướng |
+| Không dùng danh sách lồng quá sâu | Tách thành các mục riêng |
+| Không dùng code block cho nội dung không phải code | Dùng admonition cho ví dụ hội thoại |
+| Không dùng cả đoạn in đậm để làm callout | Dùng admonition thay thế |
+| Mỗi mục tối đa 1-2 admonition | Tutorial có thể dùng 3-4 admonition cho mỗi phần lớn |
+| Ô bảng / mục danh sách | Tối đa 1-2 câu |
+| Ngân sách tiêu đề | 8-12 `##` cho mỗi tài liệu; 2-3 `###` cho mỗi phần |
+
+## Admonition (cú pháp Starlight)
+
+```md
+:::tip[Tiêu đề]
+Lối tắt, best practice
+:::
+
+:::note[Tiêu đề]
+Ngữ cảnh, định nghĩa, ví dụ, điều kiện tiên quyết
+:::
+
+:::caution[Tiêu đề]
+Lưu ý, vấn đề có thể xảy ra
+:::
+
+:::danger[Tiêu đề]
+Chỉ dùng cho cảnh báo nghiêm trọng — mất dữ liệu, vấn đề bảo mật
+:::
+```
+
+### Cách dùng chuẩn
+
+| Admonition | Dùng cho |
+| --- | --- |
+| `:::note[Điều kiện tiên quyết]` | Các phụ thuộc trước khi bắt đầu |
+| `:::tip[Lối đi nhanh]` | Tóm tắt TL;DR ở đầu tài liệu |
+| `:::caution[Quan trọng]` | Cảnh báo quan trọng |
+| `:::note[Ví dụ]` | Ví dụ lệnh / phản hồi |
+
+## Mẫu bảng chuẩn
+
+**Phase:**
+
+```md
+| Phase | Tên | Điều xảy ra |
+| ----- | --- | ------------ |
+| 1     | Analysis | Brainstorm, nghiên cứu *(tùy chọn)* |
+| 2     | Planning | Yêu cầu — PRD hoặc spec *(bắt buộc)* |
+```
+
+**Skill:**
+
+```md
+| Skill | Agent | Mục đích |
+| ----- | ----- | -------- |
+| `bmad-brainstorming` | Analyst | Brainstorm cho dự án mới |
+| `bmad-create-prd` | PM | Tạo tài liệu yêu cầu sản phẩm |
+```
+
+## Khối cấu trúc thư mục
+
+Hiển thị trong phần "Bạn đã hoàn thành những gì":
+
+````md
+```
+your-project/
+├── _bmad/                                   # Cấu hình BMad
+├── _bmad-output/
+│   ├── planning-artifacts/
+│   │   └── PRD.md                           # Tài liệu yêu cầu của bạn
+│   ├── implementation-artifacts/
+│   └── project-context.md                   # Quy tắc triển khai (tùy chọn)
+└── ...
+```
+````
+
+## Cấu trúc Tutorial
+
+```text
+1. Tiêu đề + Hook (1-2 câu mô tả kết quả)
+2. Thông báo phiên bản/module (admonition info hoặc warning) (tùy chọn)
+3. Bạn sẽ học được gì (danh sách kết quả)
+4. Điều kiện tiên quyết (admonition info)
+5. Lối đi nhanh (admonition tip - tóm tắt TL;DR)
+6. Hiểu về [Chủ đề] (ngữ cảnh trước các bước - bảng cho phase/agent)
+7. Cài đặt (tùy chọn)
+8. Bước 1: [Nhiệm vụ lớn đầu tiên]
+9. Bước 2: [Nhiệm vụ lớn thứ hai]
+10. Bước 3: [Nhiệm vụ lớn thứ ba]
+11. Bạn đã hoàn thành những gì (tóm tắt + cấu trúc thư mục)
+12. Tra cứu nhanh (bảng skill)
+13. Câu hỏi thường gặp (định dạng FAQ)
+14. Nhận hỗ trợ (liên kết cộng đồng)
+15. Điểm chính cần nhớ (admonition tip)
+```
+
+### Checklist cho Tutorial
+
+- [ ] Hook mô tả kết quả trong 1-2 câu
+- [ ] Có phần "Bạn sẽ học được gì"
+- [ ] Điều kiện tiên quyết nằm trong admonition
+- [ ] Có admonition TL;DR ở đầu trang
+- [ ] Có bảng cho phase, skill, agent
+- [ ] Có phần "Bạn đã hoàn thành những gì"
+- [ ] Có bảng tra cứu nhanh
+- [ ] Có phần câu hỏi thường gặp
+- [ ] Có phần nhận hỗ trợ
+- [ ] Có admonition điểm chính ở cuối
+
+## Cấu trúc How-To
+
+```text
+1. Tiêu đề + Hook (một câu: "Sử dụng workflow `X` để...")
+2. Khi nào nên dùng (danh sách kịch bản)
+3. Khi nào nên bỏ qua (tùy chọn)
+4. Điều kiện tiên quyết (admonition note)
+5. Các bước (mục con `###` có đánh số)
+6. Bạn sẽ nhận được gì (output / artifact)
+7. Ví dụ (tùy chọn)
+8. Mẹo (tùy chọn)
+9. Bước tiếp theo (tùy chọn)
+```
+
+### Checklist cho How-To
+
+- [ ] Hook bắt đầu bằng "Sử dụng workflow `X` để..."
+- [ ] Phần "Khi nào nên dùng" có 3-5 gạch đầu dòng
+- [ ] Có liệt kê điều kiện tiên quyết
+- [ ] Các bước là mục `###` có đánh số và bắt đầu bằng động từ
+- [ ] Phần "Bạn sẽ nhận được gì" mô tả artifact đầu ra
+
+## Cấu trúc Explanation
+
+### Các loại
+
+| Loại | Ví dụ |
+| --- | --- |
+| **Trang chỉ mục / landing** | `core-concepts/index.md` |
+| **Khái niệm** | `what-are-agents.md` |
+| **Tính năng** | `quick-dev.md` |
+| **Triết lý** | `why-solutioning-matters.md` |
+| **FAQ** | `established-projects-faq.md` |
+
+### Mẫu tổng quát
+
+```text
+1. Tiêu đề + Hook (1-2 câu)
+2. Tổng quan / định nghĩa (nó là gì, vì sao quan trọng)
+3. Khái niệm chính (các mục `###`)
+4. Bảng so sánh (tùy chọn)
+5. Khi nào nên dùng / không nên dùng (tùy chọn)
+6. Sơ đồ (tùy chọn - mermaid, tối đa 1 sơ đồ mỗi tài liệu)
+7. Bước tiếp theo (tùy chọn)
+```
+
+### Trang chỉ mục / landing
+
+```text
+1. Tiêu đề + Hook (một câu)
+2. Bảng nội dung (liên kết kèm mô tả)
+3. Bắt đầu từ đâu (danh sách có đánh số)
+4. Chọn hướng đi của bạn (tùy chọn - cây quyết định)
+```
+
+### Trang giải thích khái niệm
+
+```text
+1. Tiêu đề + Hook (nó là gì)
+2. Loại / nhóm (các mục `###`) (tùy chọn)
+3. Bảng khác biệt chính
+4. Thành phần / bộ phận
+5. Nên chọn cái nào?
+6. Cách tạo / tùy chỉnh (trỏ sang how-to)
+```
+
+### Trang giải thích tính năng
+
+```text
+1. Tiêu đề + Hook (nó làm gì)
+2. Thông tin nhanh (tùy chọn - "Phù hợp với:", "Mất bao lâu:")
+3. Khi nào nên dùng / không nên dùng
+4. Cách nó hoạt động (mermaid tùy chọn)
+5. Lợi ích chính
+6. Bảng so sánh (tùy chọn)
+7. Khi nào nên nâng cấp / chuyển hướng (tùy chọn)
+```
+
+### Tài liệu về triết lý / lý do
+
+```text
+1. Tiêu đề + Hook (nguyên tắc)
+2. Vấn đề
+3. Giải pháp
+4. Nguyên tắc chính (các mục `###`)
+5. Lợi ích
+6. Khi nào áp dụng
+```
+
+### Checklist cho Explanation
+
+- [ ] Hook nêu rõ tài liệu giải thích điều gì
+- [ ] Nội dung được chia thành các phần `##` dễ quét
+- [ ] Có bảng so sánh khi có từ 3 lựa chọn trở lên
+- [ ] Sơ đồ có nhãn rõ ràng
+- [ ] Có liên kết sang how-to cho câu hỏi mang tính thủ tục
+- [ ] Mỗi tài liệu tối đa 2-3 admonition
+
+## Cấu trúc Reference
+
+### Các loại
+
+| Loại | Ví dụ |
+| --- | --- |
+| **Trang chỉ mục / landing** | `workflows/index.md` |
+| **Danh mục** | `agents/index.md` |
+| **Đào sâu** | `document-project.md` |
+| **Cấu hình** | `core-tasks.md` |
+| **Bảng thuật ngữ** | `glossary/index.md` |
+| **Tổng hợp đầy đủ** | `bmgd-workflows.md` |
+
+### Trang chỉ mục của Reference
+
+```text
+1. Tiêu đề + Hook (một câu)
+2. Các phần nội dung (`##` cho từng nhóm)
+   - Danh sách gạch đầu dòng với liên kết và mô tả
+```
+
+### Reference dạng danh mục
+
+```text
+1. Tiêu đề + Hook
+2. Các mục (`##` cho từng mục)
+   - Mô tả ngắn (một câu)
+   - **Skills:** hoặc **Thông tin chính:** ở dạng danh sách phẳng
+3. Phần dùng chung / toàn cục (`##`) (tùy chọn)
+```
+
+### Reference đào sâu theo mục
+
+```text
+1. Tiêu đề + Hook (một câu nêu mục đích)
+2. Thông tin nhanh (admonition note, tùy chọn)
+   - Module, Skill, Input, Output dưới dạng danh sách
+3. Mục đích / tổng quan (`##`)
+4. Cách gọi (code block)
+5. Các phần chính (`##` cho từng khía cạnh)
+   - Dùng `###` cho các tùy chọn con
+6. Ghi chú / lưu ý (admonition tip hoặc caution)
+```
+
+### Reference về cấu hình
+
+```text
+1. Tiêu đề + Hook
+2. Mục lục (jump link nếu có từ 4 mục trở lên)
+3. Các mục (`##` cho từng config / task)
+   - **Tóm tắt in đậm** — một câu
+   - **Dùng khi:** danh sách gạch đầu dòng
+   - **Cách hoạt động:** các bước đánh số (tối đa 3-5 bước)
+   - **Output:** kết quả mong đợi (tùy chọn)
+```
+
+### Hướng dẫn reference tổng hợp
+
+```text
+1. Tiêu đề + Hook
+2. Tổng quan (`##`)
+   - Sơ đồ hoặc bảng mô tả cách tổ chức
+3. Các phần lớn (`##` cho từng phase / nhóm)
+   - Các mục (`###` cho từng mục)
+   - Các trường chuẩn hóa: Skill, Agent, Input, Output, Description
+4. Bước tiếp theo (tùy chọn)
+```
+
+### Checklist cho Reference
+
+- [ ] Hook nêu rõ tài liệu đang tham chiếu điều gì
+- [ ] Cấu trúc phù hợp với loại reference
+- [ ] Các mục dùng cấu trúc nhất quán xuyên suốt
+- [ ] Có bảng cho dữ liệu có cấu trúc / so sánh
+- [ ] Có liên kết sang tài liệu explanation cho chiều sâu khái niệm
+- [ ] Tối đa 1-2 admonition
+
+## Cấu trúc Glossary
+
+Starlight tạo phần điều hướng "On this page" từ các tiêu đề:
+
+- Dùng `##` cho các nhóm — sẽ hiện ở thanh điều hướng bên phải
+- Đặt thuật ngữ trong bảng — gọn hơn so với tạo tiêu đề riêng cho từng thuật ngữ
+- Không chèn TOC nội tuyến — sidebar bên phải đã xử lý điều hướng
+
+### Định dạng bảng
+
+```md
+## Tên nhóm
+
+| Thuật ngữ | Định nghĩa |
+| --------- | ---------- |
+| **Agent** | AI persona chuyên biệt với chuyên môn cụ thể để dẫn dắt người dùng qua workflow. |
+| **Workflow** | Quy trình nhiều bước có hướng dẫn, điều phối hoạt động của agent AI để tạo deliverable. |
+```
+
+### Quy tắc viết định nghĩa
+
+| Nên làm | Không nên làm |
+| --- | --- |
+| Bắt đầu bằng việc nó LÀ gì hoặc LÀM gì | Bắt đầu bằng "Đây là..." hoặc "Một [thuật ngữ] là..." |
+| Giữ trong 1-2 câu | Viết thành nhiều đoạn dài |
+| Bôi đậm tên thuật ngữ trong ô | Để thuật ngữ ở dạng chữ thường |
+
+### Dấu hiệu ngữ cảnh
+
+Thêm ngữ cảnh in nghiêng ở đầu định nghĩa với các thuật ngữ có phạm vi hẹp:
+
+- `*Chỉ dành cho Quick Flow.*`
+- `*BMad Method/Enterprise.*`
+- `*Phase N.*`
+- `*BMGD.*`
+- `*Dự án hiện có.*`
+
+### Checklist cho Glossary
+
+- [ ] Thuật ngữ nằm trong bảng, không dùng tiêu đề riêng
+- [ ] Thuật ngữ được sắp theo thứ tự chữ cái trong từng nhóm
+- [ ] Định nghĩa dài 1-2 câu
+- [ ] Dấu hiệu ngữ cảnh được in nghiêng
+- [ ] Tên thuật ngữ được bôi đậm trong ô
+- [ ] Không dùng kiểu định nghĩa "Một [thuật ngữ] là..."
+
+## Phần FAQ
+
+```md
+## Các câu hỏi
+
+- [Lúc nào cũng cần kiến trúc à?](#luc-nao-cung-can-kien-truc-a)
+- [Tôi có thể đổi kế hoạch về sau không?](#toi-co-the-doi-ke-hoach-ve-sau-khong)
+
+### Lúc nào cũng cần kiến trúc à?
+
+Chỉ với nhánh BMad Method và Enterprise. Quick Flow bỏ qua để đi thẳng vào triển khai.
+
+### Tôi có thể đổi kế hoạch về sau không?
+
+Có. Workflow `bmad-correct-course` xử lý thay đổi phạm vi giữa chừng.
+
+**Có câu hỏi chưa được trả lời ở đây?** [Mở issue](...) hoặc hỏi trên [Discord](...).
+```
+
+## Các Lệnh Kiểm Tra
+
+Trước khi gửi thay đổi tài liệu:
+
+```bash
+npm run docs:fix-links            # Xem trước các sửa định dạng link
+npm run docs:fix-links -- --write # Áp dụng các sửa
+npm run docs:validate-links       # Kiểm tra link tồn tại
+npm run docs:build                # Xác minh không có lỗi build
+```

docs/vi-vn/explanation/advanced-elicitation.md

@@ -0,0 +1,49 @@
+---
+title: "Khai thác nâng cao"
+description: Buộc LLM xem xét lại kết quả của nó bằng các phương pháp lập luận có cấu trúc
+sidebar:
+  order: 6
+---
+
+Buộc LLM xem xét lại những gì nó vừa tạo ra. Bạn chọn một phương pháp lập luận, nó áp dụng phương pháp đó lên chính output của mình, rồi bạn quyết định có giữ các cải tiến hay không.
+
+## Khai thác nâng cao là gì?
+
+Đây là một lần xem xét lại có cấu trúc. Thay vì bảo AI "thử lại" hoặc "làm cho nó tốt hơn", bạn chọn một phương pháp lập luận cụ thể và AI sẽ xem lại output của chính nó dưới góc đó.
+
+Khác biệt này rất quan trọng. Yêu cầu mơ hồ sẽ tạo ra bản sửa đổi mơ hồ. Một phương pháp được gọi tên buộc AI tấn công vấn đề theo một hướng cụ thể, qua đó phát hiện những ý tưởng mà một lần thử lại chung chung sẽ bỏ lỡ.
+
+## Khi nào nên dùng
+
+- Sau khi workflow tạo nội dung và bạn muốn có phương án thay thế
+- Khi output có vẻ ổn nhưng bạn nghi vẫn còn có thể đào sâu hơn
+- Để stress-test các giả định hoặc tìm điểm yếu
+- Với nội dung quan trọng, nơi mà việc nghĩ lại sẽ có giá trị
+
+Các workflow sẽ đưa ra tùy chọn khai thác nâng cao tại các điểm quyết định - sau khi LLM tạo một kết quả, bạn sẽ được hỏi có muốn chạy nó hay không.
+
+## Nó hoạt động như thế nào
+
+1. LLM đề xuất 5 phương pháp phù hợp với nội dung của bạn
+2. Bạn chọn một phương pháp (hoặc đảo lại để xem lựa chọn khác)
+3. Phương pháp được áp dụng, các cải tiến được hiện ra
+4. Chấp nhận hoặc bỏ đi, lặp lại hoặc tiếp tục
+
+## Các phương pháp tích hợp sẵn
+
+Có hàng chục phương pháp lập luận có sẵn. Một vài ví dụ:
+
+- **Pre-mortem Analysis** - Giả sử dự án đã thất bại rồi lần ngược lại để tìm lý do
+- **First Principles Thinking** - Loại bỏ giả định, xây lại từ sự thật nền tảng
+- **Inversion** - Hỏi cách nào chắc chắn dẫn đến thất bại, rồi tránh những điều đó
+- **Red Team vs Blue Team** - Tự tấn công công việc của chính mình, rồi tự bảo vệ nó
+- **Socratic Questioning** - Chất vấn mọi khẳng định bằng "tại sao?" và "làm sao bạn biết?"
+- **Constraint Removal** - Bỏ hết ràng buộc, xem điều gì thay đổi, rồi thêm lại có chọn lọc
+- **Stakeholder Mapping** - Đánh giá lại từ góc nhìn của từng bên liên quan
+- **Analogical Reasoning** - Tìm điểm tương đồng ở lĩnh vực khác và áp dụng bài học của chúng
+
+Và còn nhiều nữa. AI sẽ chọn những lựa chọn phù hợp nhất với nội dung của bạn - bạn quyết định chạy cái nào.
+
+:::tip[Bắt đầu từ đây]
+Pre-mortem Analysis là lựa chọn đầu tiên tốt cho bất kỳ bản spec hoặc kế hoạch nào. Nó thường xuyên tìm ra các lỗ hổng mà một lần review thông thường bỏ qua.
+:::

docs/vi-vn/explanation/adversarial-review.md

@@ -0,0 +1,59 @@
+---
+title: "Đánh giá đối kháng"
+description: Kỹ thuật lập luận ép buộc giúp tránh các bản review lười kiểu "nhìn ổn"
+sidebar:
+  order: 5
+---
+
+Buộc quá trình phân tích đi sâu hơn bằng cách ép phải tìm ra vấn đề.
+
+## Đánh giá đối kháng là gì?
+
+Đây là một kỹ thuật review mà người review *bắt buộc* phải tìm thấy vấn đề. Không có chuyện "nhìn ổn". Người review chọn lập trường hoài nghi - giả sử vấn đề có tồn tại và đi tìm chúng.
+
+Đây không phải là việc cố tình tiêu cực. Đây là cách ép buộc phân tích thật sự, thay vì chỉ liếc qua và đóng dấu chấp nhận những gì vừa được nộp lên.
+
+**Quy tắc cốt lõi:** Bạn phải tìm ra vấn đề. Nếu không có phát hiện nào, quy trình sẽ dừng lại - cần phân tích lại hoặc giải thích tại sao.
+
+## Vì sao nó hiệu quả
+
+Những lần review thông thường dễ bị confirmation bias. Bạn lướt qua công việc, không có gì đập vào mắt, rồi phê duyệt. Yêu cầu "tìm vấn đề" phá vỡ mẫu này:
+
+- **Ép buộc sự kỹ lưỡng** - Không thể phê duyệt cho đến khi bạn đã đào đủ sâu để tìm thấy vấn đề
+- **Bắt được những thứ đang thiếu** - "Còn gì chưa có ở đây?" trở thành câu hỏi tự nhiên
+- **Tăng chất lượng tín hiệu** - Các phát hiện cụ thể và có thể hành động được, không phải các lo ngại mơ hồ
+- **Bất đối xứng thông tin** - Chạy review với bối cảnh mới (không có lý do gốc) để đánh giá artifact, không phải ý định
+
+## Nó được dùng ở đâu
+
+Đánh giá đối kháng xuất hiện xuyên suốt các workflow của BMad - code review, kiểm tra sẵn sàng triển khai, xác thực spec, và nhiều nơi khác. Đôi khi là bước bắt buộc, đôi khi là tùy chọn (như khai thác nâng cao hoặc party mode). Mẫu này được điều chỉnh theo artifact cần bị soi kỹ.
+
+## Vẫn cần bộ lọc của con người
+
+Vì AI *được lệnh* phải tìm vấn đề, nó sẽ tìm vấn đề - ngay cả khi chúng không tồn tại. Hãy kỳ vọng false positive: bắt bẻ những lỗi vặt, hiểu sai ý định, hoặc thậm chí tưởng tượng ra vấn đề.
+
+**Bạn là người quyết định cái nào là thật.** Xem từng phát hiện, bỏ qua nhiễu, sửa những gì quan trọng.
+
+## Ví dụ
+
+Thay vì:
+
+> "Phần triển khai xác thực có vẻ hợp lý. Đã duyệt."
+
+Một lần đánh giá đối kháng sẽ cho ra:
+
+> 1. **HIGH** - `login.ts:47` - Không có giới hạn tốc độ cho các lần đăng nhập thất bại
+> 2. **HIGH** - Session token được lưu trong localStorage (dễ bị XSS)
+> 3. **MEDIUM** - Kiểm tra mật khẩu chỉ diễn ra ở client
+> 4. **MEDIUM** - Không có audit log cho các lần đăng nhập thất bại
+> 5. **LOW** - Số magic `3600` nên được đổi thành `SESSION_TIMEOUT_SECONDS`
+
+Bản review thứ nhất có thể bỏ sót một lỗi bảo mật. Bản review thứ hai đã bắt được bốn vấn đề.
+
+## Lặp lại và lợi ích giảm dần
+
+Sau khi đã xử lý các phát hiện, hãy cân nhắc chạy lại. Lần thứ hai thường sẽ bắt thêm được vấn đề. Lần thứ ba cũng không phải lúc nào cũng vô ích. Nhưng mỗi lần đều tốn thời gian, và đến một mức nào đó bạn sẽ gặp lợi ích giảm dần - chỉ còn các bắt bẻ nhỏ và false positive.
+
+:::tip[Review tốt hơn]
+Giả sử vấn đề có tồn tại. Tìm những gì còn thiếu, không chỉ những gì sai.
+:::

docs/vi-vn/explanation/analysis-phase.md

@@ -0,0 +1,70 @@
+---
+title: "Giai đoạn Analysis: từ ý tưởng đến nền tảng"
+description: Brainstorming, research, product brief và PRFAQ là gì, và nên dùng từng công cụ khi nào
+sidebar:
+  order: 1
+---
+
+Giai đoạn Analysis (Phase 1) giúp bạn suy nghĩ rõ ràng về sản phẩm trước khi cam kết bắt tay vào xây dựng. Mọi công cụ trong giai đoạn này đều là tùy chọn, nhưng nếu bỏ qua toàn bộ phần analysis thì PRD của bạn sẽ được dựng trên giả định thay vì insight.
+
+## Vì sao cần Analysis trước Planning?
+
+PRD trả lời câu hỏi "chúng ta nên xây gì và vì sao?". Nếu đầu vào của nó là những suy nghĩ mơ hồ, bạn sẽ nhận lại một PRD mơ hồ, và mọi tài liệu phía sau đều kế thừa chính sự mơ hồ đó. Kiến trúc dựng trên một PRD yếu sẽ đặt cược sai về mặt kỹ thuật. Stories sinh ra từ một kiến trúc yếu sẽ bỏ sót edge case. Chi phí sẽ dồn lên theo từng tầng.
+
+Các công cụ analysis tồn tại để làm PRD của bạn sắc bén hơn. Chúng tiếp cận vấn đề từ nhiều góc độ khác nhau: khám phá sáng tạo, thực tế thị trường, độ rõ ràng về khách hàng, tính khả thi. Nhờ vậy, đến khi bạn ngồi xuống làm việc với PM agent, bạn đã biết mình đang xây cái gì và cho ai.
+
+## Các công cụ
+
+### Brainstorming
+
+**Nó là gì.** Một phiên sáng tạo có điều phối, sử dụng các kỹ thuật ideation đã được kiểm chứng. AI đóng vai trò như người huấn luyện, kéo ý tưởng ra từ bạn thông qua các bài tập có cấu trúc, chứ không nghĩ thay cho bạn.
+
+**Vì sao nó có mặt ở đây.** Ý tưởng thô cần không gian để phát triển trước khi bị khóa cứng thành requirement. Brainstorming tạo ra khoảng không đó. Nó đặc biệt có giá trị khi bạn có một miền vấn đề nhưng chưa có lời giải rõ ràng, hoặc khi bạn muốn khám phá nhiều hướng trước khi commit.
+
+**Khi nào nên dùng.** Bạn có một hình dung mơ hồ về thứ mình muốn xây nhưng chưa kết tinh được thành khái niệm rõ ràng. Hoặc bạn đã có concept ban đầu nhưng muốn pressure-test nó với các phương án thay thế.
+
+Xem [Brainstorming](./brainstorming.md) để hiểu sâu hơn về cách một phiên làm việc diễn ra.
+
+### Research (Thị trường, miền nghiệp vụ, kỹ thuật)
+
+**Nó là gì.** Ba workflow nghiên cứu tập trung vào các chiều khác nhau của ý tưởng. Market research xem xét đối thủ, xu hướng và cảm nhận của người dùng. Domain research xây dựng hiểu biết về miền nghiệp vụ và thuật ngữ. Technical research đánh giá tính khả thi, các lựa chọn kiến trúc và hướng triển khai.
+
+**Vì sao nó có mặt ở đây.** Xây dựng dựa trên giả định là con đường nhanh nhất để tạo ra thứ chẳng ai cần. Research đặt concept của bạn xuống mặt đất: đối thủ nào đã tồn tại, người dùng thực sự đang vật lộn với điều gì, điều gì khả thi về kỹ thuật, và bạn sẽ phải đối mặt với những ràng buộc đặc thù ngành nào.
+
+**Khi nào nên dùng.** Bạn đang bước vào một miền mới, nghi ngờ có đối thủ nhưng chưa lập bản đồ được, hoặc concept của bạn phụ thuộc vào những năng lực kỹ thuật mà bạn chưa kiểm chứng. Có thể chạy một, hai, hoặc cả ba; mỗi workflow đều đứng độc lập.
+
+### Product Brief
+
+**Nó là gì.** Một phiên discovery có hướng dẫn, tạo ra bản tóm tắt điều hành 1-2 trang cho concept sản phẩm của bạn. AI đóng vai trò Business Analyst cộng tác, giúp bạn diễn đạt tầm nhìn, đối tượng mục tiêu, giá trị cốt lõi và phạm vi.
+
+**Vì sao nó có mặt ở đây.** Product brief là con đường nhẹ nhàng hơn để đi vào planning. Nó ghi lại tầm nhìn chiến lược của bạn theo định dạng có cấu trúc và đưa thẳng vào quá trình tạo PRD. Nó hoạt động tốt nhất khi bạn đã có niềm tin tương đối chắc vào concept của mình: bạn biết khách hàng là ai, vấn đề là gì, và đại khái muốn xây gì. Brief sẽ tổ chức lại và làm sắc nét lối suy nghĩ đó.
+
+**Khi nào nên dùng.** Concept của bạn đã tương đối rõ và bạn muốn ghi lại nó một cách hiệu quả trước khi tạo PRD. Bạn tin vào hướng đi hiện tại và không cần bị thách thức giả định một cách quá quyết liệt.
+
+### PRFAQ (Working Backwards)
+
+**Nó là gì.** Phương pháp Working Backwards của Amazon được chuyển thành một thử thách tương tác. Bạn viết thông cáo báo chí công bố sản phẩm hoàn thiện trước khi tồn tại dù chỉ một dòng code, rồi trả lời những câu hỏi khó nhất mà khách hàng và stakeholder sẽ đặt ra. AI đóng vai trò product coach dai dẳng nhưng mang tính xây dựng.
+
+**Vì sao nó có mặt ở đây.** PRFAQ là con đường nghiêm ngặt hơn để đi vào planning. Nó buộc bạn đạt đến sự rõ ràng theo hướng customer-first bằng cách bắt bạn bảo vệ từng phát biểu. Nếu bạn không viết nổi một thông cáo báo chí đủ thuyết phục, sản phẩm đó chưa sẵn sàng. Nếu phần FAQ lộ ra những khoảng trống, đó chính là những khoảng trống mà bạn sẽ phát hiện muộn hơn rất nhiều, và với chi phí lớn hơn nhiều, trong lúc triển khai. Bài kiểm tra này bóc tách lối suy nghĩ yếu ngay từ sớm, khi chi phí sửa còn rẻ nhất.
+
+**Khi nào nên dùng.** Bạn muốn stress-test concept trước khi commit tài nguyên. Bạn chưa chắc người dùng có thực sự quan tâm hay không. Bạn muốn xác nhận rằng mình có thể diễn đạt một value proposition rõ ràng và có thể bảo vệ được. Hoặc đơn giản là bạn muốn dùng sự kỷ luật của Working Backwards để làm suy nghĩ của mình sắc bén hơn.
+
+## Tôi nên dùng cái nào?
+
+| Tình huống | Công cụ được khuyến nghị |
+| --------- | ------------------------ |
+| "Tôi có một ý tưởng mơ hồ, chưa biết bắt đầu từ đâu" | Brainstorming |
+| "Tôi cần hiểu thị trường trước khi quyết định" | Research |
+| "Tôi biết mình muốn xây gì rồi, chỉ cần ghi lại" | Product Brief |
+| "Tôi muốn chắc rằng ý tưởng này thực sự đáng để xây" | PRFAQ |
+| "Tôi muốn khám phá, rồi kiểm chứng, rồi ghi lại" | Brainstorming → Research → PRFAQ hoặc Brief |
+
+Product Brief và PRFAQ đều tạo ra đầu vào cho PRD. Hãy chọn một trong hai tùy vào mức độ thách thức bạn muốn. Brief là discovery mang tính cộng tác. PRFAQ là một bài kiểm tra khắc nghiệt. Cả hai đều đưa bạn tới cùng một đích; PRFAQ chỉ kiểm tra xem concept của bạn có thật sự xứng đáng để đến đó hay không.
+
+:::tip[Chưa chắc nên bắt đầu ở đâu?]
+Hãy chạy `bmad-help` và mô tả tình huống của bạn. Nó sẽ gợi ý điểm bắt đầu phù hợp dựa trên những gì bạn đã làm và điều bạn đang muốn đạt được.
+:::
+
+## Sau Analysis thì chuyện gì xảy ra?
+
+Output từ Analysis đi thẳng vào Phase 2 (Planning). Workflow tạo PRD chấp nhận product brief, tài liệu PRFAQ, kết quả research và báo cáo brainstorming làm đầu vào. Nó sẽ tổng hợp bất cứ thứ gì bạn đã tạo thành các requirement có cấu trúc. Bạn làm analysis càng kỹ, PRD của bạn càng sắc.

docs/vi-vn/explanation/brainstorming.md

@@ -0,0 +1,33 @@
+---
+title: "Động não ý tưởng"
+description: Các phiên sáng tạo tương tác sử dụng hơn 60 kỹ thuật khơi ý đã được kiểm chứng
+sidebar:
+  order: 2
+---
+
+Mở khóa sự sáng tạo của bạn thông qua quá trình khám phá có hướng dẫn.
+
+## Động não ý tưởng là gì?
+
+Chạy `bmad-brainstorming` và bạn sẽ có một người điều phối sáng tạo giúp rút ý tưởng từ chính bạn - không phải phát sinh thay bạn. AI đóng vai trò huấn luyện viên và người dẫn đường, sử dụng các kỹ thuật đã được kiểm chứng để tạo điều kiện cho những ý tưởng tốt nhất của bạn xuất hiện.
+
+**Phù hợp cho:**
+
+- Phá vỡ thế bí ý tưởng
+- Tạo ý tưởng sản phẩm hoặc tính năng
+- Xem xét vấn đề từ góc nhìn mới
+- Biến các khái niệm thô thành kế hoạch hành động
+
+## Nó hoạt động như thế nào
+
+1. **Thiết lập** - Xác định chủ đề, mục tiêu, ràng buộc
+2. **Chọn cách tiếp cận** - Tự chọn kỹ thuật, để AI đề xuất, chọn ngẫu nhiên, hoặc đi theo một luồng tiến trình
+3. **Điều phối** - Làm việc qua từng kỹ thuật bằng các câu hỏi gợi mở và huấn luyện cộng tác
+4. **Sắp xếp** - Gom ý tưởng theo chủ đề và ưu tiên hóa
+5. **Hành động** - Các ý tưởng tốt nhất sẽ được gán bước tiếp theo và chỉ số thành công
+
+Mọi thứ đều được ghi lại trong tài liệu phiên làm việc để bạn có thể xem lại sau này hoặc chia sẻ với stakeholder.
+
+:::note[Ý tưởng của bạn]
+Mọi ý tưởng đều đến từ bạn. Workflow chỉ tạo điều kiện cho insight xuất hiện - nguồn gốc vẫn là bạn.
+:::

docs/vi-vn/explanation/established-projects-faq.md

@@ -0,0 +1,51 @@
+---
+title: "FAQ cho dự án đã tồn tại"
+description: Các câu hỏi phổ biến khi dùng BMad Method trên dự án đã tồn tại
+sidebar:
+  order: 8
+---
+
+Các câu trả lời nhanh cho những câu hỏi thường gặp khi làm việc với dự án đã tồn tại bằng BMad Method (BMM).
+
+## Các câu hỏi
+
+- [Tôi có phải chạy document-project trước không?](#toi-co-phai-chay-document-project-truoc-khong)
+- [Nếu tôi quên chạy document-project thì sao?](#neu-toi-quen-chay-document-project-thi-sao)
+- [Tôi có thể dùng Quick Flow cho dự án đã tồn tại không?](#toi-co-the-dung-quick-flow-cho-du-an-da-ton-tai-khong)
+- [Nếu code hiện tại của tôi không theo best practices thì sao?](#neu-code-hien-tai-cua-toi-khong-theo-best-practices-thi-sao)
+
+### Tôi có phải chạy document-project trước không?
+
+Rất nên chạy, nhất là khi:
+
+- Không có tài liệu sẵn có
+- Tài liệu đã lỗi thời
+- Agent AI cần context về code hiện có
+
+Bạn có thể bỏ qua nếu đã có tài liệu đầy đủ, mới, bao gồm `docs/index.md`, hoặc bạn sẽ dùng công cụ/kỹ thuật khác để giúp agent khám phá hệ thống hiện có.
+
+### Nếu tôi quên chạy document-project thì sao?
+
+Không sao - bạn có thể chạy nó bất cứ lúc nào. Bạn thậm chí có thể chạy trong khi dự án đang diễn ra hoặc sau đó để giữ tài liệu luôn mới.
+
+### Tôi có thể dùng Quick Flow cho dự án đã tồn tại không?
+
+Có. Quick Flow hoạt động rất tốt với dự án đã tồn tại. Nó sẽ:
+
+- Tự động nhận diện stack hiện có
+- Phân tích pattern code hiện có
+- Phát hiện quy ước và hỏi bạn để xác nhận
+- Tạo spec giàu ngữ cảnh, tôn trọng code hiện có
+
+Rất hợp với sửa lỗi và tính năng nhỏ trong codebase sẵn có.
+
+### Nếu code hiện tại của tôi không theo best practices thì sao?
+
+Quick Flow sẽ nhận diện quy ước hiện có và hỏi: "Tôi có nên tuân theo những quy ước hiện tại này không?" Bạn là người quyết định:
+
+- **Có** → Giữ tính nhất quán với codebase hiện tại
+- **Không** → Đặt ra chuẩn mới, đồng thời ghi rõ lý do trong spec
+
+BMM tôn trọng lựa chọn của bạn - nó không ép buộc hiện đại hóa, nhưng sẽ đưa ra lựa chọn đó.
+
+**Có câu hỏi chưa được trả lời ở đây?** Hãy [mở issue](https://github.com/bmad-code-org/BMAD-METHOD/issues) hoặc hỏi trên [Discord](https://discord.gg/gk8jAdXWmj) để chúng tôi bổ sung!

docs/vi-vn/explanation/party-mode.md

@@ -0,0 +1,59 @@
+---
+title: "Party Mode"
+description: Cộng tác đa agent - đưa tất cả agent AI vào cùng một cuộc trò chuyện
+sidebar:
+  order: 7
+---
+
+Đưa tất cả agent AI của bạn vào cùng một cuộc trò chuyện.
+
+## Party Mode là gì?
+
+Chạy `bmad-party-mode` và bạn sẽ có cả đội AI trong cùng một phòng - PM, Architect, Dev, UX Designer, bất kỳ ai bạn cần. BMad Master điều phối, chọn các agent liên quan cho từng tin nhắn. Các agent trả lời đúng vai, đồng ý, phản biện, và bổ sung ý tưởng cho nhau.
+
+Cuộc trò chuyện tiếp tục lâu đến mức bạn muốn. Bạn có thể hỏi tiếp, phản biện câu trả lời, đổi hướng thảo luận - đó là một cuộc qua lại thật sự với các agent của bạn cho đến khi xong.
+
+**Phù hợp cho:**
+
+- Các quyết định lớn có đánh đổi
+- Các phiên động não ý tưởng
+- Post-mortem khi mọi thứ đi sai
+- Retrospective và lập kế hoạch sprint
+
+## Ví dụ
+
+### Gọi tên kiến trúc tệ
+
+**Bạn:** "Được rồi cả đội, sprint vừa rồi là một thảm họa. Dịch vụ xác thực sập ba lần. Ai đã làm hỏng chuyện này?"
+
+**Architect:** "Thiết kế vẫn ổn - xác thực phân tán với cơ chế fallback hợp lý. Nếu phần triển khai lệch khỏi spec..."
+
+**Dev:** "Tôi đã làm đúng theo tài liệu kiến trúc. Spec không tính đến race condition khi vô hiệu hóa session đồng thời."
+
+**PM:** "Cả hai người đều bỏ sót vấn đề lớn hơn - chúng ta không xác thực đúng yêu cầu quản lý session trong PRD. **Lỗi này là do tôi** không bắt được sớm hơn."
+
+**TEA:** "Và tôi đáng ra phải bắt được nó trong integration test. Các kịch bản test đã không bao phủ trường hợp vô hiệu hóa đồng thời."
+
+### Động não sáng tạo
+
+**Bạn:** "Làm sao để quá trình onboarding có cảm giác kỳ diệu thay vì nhàm chán?"
+
+**UX Designer:** "Bắt đầu bằng progressive disclosure - hiện tính năng khi người dùng cần, thay vì tung một tutorial dày đặc."
+
+**Storyteller:** "Nếu onboarding là một câu chuyện thì sao? Mỗi bước mở ra hành trình của một nhân vật - người dùng CHÍNH là người hùng."
+
+**Game Designer:** "Nối tiếp ý đó - nếu 'nhiệm vụ' đầu tiên thực chất giải quyết một vấn đề thật của người dùng thì sao? Họ học bằng cách làm ra giá trị ngay."
+
+### Quyết định kỹ thuật
+
+**Bạn:** "MVP nên dùng monolith hay microservices?"
+
+**Architect:** "Bắt đầu bằng monolith. Microservices thêm độ phức tạp mà bạn chưa cần ở mức 1000 người dùng."
+
+**PM:** "Đồng ý. Tốc độ ra thị trường quan trọng hơn khả năng mở rộng lý thuyết."
+
+**Dev:** "Monolith nhưng có ranh giới module rõ ràng. Nếu cần, mình có thể tách service sau."
+
+:::tip[Quyết định tốt hơn]
+Quyết định tốt hơn nhờ nhiều góc nhìn đa dạng. Chào mừng đến với party mode.
+:::

docs/vi-vn/explanation/preventing-agent-conflicts.md

@@ -0,0 +1,112 @@
+---
+title: "Ngăn xung đột giữa các agent"
+description: Cách kiến trúc ngăn xung đột khi nhiều agent cùng triển khai một hệ thống
+sidebar:
+     order: 4
+---
+
+Khi nhiều agent AI cùng triển khai các phần khác nhau của hệ thống, chúng có thể đưa ra các quyết định kỹ thuật mâu thuẫn nhau. Tài liệu kiến trúc ngăn điều đó bằng cách thiết lập các tiêu chuẩn dùng chung.
+
+## Các kiểu xung đột phổ biến
+
+### Xung đột về phong cách API
+
+Không có kiến trúc:
+- Agent A dùng REST với `/users/{id}`
+- Agent B dùng GraphQL mutations
+- Kết quả: pattern API không nhất quán, người dùng API bị rối
+
+Có kiến trúc:
+- ADR quy định: "Dùng GraphQL cho mọi giao tiếp client-server"
+- Tất cả agent theo cùng một mẫu
+
+### Xung đột về thiết kế cơ sở dữ liệu
+
+Không có kiến trúc:
+- Agent A dùng tên cột theo snake_case
+- Agent B dùng camelCase
+- Kết quả: schema không nhất quán, truy vấn khó hiểu
+
+Có kiến trúc:
+- Tài liệu standards quy định quy ước đặt tên
+- Tất cả agent theo cùng một pattern
+
+### Xung đột về quản lý state
+
+Không có kiến trúc:
+- Agent A dùng Redux cho global state
+- Agent B dùng React Context
+- Kết quả: nhiều cách quản lý state song song, độ phức tạp tăng cao
+
+Có kiến trúc:
+- ADR quy định cách quản lý state
+- Tất cả agent triển khai thống nhất
+
+## Kiến trúc ngăn xung đột bằng cách nào
+
+### 1. Quyết định rõ ràng thông qua ADR
+
+Mỗi lựa chọn công nghệ quan trọng đều được ghi lại với:
+- Context (vì sao quyết định này quan trọng)
+- Các lựa chọn đã cân nhắc (có những phương án nào)
+- Quyết định (ta đã chọn gì)
+- Lý do (tại sao lại chọn như vậy)
+- Hệ quả (các đánh đổi được chấp nhận)
+
+### 2. Hướng dẫn riêng cho FR/NFR
+
+Kiến trúc ánh xạ mỗi functional requirement sang cách tiếp cận kỹ thuật:
+- FR-001: User Management → GraphQL mutations
+- FR-002: Mobile App → Truy vấn tối ưu
+
+### 3. Tiêu chuẩn và quy ước
+
+Tài liệu hóa rõ ràng về:
+- Cấu trúc thư mục
+- Quy ước đặt tên
+- Cách tổ chức code
+- Pattern kiểm thử
+
+## Kiến trúc như một bối cảnh dùng chung
+
+Hãy xem kiến trúc là bối cảnh dùng chung mà tất cả agent đều đọc trước khi triển khai:
+
+```text
+PRD: "Cần xây gì"
+     ↓
+Kiến trúc: "Xây như thế nào"
+     ↓
+Agent A đọc kiến trúc → triển khai Epic 1
+Agent B đọc kiến trúc → triển khai Epic 2
+Agent C đọc kiến trúc → triển khai Epic 3
+     ↓
+Kết quả: Triển khai nhất quán
+```
+
+## Các chủ đề ADR quan trọng
+
+Những quyết định phổ biến giúp tránh xung đột:
+
+| Chủ đề | Ví dụ quyết định |
+| ---------------- | -------------------------------------------- |
+| API Style | GraphQL hay REST hay gRPC |
+| Database | PostgreSQL hay MongoDB |
+| Auth | JWT hay Session |
+| State Management | Redux hay Context hay Zustand |
+| Styling | CSS Modules hay Tailwind hay Styled Components |
+| Testing | Jest + Playwright hay Vitest + Cypress |
+
+## Anti-pattern cần tránh
+
+:::caution[Những lỗi thường gặp]
+- **Quyết định ngầm** - "Cứ để đó rồi tính phong cách API sau" sẽ dẫn đến không nhất quán
+- **Tài liệu hóa quá mức** - Ghi lại mọi lựa chọn nhỏ gây tê liệt phân tích
+- **Kiến trúc lỗi thời** - Tài liệu viết một lần rồi không cập nhật khiến agent đi theo pattern cũ
+:::
+
+:::tip[Cách tiếp cận đúng]
+- Tài liệu hóa những quyết định cắt ngang nhiều epic
+- Tập trung vào những khu vực dễ phát sinh xung đột
+- Cập nhật kiến trúc khi bạn học thêm
+- Dùng `bmad-correct-course` cho các thay đổi đáng kể
+:::

docs/vi-vn/explanation/project-context.md

@@ -0,0 +1,157 @@
+---
+title: "Project Context"
+description: Cách project-context.md định hướng các agent AI theo quy tắc và ưu tiên của dự án
+sidebar:
+  order: 7
+---
+
+Tệp `project-context.md` là kim chỉ nam cho việc triển khai của các agent AI trong dự án của bạn. Tương tự như một "bản hiến pháp" trong các hệ thống phát triển khác, nó ghi lại các quy tắc, pattern và ưu tiên giúp việc sinh mã được nhất quán trong mọi workflow.
+
+## Nó làm gì
+
+Các agent AI liên tục đưa ra quyết định triển khai - theo pattern nào, tổ chức code ra sao, dùng quy ước gì. Nếu không có hướng dẫn rõ ràng, chúng có thể:
+- Làm theo best practice chung chung không khớp với codebase của bạn
+- Đưa ra quyết định không nhất quán giữa các story
+- Bỏ sót yêu cầu hoặc ràng buộc đặc thù của dự án
+
+Tệp `project-context.md` giải quyết vấn đề này bằng cách tài liệu hóa những gì agent cần biết trong định dạng ngắn gọn, tối ưu cho LLM.
+
+## Nó hoạt động như thế nào
+
+Mỗi workflow triển khai đều tự động nạp `project-context.md` nếu tệp tồn tại. Workflow architect cũng nạp tệp này để tôn trọng các ưu tiên kỹ thuật của bạn khi thiết kế kiến trúc.
+
+**Được nạp bởi các workflow sau:**
+- `bmad-create-architecture` - tôn trọng ưu tiên kỹ thuật trong giai đoạn solutioning
+- `bmad-create-story` - đưa pattern của dự án vào quá trình tạo story
+- `bmad-dev-story` - định hướng các quyết định triển khai
+- `bmad-code-review` - đối chiếu với tiêu chuẩn của dự án
+- `bmad-quick-dev` - áp dụng pattern khi triển khai các spec
+- `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` - cung cấp bối cảnh cấp dự án
+
+## Khi nào nên tạo
+
+Tệp `project-context.md` hữu ích ở bất kỳ giai đoạn nào của dự án:
+
+| Tình huống | Khi nào nên tạo | Mục đích |
+|----------|----------------|---------|
+| **Dự án mới, trước kiến trúc** | Tạo thủ công, trước `bmad-create-architecture` | Ghi lại ưu tiên kỹ thuật để architect tôn trọng |
+| **Dự án mới, sau kiến trúc** | Qua `bmad-generate-project-context` hoặc tạo thủ công | Ghi lại quyết định kiến trúc cho các agent triển khai |
+| **Dự án hiện có** | Qua `bmad-generate-project-context` | Khám phá pattern hiện có để agent theo đúng quy ước |
+| **Dự án Quick Flow** | Trước hoặc trong `bmad-quick-dev` | Đảm bảo triển khai nhanh vẫn tôn trọng pattern của bạn |
+
+:::tip[Khuyến nghị]
+Với dự án mới, hãy tạo thủ công trước giai đoạn kiến trúc nếu bạn có ưu tiên kỹ thuật rõ ràng. Nếu không, hãy tạo nó sau kiến trúc để ghi lại các quyết định đã được đưa ra.
+:::
+
+## Nội dung cần có trong tệp
+
+Tệp này có hai phần chính:
+
+### Technology Stack & Versions
+
+Ghi lại framework, ngôn ngữ và công cụ dự án đang dùng, kèm phiên bản cụ thể:
+
+```markdown
+## Technology Stack & Versions
+
+- Node.js 20.x, TypeScript 5.3, React 18.2
+- State: Zustand (không dùng Redux)
+- Testing: Vitest, Playwright, MSW
+- Styling: Tailwind CSS với custom design tokens
+```
+
+### Critical Implementation Rules
+
+Ghi lại những pattern và quy ước mà agent dễ bỏ sót nếu chỉ đọc qua code:
+
+```markdown
+## Critical Implementation Rules
+
+**TypeScript Configuration:**
+- Bật strict mode - không dùng `any` nếu chưa có phê duyệt rõ ràng
+- Dùng `interface` cho public API, `type` cho union/intersection
+
+**Code Organization:**
+- Components đặt trong `/src/components/` và để `.test.tsx` cùng chỗ
+- Utilities đặt trong `/src/lib/` cho các hàm pure có thể tái sử dụng
+- Lời gọi API phải dùng `apiClient` singleton - không fetch trực tiếp
+
+**Testing Patterns:**
+- Unit test tập trung vào business logic, không soi chi tiết implementation
+- Integration test dùng MSW để mock API responses
+- E2E test chỉ bao phủ các user journey quan trọng
+
+**Framework-Specific:**
+- Mọi thao tác async dùng wrapper `handleError` để xử lý lỗi nhất quán
+- Feature flags được truy cập qua `featureFlag()` từ `@/lib/flags`
+- Route mới theo file-based routing pattern trong `/src/app/`
+```
+
+Hãy tập trung vào những gì **không hiển nhiên** - những điều agent khó suy ra chỉ từ một vài đoạn code. Không cần ghi lại các thực hành tiêu chuẩn áp dụng mọi nơi.
+
+## Tạo tệp
+
+Bạn có ba lựa chọn:
+
+### Tạo thủ công
+
+Tạo tệp tại `_bmad-output/project-context.md` và thêm các quy tắc của bạn:
+
+```bash
+# Trong thư mục gốc của dự án
+mkdir -p _bmad-output
+touch _bmad-output/project-context.md
+```
+
+Sửa tệp để thêm stack công nghệ và quy tắc triển khai. Workflow architect và implementation sẽ tự động tìm và nạp nó.
+
+### Tạo sau khi hoàn thành kiến trúc
+
+Chạy workflow `bmad-generate-project-context` sau khi bạn hoàn tất kiến trúc:
+
+```bash
+bmad-generate-project-context
+```
+
+Nó sẽ quét tài liệu kiến trúc và tệp dự án để tạo tệp context ghi lại các quyết định đã được đưa ra.
+
+### Tạo cho dự án hiện có
+
+Với dự án hiện có, chạy `bmad-generate-project-context` để khám phá pattern sẵn có:
+
+```bash
+bmad-generate-project-context
+```
+
+Workflow sẽ phân tích codebase để nhận diện quy ước, sau đó tạo tệp context cho bạn xem lại và tinh chỉnh.
+
+## Vì sao nó quan trọng
+
+Nếu không có `project-context.md`, các agent sẽ tự đưa ra giả định có thể không phù hợp với dự án:
+
+| Không có context | Có context |
+|----------------|--------------|
+| Dùng pattern chung chung | Theo đúng quy ước đã được xác lập |
+| Phong cách không nhất quán giữa các story | Triển khai nhất quán |
+| Có thể bỏ sót ràng buộc đặc thù | Tôn trọng đầy đủ yêu cầu kỹ thuật |
+| Mỗi agent tự quyết định | Tất cả agent canh hàng theo cùng quy tắc |
+
+Điều này đặc biệt quan trọng với:
+- **Quick Flow** - bỏ qua PRD và kiến trúc, nên tệp context lấp đầy khoảng trống
+- **Dự án theo nhóm** - đảm bảo tất cả agent theo cùng tiêu chuẩn
+- **Dự án hiện có** - tránh phá vỡ các pattern đã ổn định
+
+## Chỉnh sửa và cập nhật
+
+Tệp `project-context.md` là tài liệu sống. Hãy cập nhật khi:
+
+- Quyết định kiến trúc thay đổi
+- Có quy ước mới được thiết lập
+- Pattern tiến hóa trong quá trình triển khai
+- Bạn nhận ra lỗ hổng qua hành vi của agent
+
+Bạn có thể sửa thủ công bất kỳ lúc nào, hoặc chạy lại `bmad-generate-project-context` để cập nhật sau các thay đổi lớn.
+
+:::note[Vị trí tệp]
+Vị trí mặc định là `_bmad-output/project-context.md`. Các workflow tìm tệp ở đó, đồng thời cũng kiểm tra `**/project-context.md` ở bất kỳ đâu trong dự án.
+:::

docs/vi-vn/explanation/quick-dev.md

@@ -0,0 +1,73 @@
+---
+title: "Quick Dev"
+description: Giảm ma sát human-in-the-loop mà vẫn giữ các checkpoint bảo vệ chất lượng output
+sidebar:
+  order: 2
+---
+
+Đưa ý định vào, nhận thay đổi mã nguồn ra, với số lần cần con người nhảy vào giữa quy trình ít nhất có thể - nhưng không đánh đổi chất lượng.
+
+Nó cho phép model tự vận hành lâu hơn giữa các checkpoint, rồi chỉ đưa con người quay lại khi tác vụ không thể tiếp tục an toàn nếu thiếu phán đoán của con người, hoặc khi đã đến lúc review kết quả cuối.
+
+![Quick Dev workflow diagram](/diagrams/quick-dev-diagram.png)
+
+## Vì sao nó tồn tại
+
+Các lượt human-in-the-loop vừa cần thiết vừa tốn kém.
+
+LLM hiện tại vẫn thất bại theo những cách dễ đoán: hiểu sai ý định, tự điền vào khoảng trống bằng những phán đoán tự tin, lệch sang công việc không liên quan, và tạo ra các bản review nhiễu. Đồng thời, việc cần con người nhảy vào liên tục làm giảm tốc độ phát triển. Sự chú ý của con người là nút thắt.
+
+`bmad-quick-dev` cân bằng lại đánh đổi đó. Nó tin model có thể chạy tự chủ lâu hơn, nhưng chỉ sau khi workflow đã tạo được một ranh giới đủ mạnh để làm điều đó an toàn.
+
+## Thiết kế cốt lõi
+
+### 1. Nén ý định trước
+
+Workflow bắt đầu bằng việc để con người và model nén yêu cầu thành một mục tiêu thống nhất. Đầu vào có thể bắt đầu như một ý định thô, nhưng trước khi workflow tự vận hành thì nó phải đủ nhỏ, đủ rõ ràng, và đủ ít mâu thuẫn để có thể thực thi.
+
+Ý định có thể đến từ nhiều dạng: vài cụm từ, liên kết bug tracker, output từ plan mode, đoạn văn bản copy từ phiên chat, hoặc thậm chí một số story trong `epics.md` của chính BMAD. Ở trường hợp cuối, workflow không hiểu được ngữ nghĩa theo dõi story của BMAD, nhưng vẫn có thể lấy chính story đó và tiếp tục.
+
+Workflow này không loại bỏ quyền kiểm soát của con người. Nó chuyển nó về một số thời điểm có giá trị cao:
+
+- **Làm rõ ý định** - biến một yêu cầu lộn xộn thành một mục tiêu thống nhất, không mâu thuẫn ngầm
+- **Phê duyệt spec** - xác nhận rằng cách hiểu đã đóng băng là đúng thứ cần xây
+- **Review sản phẩm cuối** - checkpoint chính, nơi con người quyết định kết quả cuối có chấp nhận được hay không
+
+### 2. Định tuyến theo con đường an toàn nhỏ nhất
+
+Khi mục tiêu đã rõ, workflow sẽ quyết định đây có phải thay đổi one-shot thật sự hay cần đi theo đường đầy đủ hơn. Những thay đổi nhỏ, blast radius gần như bằng 0 có thể đi thẳng vào triển khai. Còn lại sẽ đi qua lập kế hoạch để model có được một ranh giới mạnh hơn trước khi tự chạy lâu hơn.
+
+### 3. Chạy lâu hơn với ít giám sát hơn
+
+Sau quyết định định tuyến đó, model có thể tự gánh thêm công việc. Trên con đường đầy đủ, spec đã được phê duyệt trở thành ranh giới mà model sẽ thực thi với ít giám sát hơn, và đó chính là mục tiêu của thiết kế này.
+
+### 4. Chẩn đoán lỗi ở đúng tầng
+
+Nếu triển khai sai vì ý định sai, vậy sửa code không phải cách fix đúng. Nếu code sai vì spec yếu, thì vá diff cũng không phải cách fix đúng. Workflow được thiết kế để chẩn đoán lỗi đã đi vào hệ thống từ tầng nào, quay lại đúng tầng đó, rồi sinh lại từ đấy.
+
+Các phát hiện từ review được dùng để xác định vấn đề đến từ ý định, quá trình tạo spec, hay triển khai cục bộ. Chỉ những lỗi thật sự cục bộ mới được sửa tại chỗ.
+
+### 5. Chỉ đưa con người quay lại khi cần
+
+Bước interview ý định có human-in-the-loop, nhưng nó không giống một checkpoint lặp đi lặp lại. Workflow cố gắng giảm thiểu những checkpoint lặp lại đó. Sau bước định hình ý định ban đầu, con người chủ yếu quay lại khi workflow không thể tiếp tục an toàn nếu thiếu phán đoán, và ở cuối quy trình để review kết quả.
+
+- **Xử lý khoảng trống của ý định** - quay lại khi review cho thấy workflow không thể suy ra an toàn điều được hàm ý
+
+Mọi thứ còn lại đều là ứng viên cho việc thực thi tự chủ lâu hơn. Đánh đổi này là có chủ đích. Các pattern cũ tốn nhiều sự chú ý của con người cho việc giám sát liên tục. Quick Dev đặt nhiều niềm tin hơn vào model, nhưng để dành sự chú ý của con người cho những thời điểm mà lý trí con người có đòn bẩy lớn nhất.
+
+## Vì sao hệ thống review quan trọng
+
+Giai đoạn review không chỉ để tìm bug. Nó còn để định tuyến cách sửa mà không phá hỏng động lượng.
+
+Workflow này hoạt động tốt nhất trên nền tảng có thể spawn subagent, hoặc ít nhất gọi được một LLM khác qua dòng lệnh và đợi kết quả. Nếu nền tảng của bạn không hỗ trợ sẵn, bạn có thể thêm skill để làm việc đó. Các subagent không mang context là một trụ cột trong thiết kế review.
+
+Review agentic thường sai theo hai cách:
+
+- Tạo quá nhiều phát hiện, buộc con người lọc quá nhiều nhiễu.
+- Làm lệch thay đổi hiện tại bằng cách kéo vào các vấn đề không liên quan, biến mỗi lần chạy thành một dự án dọn dẹp ad-hoc.
+
+Quick Dev xử lý cả hai bằng cách coi review là triage.
+
+Có những phát hiện thuộc về thay đổi hiện tại. Có những phát hiện không thuộc về nó. Nếu một phát hiện chỉ là ngẫu nhiên xuất hiện, không gắn nhân quả với thay đổi đang làm, workflow có thể trì hoãn nó thay vì ép con người xử lý ngay. Điều đó giữ cho mỗi lần chạy tập trung và ngăn các ngả rẽ ngẫu nhiên ăn hết ngân sách chú ý.
+
+Quá trình triage này đôi khi sẽ không hoàn hảo. Điều đó chấp nhận được. Thường tốt hơn khi đánh giá sai một số phát hiện còn hơn là nhận về hàng ngàn bình luận review giá trị thấp. Hệ thống tối ưu cho chất lượng tín hiệu, không phải độ phủ tuyệt đối.

docs/vi-vn/explanation/why-solutioning-matters.md

@@ -0,0 +1,76 @@
+---
+title: "Vì sao solutioning quan trọng"
+description: Hiểu vì sao giai đoạn solutioning là tối quan trọng đối với dự án nhiều epic
+sidebar:
+  order: 3
+---
+
+Giai đoạn 3 (Solutioning) biến **xây gì** (từ giai đoạn Planning) thành **xây như thế nào** (thiết kế kỹ thuật). Giai đoạn này ngăn xung đột giữa các agent trong dự án nhiều epic bằng cách ghi lại các quyết định kiến trúc trước khi bắt đầu triển khai.
+
+## Vấn đề nếu bỏ qua solutioning
+
+```text
+Agent 1 triển khai Epic 1 bằng REST API
+Agent 2 triển khai Epic 2 bằng GraphQL
+Kết quả: Thiết kế API không nhất quán, tích hợp trở thành ác mộng
+```
+
+Khi nhiều agent triển khai các phần khác nhau của hệ thống mà không có hướng dẫn kiến trúc chung, chúng sẽ tự đưa ra quyết định kỹ thuật độc lập và dễ xung đột với nhau.
+
+## Lợi ích khi có solutioning
+
+```text
+workflow kiến trúc quyết định: "Dùng GraphQL cho mọi API"
+Tất cả agent đều theo quyết định kiến trúc
+Kết quả: Triển khai nhất quán, không xung đột
+```
+
+Bằng cách tài liệu hóa rõ ràng các quyết định kỹ thuật, tất cả agent triển khai đồng bộ và việc tích hợp trở nên đơn giản hơn nhiều.
+
+## Solutioning và Planning khác nhau ở đâu
+
+| Khía cạnh | Planning (Giai đoạn 2) | Solutioning (Giai đoạn 3) |
+| -------- | ----------------------- | --------------------------------- |
+| Câu hỏi | Xây gì và vì sao? | Xây như thế nào? Rồi chia thành đơn vị công việc gì? |
+| Đầu ra | FR/NFR (Yêu cầu) | Kiến trúc + Epics/Stories |
+| Agent | PM | Architect → PM |
+| Đối tượng đọc | Stakeholder | Developer |
+| Tài liệu | PRD (FRs/NFRs) | Kiến trúc + Tệp Epic |
+| Mức độ | Logic nghiệp vụ | Thiết kế kỹ thuật + Phân rã công việc |
+
+## Nguyên lý cốt lõi
+
+**Biến các quyết định kỹ thuật thành tường minh và được tài liệu hóa** để tất cả agent triển khai nhất quán.
+
+Điều này ngăn chặn:
+- Xung đột phong cách API (REST vs GraphQL)
+- Không nhất quán trong thiết kế cơ sở dữ liệu
+- Bất đồng về quản lý state
+- Lệch quy ước đặt tên
+- Biến thể trong cách tiếp cận bảo mật
+
+## Khi nào solutioning là bắt buộc
+
+| Track | Có cần solutioning không? |
+|-------|----------------------|
+| Quick Flow | Không - bỏ qua hoàn toàn |
+| BMad Method đơn giản | Tùy chọn |
+| BMad Method phức tạp | Có |
+| Enterprise | Có |
+
+:::tip[Quy tắc ngón tay cái]
+Nếu bạn có nhiều epic có thể được các agent khác nhau triển khai, bạn cần solutioning.
+:::
+
+## Cái giá của việc bỏ qua
+
+Bỏ qua solutioning trong dự án phức tạp sẽ dẫn đến:
+
+- **Vấn đề tích hợp** chỉ được phát hiện giữa sprint
+- **Làm lại** vì các phần triển khai xung đột nhau
+- **Tổng thời gian phát triển dài hơn**
+- **Nợ kỹ thuật** do pattern không đồng nhất
+
+:::caution[Hệ số chi phí]
+Bắt được vấn đề canh hàng trong giai đoạn solutioning nhanh hơn gấp 10 lần so với để đến lúc triển khai mới phát hiện.
+:::

docs/vi-vn/how-to/customize-bmad.md

@@ -0,0 +1,171 @@
+---
+title: "Cách tùy chỉnh BMad"
+description: Tùy chỉnh agent, workflow và module trong khi vẫn giữ khả năng tương thích khi cập nhật
+sidebar:
+  order: 7
+---
+
+Sử dụng các tệp `.customize.yaml` để điều chỉnh hành vi, persona và menu của agent, đồng thời giữ lại thay đổi của bạn qua các lần cập nhật.
+
+## Khi nào nên dùng
+
+- Bạn muốn thay đổi tên, tính cách hoặc phong cách giao tiếp của một agent
+- Bạn cần agent ghi nhớ bối cảnh riêng của dự án
+- Bạn muốn thêm các mục menu tùy chỉnh để kích hoạt workflow hoặc prompt của riêng mình
+- Bạn muốn agent luôn thực hiện một số hành động cụ thể mỗi khi khởi động
+
+:::note[Điều kiện tiên quyết]
+- BMad đã được cài trong dự án của bạn (xem [Cách cài đặt BMad](./install-bmad.md))
+- Trình soạn thảo văn bản để chỉnh sửa tệp YAML
+:::
+
+:::caution[Giữ an toàn cho các tùy chỉnh của bạn]
+Luôn sử dụng các tệp `.customize.yaml` được mô tả trong tài liệu này thay vì sửa trực tiếp tệp agent. Trình cài đặt sẽ ghi đè các tệp agent khi cập nhật, nhưng vẫn giữ nguyên các thay đổi trong `.customize.yaml`.
+:::
+
+## Các bước thực hiện
+
+### 1. Xác định vị trí các tệp tùy chỉnh
+
+Sau khi cài đặt, bạn sẽ tìm thấy một tệp `.customize.yaml` cho mỗi agent tại:
+
+```text
+_bmad/_config/agents/
+├── core-bmad-master.customize.yaml
+├── bmm-dev.customize.yaml
+├── bmm-pm.customize.yaml
+└── ... (một tệp cho mỗi agent đã cài)
+```
+
+### 2. Chỉnh sửa tệp tùy chỉnh
+
+Mở tệp `.customize.yaml` của agent mà bạn muốn sửa. Mỗi phần đều là tùy chọn, chỉ tùy chỉnh những gì bạn cần.
+
+| Phần | Cách hoạt động | Mục đích |
+| --- | --- | --- |
+| `agent.metadata` | Thay thế | Ghi đè tên hiển thị của agent |
+| `persona` | Thay thế | Đặt vai trò, danh tính, phong cách và các nguyên tắc |
+| `memories` | Nối thêm | Thêm bối cảnh cố định mà agent luôn ghi nhớ |
+| `menu` | Nối thêm | Thêm mục menu tùy chỉnh cho workflow hoặc prompt |
+| `critical_actions` | Nối thêm | Định nghĩa hướng dẫn khởi động cho agent |
+| `prompts` | Nối thêm | Tạo các prompt tái sử dụng cho các hành động trong menu |
+
+Những phần được đánh dấu **Thay thế** sẽ ghi đè hoàn toàn cấu hình mặc định của agent. Những phần được đánh dấu **Nối thêm** sẽ bổ sung vào cấu hình hiện có.
+
+**Tên agent**
+
+Thay đổi cách agent tự giới thiệu:
+
+```yaml
+agent:
+  metadata:
+    name: 'Spongebob' # Mặc định: "Amelia"
+```
+
+**Persona**
+
+Thay thế tính cách, vai trò và phong cách giao tiếp của agent:
+
+```yaml
+persona:
+  role: 'Senior Full-Stack Engineer'
+  identity: 'Sống trong quả dứa (dưới đáy biển)'
+  communication_style: 'Spongebob gây phiền'
+  principles:
+    - 'Không lồng quá sâu, dev Spongebob ghét nesting quá 2 cấp'
+    - 'Ưu tiên composition hơn inheritance'
+```
+
+Phần `persona` sẽ thay thế toàn bộ persona mặc định, vì vậy nếu đặt phần này bạn nên cung cấp đầy đủ cả bốn trường.
+
+**Memories**
+
+Thêm bối cảnh cố định mà agent sẽ luôn nhớ:
+
+```yaml
+memories:
+  - 'Làm việc tại Krusty Krab'
+  - 'Người nổi tiếng yêu thích: David Hasselhoff'
+  - 'Đã học ở Epic 1 rằng giả vờ test đã pass là không ổn'
+```
+
+**Mục menu**
+
+Thêm các mục tùy chỉnh vào menu hiển thị của agent. Mỗi mục cần có `trigger`, đích đến (`workflow` hoặc `action`) và `description`:
+
+```yaml
+menu:
+  - trigger: my-workflow
+    workflow: 'my-custom/workflows/my-workflow.yaml'
+    description: Workflow tùy chỉnh của tôi
+  - trigger: deploy
+    action: '#deploy-prompt'
+    description: Triển khai lên production
+```
+
+**Critical Actions**
+
+Định nghĩa các hướng dẫn sẽ chạy khi agent khởi động:
+
+```yaml
+critical_actions:
+  - 'Kiểm tra pipeline CI bằng XYZ Skill và cảnh báo người dùng ngay khi khởi động nếu có việc khẩn cấp cần xử lý'
+```
+
+**Prompt tùy chỉnh**
+
+Tạo các prompt tái sử dụng để mục menu có thể tham chiếu bằng `action="#id"`:
+
+```yaml
+prompts:
+  - id: deploy-prompt
+    content: |
+      Triển khai nhánh hiện tại lên production:
+      1. Chạy toàn bộ test
+      2. Build dự án
+      3. Thực thi script triển khai
+```
+
+### 3. Áp dụng thay đổi
+
+Sau khi chỉnh sửa, cài đặt lại để áp dụng thay đổi:
+
+```bash
+npx bmad-method install
+```
+
+Trình cài đặt sẽ nhận diện bản cài đặt hiện có và đưa ra các lựa chọn sau:
+
+| Lựa chọn | Tác dụng |
+| --- | --- |
+| **Quick Update** | Cập nhật tất cả module lên phiên bản mới nhất và áp dụng các tùy chỉnh |
+| **Modify BMad Installation** | Chạy lại quy trình cài đặt đầy đủ để thêm hoặc gỡ bỏ module |
+
+Nếu chỉ thay đổi phần tùy chỉnh, **Quick Update** là lựa chọn nhanh nhất.
+
+## Khắc phục sự cố
+
+**Thay đổi không xuất hiện?**
+
+- Chạy `npx bmad-method install` và chọn **Quick Update** để áp dụng thay đổi
+- Kiểm tra YAML có hợp lệ không (thụt lề rất quan trọng)
+- Xác minh bạn đã sửa đúng tệp `.customize.yaml` của agent cần thiết
+
+**Agent không tải lên được?**
+
+- Kiểm tra lỗi cú pháp YAML bằng một công cụ kiểm tra YAML trực tuyến
+- Đảm bảo bạn không để trống trường nào sau khi bỏ comment
+- Thử khôi phục mẫu gốc rồi build lại
+
+**Cần đặt lại một agent?**
+
+- Xóa nội dung hoặc xóa tệp `.customize.yaml` của agent đó
+- Chạy `npx bmad-method install` và chọn **Quick Update** để khôi phục mặc định
+
+## Tùy chỉnh workflow
+
+Tài liệu về cách tùy chỉnh các workflow và skill sẵn có trong BMad Method sẽ được bổ sung trong thời gian tới.
+
+## Tùy chỉnh module
+
+Hướng dẫn xây dựng expansion module và tùy chỉnh các module hiện có sẽ được bổ sung trong thời gian tới.

docs/vi-vn/how-to/established-projects.md

@@ -0,0 +1,117 @@
+---
+title: "Dự án đã tồn tại"
+description: Cách sử dụng BMad Method trên các codebase hiện có
+sidebar:
+  order: 6
+---
+
+Sử dụng BMad Method hiệu quả khi làm việc với các dự án hiện có và codebase legacy.
+
+Tài liệu này mô tả workflow cốt lõi để on-board vào các dự án đã tồn tại bằng BMad Method.
+
+:::note[Điều kiện tiên quyết]
+- Đã cài BMad Method (`npx bmad-method install`)
+- Một codebase hiện có mà bạn muốn làm việc cùng
+- Quyền truy cập vào một IDE tích hợp AI (Claude Code hoặc Cursor)
+:::
+
+## Bước 1: Dọn dẹp các tài liệu lập kế hoạch đã hoàn tất
+
+Nếu bạn đã hoàn thành toàn bộ epic và story trong PRD theo quy trình BMad, hãy dọn dẹp những tệp đó. Bạn có thể lưu trữ, xóa đi, hoặc dựa vào lịch sử phiên bản nếu cần. Không nên giữ các tệp này trong:
+
+- `docs/`
+- `_bmad-output/planning-artifacts/`
+- `_bmad-output/implementation-artifacts/`
+
+## Bước 2: Tạo Project Context
+
+:::tip[Khuyến dùng cho dự án hiện có]
+Hãy tạo `project-context.md` để ghi lại các pattern và quy ước trong codebase hiện tại. Điều này giúp các agent AI tuân theo các thực hành sẵn có khi thực hiện thay đổi.
+:::
+
+Chạy workflow tạo project context:
+
+```bash
+bmad-generate-project-context
+```
+
+Workflow này sẽ quét codebase để nhận diện:
+- Stack công nghệ và các phiên bản
+- Các pattern tổ chức code
+- Quy ước đặt tên
+- Cách tiếp cận kiểm thử
+- Các pattern đặc thù framework
+
+Bạn có thể xem lại và chỉnh sửa tệp được tạo, hoặc tự tạo tệp tại `_bmad-output/project-context.md` nếu muốn.
+
+[Tìm hiểu thêm về project context](../explanation/project-context.md)
+
+## Bước 3: Duy trì tài liệu dự án chất lượng
+
+Thư mục `docs/` của bạn nên chứa tài liệu ngắn gọn, có tổ chức tốt, và phản ánh chính xác dự án:
+
+- Mục tiêu và lý do kinh doanh
+- Quy tắc nghiệp vụ
+- Kiến trúc
+- Bất kỳ thông tin dự án nào khác có liên quan
+
+Với các dự án phức tạp, hãy cân nhắc dùng workflow `bmad-document-project`. Nó có các biến thể lúc chạy có thể quét toàn bộ dự án và tài liệu hóa trạng thái thực tế hiện tại của hệ thống.
+
+## Bước 4: Nhờ trợ giúp
+
+### BMad-Help: Điểm bắt đầu của bạn
+
+**Hãy chạy `bmad-help` bất cứ lúc nào bạn không chắc cần làm gì tiếp theo.** Công cụ hướng dẫn thông minh này:
+
+- Kiểm tra dự án để xem những gì đã được hoàn thành
+- Đưa ra tùy chọn dựa trên các module bạn đã cài
+- Hiểu các câu hỏi bằng ngôn ngữ tự nhiên
+
+```text
+bmad-help Tôi có một ứng dụng Rails đã tồn tại, tôi nên bắt đầu từ đâu?
+bmad-help Điểm khác nhau giữa quick-flow và full method là gì?
+bmad-help Cho tôi xem những workflow đang có
+```
+
+BMad-Help cũng **tự động chạy ở cuối mỗi workflow**, đưa ra hướng dẫn rõ ràng về việc cần làm tiếp theo.
+
+### Chọn cách tiếp cận
+
+Bạn có hai lựa chọn chính, tùy thuộc vào phạm vi thay đổi:
+
+| Phạm vi | Cách tiếp cận được khuyến nghị |
+| --- | --- |
+| **Cập nhật hoặc bổ sung nhỏ** | Chạy `bmad-quick-dev` để làm rõ ý định, lập kế hoạch, triển khai và review trong một workflow duy nhất. Quy trình BMad Method đầy đủ có thể là quá mức cần thiết. |
+| **Thay đổi hoặc bổ sung lớn** | Bắt đầu với BMad Method, áp dụng mức độ chặt chẽ phù hợp với nhu cầu của bạn. |
+
+### Khi tạo PRD
+
+Khi tạo brief hoặc đi thẳng vào PRD, đảm bảo agent:
+
+- Tìm và phân tích tài liệu dự án hiện có
+- Đọc đúng bối cảnh về hệ thống hiện tại của bạn
+
+Bạn có thể chủ động hướng dẫn agent, nhưng mục tiêu là đảm bảo tính năng mới tích hợp tốt với hệ thống đã có.
+
+### Cân nhắc về UX
+
+Công việc UX là tùy chọn. Quyết định này không phụ thuộc vào việc dự án có UX hay không, mà phụ thuộc vào:
+
+- Bạn có định thay đổi UX hay không
+- Bạn có cần thiết kế hay pattern UX mới đáng kể hay không
+
+Nếu thay đổi của bạn chỉ là những cập nhật nhỏ trên các màn hình hiện có mà bạn đã hài lòng, thì không cần một quy trình UX đầy đủ.
+
+### Cân nhắc về kiến trúc
+
+Khi làm kiến trúc, đảm bảo kiến trúc sư:
+
+- Sử dụng đúng các tệp tài liệu cần thiết
+- Quét codebase hiện có
+
+Cần đặc biệt chú ý để tránh tái phát minh bánh xe hoặc đưa ra quyết định không phù hợp với kiến trúc hiện tại.
+
+## Thông tin thêm
+
+- **[Quick Fixes](./quick-fixes.md)** - Sửa lỗi và thay đổi ad-hoc
+- **[Câu hỏi thường gặp cho dự án đã tồn tại](../explanation/established-projects-faq.md)** - Những câu hỏi phổ biến khi làm việc với dự án đã tồn tại

docs/vi-vn/how-to/get-answers-about-bmad.md

@@ -0,0 +1,135 @@
+---
+title: "Cách tìm câu trả lời về BMad"
+description: Sử dụng LLM để tự nhanh chóng trả lời các câu hỏi về BMad
+sidebar:
+        order: 4
+---
+
+## Bắt đầu tại đây: BMad-Help
+
+**Cách nhanh nhất để tìm câu trả lời về BMad là dùng skill `bmad-help`.** Đây là công cụ hướng dẫn thông minh có thể trả lời hơn 80% các câu hỏi và có sẵn ngay trong IDE khi bạn làm việc.
+
+BMad-Help không chỉ là công cụ tra cứu, nó còn:
+- **Kiểm tra dự án của bạn** để xem những gì đã hoàn thành
+- **Hiểu ngôn ngữ tự nhiên** - đặt câu hỏi bằng ngôn ngữ bình thường
+- **Thay đổi theo module đã cài** - hiển thị các lựa chọn liên quan
+- **Tự động chạy sau workflow** - nói rõ bạn cần làm gì tiếp theo
+- **Đề xuất tác vụ đầu tiên cần thiết** - không cần đoán nên bắt đầu từ đâu
+
+### Cách dùng BMad-Help
+
+Gọi nó trực tiếp trong phiên AI của bạn:
+
+```text
+bmad-help
+```
+
+:::tip
+Bạn cũng có thể dùng `/bmad-help` hoặc `$bmad-help` tùy nền tảng, nhưng chỉ `bmad-help` là cách nên hoạt động mọi nơi.
+:::
+
+Kết hợp với câu hỏi ngôn ngữ tự nhiên:
+
+```text
+bmad-help Tôi có ý tưởng SaaS và đã biết tất cả tính năng. Tôi nên bắt đầu từ đâu?
+bmad-help Tôi có những lựa chọn nào cho thiết kế UX?
+bmad-help Tôi đang bị mắc ở workflow PRD
+bmad-help Cho tôi xem tôi đã làm được gì đến giờ
+```
+
+BMad-Help sẽ trả lời:
+- Điều gì được khuyến nghị cho tình huống của bạn
+- Tác vụ đầu tiên cần thiết là gì
+- Phần còn lại của quy trình trông thế nào
+
+## Khi nào nên dùng tài liệu này
+
+Hãy xem phần này khi:
+- Bạn muốn hiểu kiến trúc hoặc nội bộ của BMad
+- Bạn cần câu trả lời nằm ngoài phạm vi BMad-Help cung cấp
+- Bạn đang nghiên cứu BMad trước khi cài đặt
+- Bạn muốn tự khám phá source code trực tiếp
+
+## Các bước thực hiện
+
+### 1. Chọn nguồn thông tin
+
+| Nguồn | Phù hợp nhất cho | Ví dụ |
+| --- | --- | --- |
+| **Thư mục `_bmad`** | Cách BMad vận hành: agent, workflow, prompt | "PM agent làm gì?" |
+| **Toàn bộ repo GitHub** | Lịch sử, installer, kiến trúc | "v6 thay đổi gì?" |
+| **`llms-full.txt`** | Tổng quan nhanh từ tài liệu | "Giải thích bốn giai đoạn của BMad" |
+
+Thư mục `_bmad` được tạo khi bạn cài đặt BMad. Nếu chưa có, hãy clone repo thay thế.
+
+### 2. Cho AI của bạn truy cập nguồn thông tin
+
+**Nếu AI của bạn đọc được tệp (Claude Code, Cursor, ...):**
+
+- **Đã cài BMad:** Trỏ đến thư mục `_bmad` và hỏi trực tiếp
+- **Cần bối cảnh sâu hơn:** Clone [repo đầy đủ](https://github.com/bmad-code-org/BMAD-METHOD)
+
+**Nếu bạn dùng ChatGPT hoặc Claude.ai:**
+
+Nạp `llms-full.txt` vào phiên làm việc:
+
+```text
+https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
+```
+
+### 3. Đặt câu hỏi
+
+:::note[Ví dụ]
+**Q:** "Hãy chỉ tôi cách nhanh nhất để xây dựng một thứ gì đó bằng BMad"
+
+**A:** Dùng Quick Flow: Chạy `bmad-quick-dev` - nó sẽ làm rõ ý định, lập kế hoạch, triển khai, review và trình bày kết quả trong một workflow duy nhất, bỏ qua các giai đoạn lập kế hoạch đầy đủ.
+:::
+
+## Bạn nhận được gì
+
+Các câu trả lời trực tiếp về BMad: agent hoạt động ra sao, workflow làm gì, tại sao cấu trúc lại được tổ chức như vậy, mà không cần chờ người khác trả lời.
+
+## Mẹo
+
+- **Xác minh những câu trả lời gây bất ngờ** - LLM vẫn có lúc nhầm. Hãy kiểm tra tệp nguồn hoặc hỏi trên Discord.
+- **Đặt câu hỏi cụ thể** - "Bước 3 trong workflow PRD làm gì?" tốt hơn "PRD hoạt động ra sao?"
+
+## Vẫn bị mắc?
+
+Đã thử cách tiếp cận bằng LLM mà vẫn cần trợ giúp? Lúc này bạn đã có một câu hỏi tốt hơn để đem đi hỏi.
+
+| Kênh | Dùng cho |
+| --- | --- |
+| `#bmad-method-help` | Câu hỏi nhanh (trò chuyện thời gian thực) |
+| `help-requests` forum | Câu hỏi chi tiết (có thể tìm lại, tồn tại lâu dài) |
+| `#suggestions-feedback` | Ý tưởng và đề xuất tính năng |
+| `#report-bugs-and-issues` | Báo cáo lỗi |
+
+**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) (dành cho các lỗi rõ ràng)
+
+*Chính bạn,*
+        *đang mắc kẹt*
+             *trong hàng đợi -*
+                      *đợi*
+                              *ai?*
+
+*Mã nguồn*
+        *nằm ngay đó,*
+                *rõ như ban ngày!*
+
+*Hãy trỏ*
+        *cho máy của bạn.*
+                    *Thả nó đi.*
+
+*Nó đọc.*
+        *Nó nói.*
+                *Cứ hỏi -*
+
+*Sao phải chờ*
+        *đến ngày mai*
+                *khi bạn đã có*
+                        *ngày hôm nay?*
+
+*- Claude*

docs/vi-vn/how-to/install-bmad.md

@@ -0,0 +1,116 @@
+---
+title: "Cách cài đặt BMad"
+description: Hướng dẫn từng bước để cài đặt BMad vào dự án của bạn
+sidebar:
+  order: 1
+---
+
+Sử dụng lệnh `npx bmad-method install` để thiết lập BMad trong dự án của bạn với các module và công cụ AI theo lựa chọn.
+
+Nếu bạn muốn dùng trình cài đặt không tương tác và cung cấp toàn bộ tùy chọn ngay trên dòng lệnh, xem [hướng dẫn này](./non-interactive-installation.md).
+
+## Khi nào nên dùng
+
+- Bắt đầu một dự án mới với BMad
+- Thêm BMad vào một codebase hiện có
+- Cập nhật bản cài đặt BMad hiện tại
+
+:::note[Điều kiện tiên quyết]
+- **Node.js** 20+ (bắt buộc cho trình cài đặt)
+- **Git** (khuyến nghị)
+- **Công cụ AI** (Claude Code, Cursor, hoặc tương tự)
+:::
+
+## Các bước thực hiện
+
+### 1. Chạy trình cài đặt
+
+```bash
+npx bmad-method install
+```
+
+:::tip[Muốn dùng bản prerelease mới nhất?]
+Sử dụng dist-tag `next`:
+```bash
+npx bmad-method@next install
+```
+
+Cách này giúp bạn nhận các thay đổi mới sớm hơn, đổi lại khả năng biến động cao hơn bản cài đặt mặc định.
+:::
+
+:::tip[Bản rất mới]
+Để cài đặt trực tiếp từ nhánh `main` mới nhất (có thể không ổn định):
+```bash
+npx github:bmad-code-org/BMAD-METHOD install
+```
+:::
+
+### 2. Chọn vị trí cài đặt
+
+Trình cài đặt sẽ hỏi bạn muốn đặt các tệp BMad ở đâu:
+
+- Thư mục hiện tại (khuyến nghị cho dự án mới nếu bạn tự tạo thư mục và chạy lệnh từ bên trong nó)
+- Đường dẫn tùy chọn
+
+### 3. Chọn công cụ AI
+
+Chọn các công cụ AI bạn đang dùng:
+
+- Claude Code
+- Cursor
+- Các công cụ khác
+
+Mỗi công cụ có cách tích hợp skill riêng. Trình cài đặt sẽ tạo các tệp prompt nhỏ để kích hoạt workflow và agent, và đặt chúng vào đúng vị trí mà công cụ của bạn mong đợi.
+
+:::note[Kích hoạt skill]
+Một số nền tảng yêu cầu bật skill trong cài đặt trước khi chúng xuất hiện. Nếu bạn đã cài BMad mà chưa thấy skill, hãy kiểm tra cài đặt của nền tảng hoặc hỏi trợ lý AI cách bật skill.
+:::
+
+### 4. Chọn module
+
+Trình cài đặt sẽ hiện các module có sẵn. Chọn những module bạn cần - phần lớn người dùng chỉ cần **BMad Method** (module phát triển phần mềm).
+
+### 5. Làm theo các prompt
+
+Trình cài đặt sẽ hướng dẫn các bước còn lại - nội dung tùy chỉnh, cài đặt, và các tùy chọn khác.
+
+## Bạn nhận được gì
+
+```text
+du-an-cua-ban/
+├── _bmad/
+│   ├── bmm/            # Các module bạn đã chọn
+│   │   └── config.yaml # Cài đặt module (nếu bạn cần thay đổi sau này)
+│   ├── core/           # Module core bắt buộc
+│   └── ...
+├── _bmad-output/       # Các artifact được tạo ra
+├── .claude/            # Claude Code skills (nếu dùng Claude Code)
+│   └── skills/
+│       ├── bmad-help/
+│       ├── bmad-persona/
+│       └── ...
+└── .cursor/            # Cursor skills (nếu dùng Cursor)
+    └── skills/
+        └── ...
+```
+
+## Xác minh cài đặt
+
+Chạy `bmad-help` để xác minh mọi thứ hoạt động và xem bạn nên làm gì tiếp theo.
+
+**BMad-Help là công cụ hướng dẫn thông minh** sẽ:
+- Xác nhận bản cài đặt hoạt động đúng
+- Hiển thị những gì có sẵn dựa trên module đã cài
+- Đề xuất bước đầu tiên của bạn
+
+Bạn cũng có thể hỏi nó:
+```text
+bmad-help Tôi vừa cài xong, giờ nên làm gì đầu tiên?
+bmad-help Tôi có những lựa chọn nào cho một dự án SaaS?
+```
+
+## Khắc phục sự cố
+
+**Trình cài đặt báo lỗi** - Sao chép toàn bộ output vào trợ lý AI của bạn và để nó phân tích.
+
+**Cài đặt xong nhưng sau đó có thứ không hoạt động** - AI của bạn cần bối cảnh BMad để hỗ trợ. Xem [Cách tìm câu trả lời về BMad](./get-answers-about-bmad.md) để biết cách cho AI truy cập đúng nguồn thông tin.

docs/vi-vn/how-to/non-interactive-installation.md

@@ -0,0 +1,184 @@
+---
+title: Cài đặt không tương tác
+description: Cài đặt BMad bằng các cờ dòng lệnh cho pipeline CI/CD và triển khai tự động
+sidebar:
+  order: 2
+---
+
+Sử dụng các cờ dòng lệnh để cài đặt BMad mà không cần tương tác. Cách này hữu ích cho:
+
+## Khi nào nên dùng
+
+- Triển khai tự động và pipeline CI/CD
+- Cài đặt bằng script
+- Cài đặt hàng loạt trên nhiều dự án
+- Cài đặt nhanh với cấu hình đã biết trước
+
+:::note[Điều kiện tiên quyết]
+Yêu cầu [Node.js](https://nodejs.org) v20+ và `npx` (đi kèm với npm).
+:::
+
+## Các cờ khả dụng
+
+### Tùy chọn cài đặt
+
+| Cờ | Mô tả | Ví dụ |
+|------|-------------|---------|
+| `--directory <path>` | Thư mục cài đặt | `--directory ~/projects/myapp` |
+| `--modules <modules>` | Danh sách ID module, cách nhau bởi dấu phẩy | `--modules bmm,bmb` |
+| `--tools <tools>` | Danh sách ID công cụ/IDE, cách nhau bởi dấu phẩy (dùng `none` để bỏ qua) | `--tools claude-code,cursor` hoặc `--tools none` |
+| `--custom-content <paths>` | Danh sách đường dẫn đến module tùy chỉnh, cách nhau bởi dấu phẩy | `--custom-content ~/my-module,~/another-module` |
+| `--action <type>` | Hành động cho bản cài đặt hiện có: `install` (mặc định), `update`, hoặc `quick-update` | `--action quick-update` |
+
+### Cấu hình cốt lõi
+
+| Cờ | Mô tả | Mặc định |
+|------|-------------|---------|
+| `--user-name <name>` | Tên để agent sử dụng | Tên người dùng hệ thống |
+| `--communication-language <lang>` | Ngôn ngữ giao tiếp của agent | Tiếng Anh |
+| `--document-output-language <lang>` | Ngôn ngữ đầu ra tài liệu | Tiếng Anh |
+| `--output-folder <path>` | Đường dẫn thư mục output (xem quy tắc resolve bên dưới) | `_bmad-output` |
+
+#### Quy tắc resolve đường dẫn output folder
+
+Giá trị truyền vào `--output-folder` (hoặc nhập ở chế độ tương tác) sẽ được resolve theo các quy tắc sau:
+
+| Loại đầu vào | Ví dụ | Được resolve thành |
+|------|-------------|---------|
+| Đường dẫn tương đối (mặc định) | `_bmad-output` | `<project-root>/_bmad-output` |
+| Đường dẫn tương đối có traversal | `../../shared-outputs` | Đường dẫn tuyệt đối đã được chuẩn hóa, ví dụ `/Users/me/shared-outputs` |
+| Đường dẫn tuyệt đối | `/Users/me/shared-outputs` | Giữ nguyên như đã nhập, **không** thêm project root vào trước |
+
+Đường dẫn sau khi resolve là đường dẫn mà agent và workflow sẽ dùng lúc runtime để ghi file đầu ra. Việc dùng đường dẫn tuyệt đối hoặc đường dẫn tương đối có traversal cho phép bạn chuyển toàn bộ artifact sinh ra sang một thư mục nằm ngoài cây dự án, hữu ích với thư mục dùng chung hoặc cấu trúc monorepo.
+
+### Tùy chọn khác
+
+| Cờ | Mô tả |
+|------|-------------|
+| `-y, --yes` | Chấp nhận toàn bộ mặc định và bỏ qua prompt |
+| `-d, --debug` | Bật output debug cho quá trình tạo manifest |
+
+## ID module
+
+Những ID module có thể dùng với cờ `--modules`:
+
+- `bmm` - BMad Method Master
+- `bmb` - BMad Builder
+
+Kiểm tra [BMad registry](https://github.com/bmad-code-org) để xem các module ngoài được hỗ trợ.
+
+## ID công cụ/IDE
+
+Những ID công cụ có thể dùng với cờ `--tools`:
+
+**Khuyến dùng:** `claude-code`, `cursor`
+
+Chạy `npx bmad-method install` một lần ở chế độ tương tác để xem danh sách đầy đủ hiện tại của các công cụ được hỗ trợ, hoặc xem [cấu hình platform codes](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml).
+
+## Các chế độ cài đặt
+
+| Chế độ | Mô tả | Ví dụ |
+|------|-------------|---------|
+| Hoàn toàn không tương tác | Cung cấp đầy đủ cờ để bỏ qua tất cả prompt | `npx bmad-method install --directory . --modules bmm --tools claude-code --yes` |
+| Bán tương tác | Cung cấp một số cờ, BMad hỏi thêm phần còn lại | `npx bmad-method install --directory . --modules bmm` |
+| Chỉ dùng mặc định | Chấp nhận tất cả giá trị mặc định với `-y` | `npx bmad-method install --yes` |
+| Không cấu hình công cụ | Bỏ qua cấu hình công cụ/IDE | `npx bmad-method install --modules bmm --tools none` |
+
+## Ví dụ
+
+### Cài đặt cho 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 English \
+  --document-output-language English \
+  --output-folder _bmad-output \
+  --yes
+```
+
+### Cập nhật bản cài đặt hiện có
+
+```bash
+npx bmad-method install \
+  --directory ~/projects/myapp \
+  --action update \
+  --modules bmm,bmb,custom-module
+```
+
+### Quick Update (giữ nguyên cài đặt)
+
+```bash
+npx bmad-method install \
+  --directory ~/projects/myapp \
+  --action quick-update
+```
+
+### Cài đặt với nội dung tùy chỉnh
+
+```bash
+npx bmad-method install \
+  --directory ~/projects/myapp \
+  --modules bmm \
+  --custom-content ~/my-custom-module,~/another-module \
+  --tools claude-code
+```
+
+## Bạn nhận được gì
+
+- Thư mục `_bmad/` đã được cấu hình đầy đủ trong dự án của bạn
+- Agent và workflow đã được cấu hình theo module và công cụ bạn chọn
+- Thư mục `_bmad-output/` để lưu các artifact được tạo
+
+## Kiểm tra và xử lý lỗi
+
+BMad sẽ kiểm tra tất cả các cờ được cung cấp:
+
+- **Directory** - Phải là đường dẫn hợp lệ và có quyền ghi
+- **Modules** - Cảnh báo nếu ID module không hợp lệ (nhưng không thất bại)
+- **Tools** - Cảnh báo nếu ID công cụ không hợp lệ (nhưng không thất bại)
+- **Custom Content** - Mỗi đường dẫn phải chứa tệp `module.yaml` hợp lệ
+- **Action** - Phải là một trong: `install`, `update`, `quick-update`
+
+Giá trị không hợp lệ sẽ dẫn đến một trong các trường hợp sau:
+1. Hiện lỗi và thoát (với các tùy chọn quan trọng như directory)
+2. Hiện cảnh báo và bỏ qua (với mục tùy chọn như custom content)
+3. Quay lại hỏi interactive (với giá trị bắt buộc bị thiếu)
+
+:::tip[Thực hành tốt]
+- Dùng đường dẫn tuyệt đối cho `--directory` để tránh nhầm lẫn
+- Dùng đường dẫn tuyệt đối cho `--output-folder` khi bạn muốn ghi artifact ra ngoài cây dự án, ví dụ vào một thư mục output dùng chung trong monorepo
+- Thử nghiệm cờ ở máy local trước khi đưa vào pipeline CI/CD
+- Kết hợp với `-y` nếu bạn muốn cài đặt hoàn toàn không cần can thiệp
+- Dùng `--debug` nếu gặp vấn đề trong quá trình cài đặt
+:::
+
+## Khắc phục sự cố
+
+### Cài đặt thất bại với lỗi "Invalid directory"
+
+- Thư mục đích phải tồn tại (hoặc thư mục cha của nó phải tồn tại)
+- Bạn cần quyền ghi
+- Đường dẫn phải là tuyệt đối, hoặc tương đối đúng với thư mục hiện tại
+
+### Không tìm thấy module
+
+- Xác minh ID module có đúng không
+- Module bên ngoài phải có sẵn trong registry
+
+### Đường dẫn custom content không hợp lệ
+
+Đảm bảo mỗi đường dẫn custom content:
+- Trỏ tới một thư mục
+- Chứa tệp `module.yaml` ở cấp gốc
+- Có trường `code` trong tệp `module.yaml`
+
+:::note[Vẫn bị mắc?]
+Chạy với `--debug` để xem output chi tiết, thử chế độ interactive để cô lập vấn đề, hoặc báo cáo tại <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
+:::

docs/vi-vn/how-to/project-context.md

@@ -0,0 +1,127 @@
+---
+title: "Quản lý Project Context"
+description: Tạo và duy trì project-context.md để định hướng cho các agent AI
+sidebar:
+  order: 8
+---
+
+Sử dụng tệp `project-context.md` để đảm bảo các agent AI tuân theo ưu tiên kỹ thuật và quy tắc triển khai của dự án trong suốt mọi workflow. Để đảm bảo tệp này luôn sẵn có, bạn cũng có thể thêm dòng `Important project context and conventions are located in [path to project context]/project-context.md` vào file context của công cụ hoặc file always rules của bạn (như `AGENTS.md`).
+
+:::note[Điều kiện tiên quyết]
+- Đã cài BMad Method
+- Hiểu stack công nghệ và các quy ước của dự án
+:::
+
+## Khi nào nên dùng
+
+- Bạn có các ưu tiên kỹ thuật rõ ràng trước khi bắt đầu làm kiến trúc
+- Bạn đã hoàn thành kiến trúc và muốn ghi lại các quyết định để phục vụ triển khai
+- Bạn đang làm việc với một codebase hiện có có những pattern đã ổn định
+- Bạn thấy các agent đưa ra quyết định không nhất quán giữa các story
+
+## Bước 1: Chọn cách tiếp cận
+
+**Tự tạo bằng tay** - Phù hợp nhất khi bạn biết rõ cần tài liệu hóa quy tắc nào
+
+**Tạo sau kiến trúc** - Phù hợp để ghi lại các quyết định đã được đưa ra trong giai đoạn solutioning
+
+**Tạo cho dự án hiện có** - Phù hợp để khám phá pattern trong các codebase đã tồn tại
+
+## Bước 2: Tạo tệp
+
+### Lựa chọn A: Tạo thủ công
+
+Tạo tệp tại `_bmad-output/project-context.md`:
+
+```bash
+mkdir -p _bmad-output
+touch _bmad-output/project-context.md
+```
+
+Thêm stack công nghệ và các quy tắc triển khai của bạn:
+
+```markdown
+---
+project_name: 'MyProject'
+user_name: 'YourName'
+date: '2026-02-15'
+sections_completed: ['technology_stack', 'critical_rules']
+---
+
+# Project Context for AI Agents
+
+## Technology Stack & Versions
+
+- Node.js 20.x, TypeScript 5.3, React 18.2
+- State: Zustand
+- Testing: Vitest, Playwright
+- Styling: Tailwind CSS
+
+## Critical Implementation Rules
+
+**TypeScript:**
+- Strict mode enabled, no `any` types
+- Use `interface` for public APIs, `type` for unions
+
+**Code Organization:**
+- Components in `/src/components/` with co-located tests
+- API calls use `apiClient` singleton — never fetch directly
+
+**Testing:**
+- Unit tests focus on business logic
+- Integration tests use MSW for API mocking
+```
+
+### Lựa chọn B: Tạo sau khi hoàn thành kiến trúc
+
+Chạy workflow trong một phiên chat mới:
+
+```bash
+bmad-generate-project-context
+```
+
+Workflow sẽ quét tài liệu kiến trúc và tệp dự án để tạo tệp context ghi lại các quyết định đã được đưa ra.
+
+### Lựa chọn C: Tạo cho dự án hiện có
+
+Với các dự án hiện có, chạy:
+
+```bash
+bmad-generate-project-context
+```
+
+Workflow sẽ phân tích codebase để nhận diện quy ước, sau đó tạo tệp context để bạn xem lại và chỉnh sửa.
+
+## Bước 3: Xác minh nội dung
+
+Xem lại tệp được tạo và đảm bảo nó ghi đúng:
+
+- Các phiên bản công nghệ chính xác
+- Đúng các quy ước thực tế của bạn (không phải các best practice chung chung)
+- Các quy tắc giúp tránh những lỗi thường gặp
+- Các pattern đặc thù framework
+
+Chỉnh sửa thủ công để thêm phần còn thiếu hoặc loại bỏ những chỗ không chính xác.
+
+## Bạn nhận được gì
+
+Một tệp `project-context.md` sẽ:
+
+- Đảm bảo tất cả agent tuân theo cùng một bộ quy ước
+- Ngăn các quyết định không nhất quán giữa các story
+- Ghi lại các quyết định kiến trúc cho giai đoạn triển khai
+- Làm tài liệu tham chiếu cho các pattern và quy tắc của dự án
+
+## Mẹo
+
+:::tip[Thực hành tốt]
+- **Tập trung vào điều không hiển nhiên** - Ghi lại những pattern agent dễ bỏ sót (ví dụ: "Dùng JSDoc cho mọi lớp public"), thay vì các quy tắc phổ quát như "đặt tên biến có ý nghĩa".
+- **Gọn nhẹ** - Tệp này được nạp trong mọi workflow triển khai. Tệp quá dài sẽ tốn context. Hãy bỏ qua nội dung chỉ áp dụng cho phạm vi hẹp hoặc một vài story cụ thể.
+- **Cập nhật khi cần** - Sửa thủ công khi pattern thay đổi, hoặc tạo lại sau các thay đổi kiến trúc lớn.
+- Áp dụng được cho cả Quick Flow lẫn quy trình BMad Method đầy đủ.
+:::
+
+## Bước tiếp theo
+
+- [**Giải thích về Project Context**](../explanation/project-context.md) - Tìm hiểu sâu hơn cách nó hoạt động
+- [**Bản đồ workflow**](../reference/workflow-map.md) - Xem workflow nào sử dụng project context

docs/vi-vn/how-to/quick-fixes.md

@@ -0,0 +1,95 @@
+---
+title: "Quick Fixes"
+description: Cách thực hiện các sửa nhanh và thay đổi ad-hoc
+sidebar:
+  order: 5
+---
+
+Sử dụng **Quick Dev** cho sửa lỗi, refactor, hoặc các thay đổi nhỏ có mục tiêu rõ ràng mà không cần quy trình BMad Method đầy đủ.
+
+## Khi nào nên dùng
+
+- Sửa lỗi khi nguyên nhân đã rõ ràng
+- Refactor nhỏ (đổi tên, tách hàm, tái cấu trúc) nằm trong một vài tệp
+- Điều chỉnh tính năng nhỏ hoặc thay đổi cấu hình
+- Cập nhật dependency
+
+:::note[Điều kiện tiên quyết]
+- Đã cài BMad Method (`npx bmad-method install`)
+- Một IDE tích hợp AI (Claude Code, Cursor, hoặc tương tự)
+:::
+
+## Các bước thực hiện
+
+### 1. Bắt đầu một phiên chat mới
+
+Mở **một phiên chat mới** trong AI IDE của bạn. Tái sử dụng một phiên từ workflow trước dễ gây xung đột context.
+
+### 2. Mô tả ý định của bạn
+
+Quick Dev nhận ý định dạng tự do - trước, cùng lúc, hoặc sau khi gọi workflow. Ví dụ:
+
+```text
+run quick-dev — Sửa lỗi validate đăng nhập cho phép mật khẩu rỗng.
+```
+
+```text
+run quick-dev — fix https://github.com/org/repo/issues/42
+```
+
+```text
+run quick-dev — thực hiện ý định trong _bmad-output/implementation-artifacts/my-intent.md
+```
+
+```text
+Tôi nghĩ vấn đề nằm ở auth middleware, nó không kiểm tra hạn của token.
+Để tôi xem... đúng rồi, src/auth/middleware.ts dòng 47 bỏ qua
+hoàn toàn phần kiểm tra exp. run quick-dev
+```
+
+```text
+run quick-dev
+> Bạn muốn làm gì?
+Refactor UserService sang dùng async/await thay vì callbacks.
+```
+
+Văn bản thường, đường dẫn tệp, URL issue GitHub, liên kết bug tracker - bất kỳ thứ gì LLM có thể suy ra thành một ý định cụ thể.
+
+### 3. Trả lời câu hỏi và phê duyệt
+
+Quick Dev có thể đặt câu hỏi làm rõ hoặc đưa ra một bản spec ngắn để bạn phê duyệt trước khi triển khai. Hãy trả lời và phê duyệt khi bạn thấy kế hoạch đã ổn.
+
+### 4. Review và push
+
+Quick Dev sẽ triển khai thay đổi, tự review công việc của mình, sửa các vấn đề phát hiện được và commit vào local. Khi hoàn thành, nó sẽ mở các tệp bị ảnh hưởng trong editor.
+
+- Xem nhanh diff để xác nhận thay đổi đúng với ý định của bạn
+- Nếu có gì không ổn, nói cho agent biết cần sửa gì - nó có thể lặp lại ngay trong cùng phiên
+
+Khi đã hài lòng, push commit. Quick Dev sẽ đề xuất push và tạo PR cho bạn.
+
+:::caution[Nếu có thứ bị vỡ]
+Nếu thay đổi đã push gây sự cố ngoài ý muốn, dùng `git revert HEAD` để hoàn tác commit cuối một cách sạch sẽ. Sau đó bắt đầu một phiên chat mới và chạy lại Quick Dev để thử hướng khác.
+:::
+
+## Bạn nhận được gì
+
+- Các tệp nguồn đã được sửa với bản fix hoặc refactor
+- Test đã pass (nếu dự án có bộ test)
+- Một commit sẵn sàng để push, dùng conventional commit message
+
+## Công việc trì hoãn
+
+Quick Dev giữ mỗi lần chạy tập trung vào một mục tiêu duy nhất. Nếu yêu cầu của bạn có nhiều mục tiêu độc lập, hoặc review phát hiện các vấn đề tồn tại sẵn không liên quan đến thay đổi hiện tại, Quick Dev sẽ đưa chúng vào tệp `deferred-work.md` trong thư mục implementation artifacts thay vì cố gắng xử lý tất cả một lúc.
+
+Hãy kiểm tra tệp này sau mỗi lần chạy - đó là backlog các việc bạn cần quay lại sau. Mỗi mục trì hoãn có thể được đưa vào một lần chạy Quick Dev mới.
+
+## Khi nào nên nâng cấp lên quy trình lập kế hoạch đầy đủ
+
+Cân nhắc dùng toàn bộ BMad Method khi:
+
+- Thay đổi ảnh hưởng nhiều hệ thống hoặc cần cập nhật đồng bộ trên nhiều tệp
+- Bạn chưa chắc phạm vi và cần làm rõ yêu cầu trước
+- Bạn cần ghi lại tài liệu hoặc quyết định kiến trúc cho cả nhóm
+
+Xem [Quick Dev](../explanation/quick-dev.md) để hiểu rõ hơn Quick Dev nằm ở đâu trong BMad Method.

docs/vi-vn/how-to/shard-large-documents.md

@@ -0,0 +1,78 @@
+---
+title: "Hướng dẫn chia nhỏ tài liệu"
+description: Tách các tệp markdown lớn thành nhiều tệp nhỏ có tổ chức để quản lý context tốt hơn
+sidebar:
+       order: 9
+---
+
+Sử dụng công cụ `bmad-shard-doc` nếu bạn cần tách các tệp markdown lớn thành nhiều tệp nhỏ có tổ chức để quản lý context tốt hơn.
+
+:::caution[Đã ngừng khuyến nghị]
+Đây không còn là cách được khuyến nghị, và trong thời gian tới khi workflow được cập nhật và đa số LLM/công cụ lớn hỗ trợ subprocesses, việc này sẽ không còn cần thiết.
+:::
+
+## Khi nào nên dùng
+
+Chỉ dùng cách này nếu bạn nhận thấy tổ hợp công cụ / model bạn đang dùng không thể nạp và đọc đầy đủ tất cả tài liệu đầu vào khi cần.
+
+## Chia nhỏ tài liệu là gì?
+
+Chia nhỏ tài liệu là việc tách các tệp markdown lớn thành nhiều tệp nhỏ có tổ chức dựa trên các tiêu đề cấp 2 (`## Tiêu đề`).
+
+### Kiến trúc
+
+```text
+Trước khi chia nhỏ:
+_bmad-output/planning-artifacts/
+└── PRD.md (tệp lớn 50k token)
+
+Sau khi chia nhỏ:
+_bmad-output/planning-artifacts/
+└── prd/
+       ├── index.md                    # Mục lục kèm mô tả
+       ├── overview.md                 # Phần 1
+       ├── user-requirements.md        # Phần 2
+       ├── technical-requirements.md   # Phần 3
+       └── ...                         # Các phần bổ sung
+```
+
+## Các bước thực hiện
+
+### 1. Chạy công cụ Shard-Doc
+
+```bash
+/bmad-shard-doc
+```
+
+### 2. Làm theo quy trình tương tác
+
+```text
+Agent: Bạn muốn chia nhỏ tài liệu nào?
+User: docs/PRD.md
+
+Agent: Thư mục đích mặc định: docs/prd/
+       Chấp nhận mặc định? [y/n]
+User: y
+
+Agent: Đang chia nhỏ PRD.md...
+       ✓ Đã tạo 12 tệp theo từng phần
+       ✓ Đã tạo index.md
+       ✓ Hoàn tất!
+```
+
+## Cơ chế workflow tìm tài liệu
+
+Workflow của BMad dùng **hệ thống phát hiện kép**:
+
+1. **Thử tài liệu nguyên khối trước** - Tìm `document-name.md`
+2. **Kiểm tra bản đã chia nhỏ** - Tìm `document-name/index.md`
+3. **Quy tắc ưu tiên** - Bản nguyên khối được ưu tiên nếu cả hai cùng tồn tại; hãy xóa bản nguyên khối nếu bạn muốn workflow dùng bản đã chia nhỏ
+
+## Hỗ trợ trong workflow
+
+Tất cả workflow BMM đều hỗ trợ cả hai định dạng:
+
+- Tài liệu nguyên khối
+- Tài liệu đã chia nhỏ
+- Tự động nhận diện
+- Trong suốt với người dùng

docs/vi-vn/how-to/upgrade-to-v6.md

@@ -0,0 +1,100 @@
+---
+title: "Cách nâng cấp lên v6"
+description: Di chuyển từ BMad v4 sang v6
+sidebar:
+  order: 3
+---
+
+Sử dụng trình cài đặt BMad để nâng cấp từ v4 lên v6, bao gồm khả năng tự động phát hiện bản cài đặt cũ và hỗ trợ di chuyển.
+
+## Khi nào nên dùng
+
+- Bạn đang dùng BMad v4 (thư mục `.bmad-method`)
+- Bạn muốn chuyển sang kiến trúc v6 mới
+- Bạn có các planning artifact hiện có cần giữ lại
+
+:::note[Điều kiện tiên quyết]
+- Node.js 20+
+- Bản cài đặt BMad v4 hiện có
+:::
+
+## Các bước thực hiện
+
+### 1. Chạy trình cài đặt
+
+Làm theo [Hướng dẫn cài đặt](./install-bmad.md).
+
+### 2. Xử lý bản cài đặt cũ
+
+Khi v4 được phát hiện, bạn có thể:
+
+- Cho phép trình cài đặt sao lưu và xóa `.bmad-method`
+- Thoát và tự xử lý dọn dẹp thủ công
+
+Nếu trước đây bạn đặt tên thư mục BMad khác - bạn sẽ phải tự xóa thư mục đó.
+
+### 3. Dọn dẹp skill IDE cũ
+
+Tự xóa các command/skill IDE cũ của v4 - ví dụ nếu bạn dùng Claude Code, hãy tìm các thư mục lồng nhau bắt đầu bằng `bmad` và xóa chúng:
+
+- `.claude/commands/`
+
+Các skill v6 mới sẽ được cài tại:
+
+- `.claude/skills/`
+
+### 4. Di chuyển planning artifacts
+
+**Nếu bạn có tài liệu lập kế hoạch (Brief/PRD/UX/Architecture):**
+
+Di chuyển chúng vào `_bmad-output/planning-artifacts/` với tên mô tả rõ ràng:
+
+- Tên tệp PRD nên chứa `PRD`
+- Tên tệp tương ứng nên chứa `brief`, `architecture`, hoặc `ux-design`
+- Tài liệu đã chia nhỏ có thể đặt trong các thư mục con đặt tên phù hợp
+
+**Nếu bạn đang lập kế hoạch dở dang:** Hãy cân nhắc bắt đầu lại với workflow v6. Bạn vẫn có thể dùng các tài liệu hiện có làm input - các workflow discovery tiên tiến trong v6, kết hợp web search và chế độ plan trong IDE, cho kết quả tốt hơn.
+
+### 5. Di chuyển công việc phát triển đang dở dang
+
+Nếu bạn đã có các story được tạo hoặc đã triển khai:
+
+1. Hoàn thành cài đặt v6
+2. Đặt `epics.md` hoặc `epics/epic*.md` vào `_bmad-output/planning-artifacts/`
+3. Chạy workflow `bmad-sprint-planning` của Scrum Master
+4. Nói rõ với SM những epic/story nào đã hoàn thành
+
+## Bạn nhận được gì
+
+**Cấu trúc thống nhất của v6:**
+
+```text
+du-an-cua-ban/
+├── _bmad/               # Thư mục cài đặt duy nhất
+│   ├── _config/         # Các tùy chỉnh của bạn
+│   │   └── agents/      # Tệp tùy chỉnh agent
+│   ├── core/            # Framework core dùng chung
+│   ├── bmm/             # Module BMad Method
+│   ├── bmb/             # BMad Builder
+│   └── cis/             # Creative Intelligence Suite
+└── _bmad-output/        # Thư mục output (là thư mục docs trong v4)
+```
+
+## Di chuyển module
+
+| Module v4 | Trạng thái trong v6 |
+| --- | --- |
+| `.bmad-2d-phaser-game-dev` | Đã được tích hợp vào module BMGD |
+| `.bmad-2d-unity-game-dev` | Đã được tích hợp vào module BMGD |
+| `.bmad-godot-game-dev` | Đã được tích hợp vào module BMGD |
+| `.bmad-infrastructure-devops` | Đã bị ngừng hỗ trợ - agent DevOps mới sắp ra mắt |
+| `.bmad-creative-writing` | Chưa được điều chỉnh - module v6 mới sắp ra mắt |
+
+## Các thay đổi chính
+
+| Khái niệm | v4 | v6 |
+| --- | --- | --- |
+| **Core** | `_bmad-core` thực chất là BMad Method | `_bmad/core/` là framework dùng chung |
+| **Method** | `_bmad-method` | `_bmad/bmm/` |
+| **Config** | Sửa trực tiếp các tệp | `config.yaml` theo từng module |
+| **Documents** | Cần thiết lập trước cho bản chia nhỏ hoặc nguyên khối | Linh hoạt hoàn toàn, tự động quét |

docs/vi-vn/index.md

@@ -0,0 +1,60 @@
+---
+title: Chào mừng đến với BMad Method
+description: Framework phát triển phần mềm dựa trên AI với các agent chuyên biệt, workflow có hướng dẫn và khả năng lập kế hoạch thông minh
+---
+
+BMad Method (**B**uild **M**ore **A**rchitect **D**reams) là một framework phát triển phần mềm dựa trên AI trong hệ sinh thái BMad Method, giúp bạn xây dựng phần mềm xuyên suốt toàn bộ quy trình, từ hình thành ý tưởng và lập kế hoạch cho tới triển khai với agent. Framework này cung cấp các AI agent chuyên biệt, workflow có hướng dẫn, và khả năng lập kế hoạch thông minh thích ứng với độ phức tạp của dự án, dù bạn đang sửa một lỗi nhỏ hay xây dựng một nền tảng doanh nghiệp.
+
+Nếu bạn đã quen làm việc với các trợ lý AI cho lập trình như Claude, Cursor, hoặc GitHub Copilot, bạn có thể bắt đầu ngay.
+
+:::note[🚀 V6 đã ra mắt và chúng tôi mới chỉ bắt đầu!]
+Kiến trúc Skills, BMad Builder v1, Dev Loop Automation, và nhiều thứ khác nữa đang được phát triển. **[Xem Roadmap →](/vi-vn/roadmap/)**
+:::
+
+## Mới bắt đầu? Hãy xem một Tutorial trước
+
+Cách nhanh nhất để hiểu BMad là dùng thử nó.
+
+- **[Bắt đầu với BMad](./tutorials/getting-started.md)** — Cài đặt và hiểu cách BMad hoạt động
+- **[Sơ đồ Workflow](./reference/workflow-map.md)** — Tổng quan trực quan về các phase của BMM, workflow, và cách quản lý context
+
+:::tip[Muốn vào việc ngay?]
+Cài BMad và dùng skill `bmad-help` — nó sẽ hướng dẫn bạn mọi thứ dựa trên dự án và các module đã cài.
+:::
+
+## Cách dùng bộ tài liệu này
+
+Bộ tài liệu này được chia thành bốn phần, dựa trên mục tiêu của bạn:
+
+| Phần | Mục đích |
+| ----------------- | ---------------------------------------------------------------------------------------------------------- |
+| **Tutorials** | Thiên về học theo từng bước. Đây là các hướng dẫn tuần tự giúp bạn xây dựng một thứ gì đó. Nếu bạn mới làm quen, hãy bắt đầu ở đây. |
+| **How-To Guides** | Thiên về tác vụ. Đây là các hướng dẫn thực tế để giải quyết một vấn đề cụ thể. Câu hỏi kiểu “Làm sao để tùy chỉnh một agent?” nằm ở phần này. |
+| **Explanation** | Thiên về hiểu bản chất. Đây là các bài phân tích sâu về khái niệm và kiến trúc. Hãy đọc khi bạn muốn hiểu *vì sao*. |
+| **Reference** | Thiên về tra cứu thông tin. Đây là đặc tả kỹ thuật cho agent, workflow, và cấu hình. |
+
+## Mở rộng và tùy chỉnh
+
+Bạn muốn mở rộng BMad bằng các agent, workflow, hoặc module của riêng mình? **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** cung cấp framework và công cụ để tạo các phần mở rộng tùy chỉnh, dù bạn chỉ bổ sung khả năng mới cho BMad hay xây dựng hẳn một module mới từ đầu.
+
+## Bạn cần gì để bắt đầu
+
+BMad hoạt động với bất kỳ trợ lý AI cho lập trình nào hỗ trợ custom system prompt hoặc project context. Một số lựa chọn phổ biến:
+
+- **[Claude Code](https://code.claude.com)** — Công cụ CLI của Anthropic (khuyến nghị)
+- **[Cursor](https://cursor.sh)** — Trình soạn thảo mã lấy AI làm trung tâm
+- **[Codex CLI](https://github.com/openai/codex)** — Agent lập trình trên terminal của OpenAI
+
+Bạn nên quen với các khái niệm phát triển phần mềm cơ bản như quản lý phiên bản, cấu trúc dự án, và workflow Agile. Không cần có kinh nghiệm trước với các hệ thống agent kiểu BMad, vì bộ tài liệu này được viết ra chính để hỗ trợ việc đó.
+
+## Tham gia cộng đồng
+
+Nhận trợ giúp, chia sẻ những gì bạn đang xây dựng, hoặc đóng góp cho BMad:
+
+- **[Discord](https://discord.gg/gk8jAdXWmj)** — Trao đổi với những người dùng BMad khác, đặt câu hỏi, chia sẻ ý tưởng
+- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Mã nguồn, issues, và đóng góp
+- **[YouTube](https://www.youtube.com/@BMadCode)** — Video hướng dẫn và walkthrough
+
+## Bước tiếp theo
+
+Sẵn sàng bắt đầu? **[Bắt đầu với BMad](./tutorials/getting-started.md)** và xây dựng dự án đầu tiên của bạn.

docs/vi-vn/reference/agents.md

@@ -0,0 +1,55 @@
+---
+title: Agents
+description: Các agent mặc định của BMM cùng skill ID, trigger menu và workflow chính
+sidebar:
+  order: 2
+---
+
+## Các Agent Mặc Định
+
+Trang này liệt kê các agent mặc định của BMM (bộ Agile suite) được cài cùng với BMad Method, bao gồm skill ID, trigger menu và workflow chính của chúng. Mỗi agent được gọi dưới dạng một skill.
+
+## Ghi Chú
+
+- Mỗi agent đều có sẵn dưới dạng một skill do trình cài đặt tạo ra. Skill ID, ví dụ `bmad-dev`, được dùng để gọi agent.
+- Trigger là các mã menu ngắn, ví dụ `CP`, cùng với các fuzzy match hiển thị trong menu của từng agent.
+- Việc tạo test QA do workflow skill `bmad-qa-generate-e2e-tests` đảm nhận, khả dụng thông qua Developer agent. Module Test Architect (TEA) đầy đủ nằm trong một module riêng.
+
+| Agent | Skill ID | Trigger | Workflow chính |
+| --------------------------- | -------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
+| Analyst (Mary) | `bmad-analyst` | `BP`, `RS`, `CB`, `WB`, `DP` | Brainstorm Project, Research, Create Brief, PRFAQ Challenge, Document Project |
+| Product Manager (John) | `bmad-pm` | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Create/Validate/Edit PRD, Create Epics and Stories, Implementation Readiness, Correct Course |
+| Architect (Winston) | `bmad-architect` | `CA`, `IR` | Create Architecture, Implementation Readiness |
+| Developer (Amelia) | `bmad-agent-dev` | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | Dev Story, Quick Dev, QA Test Generation, Code Review, Sprint Planning, Create Story, Epic Retrospective |
+| UX Designer (Sally) | `bmad-ux-designer` | `CU` | Create UX Design |
+| Technical Writer (Paige) | `bmad-tech-writer` | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Document Project, Write Document, Update Standards, Mermaid Generate, Validate Doc, Explain Concept |
+
+## Các Loại Trigger
+
+Trigger trong menu agent dùng hai kiểu gọi khác nhau. Biết trigger thuộc kiểu nào sẽ giúp bạn cung cấp đúng đầu vào.
+
+### Trigger workflow (không cần tham số)
+
+Phần lớn trigger sẽ nạp một file workflow có cấu trúc. Bạn gõ mã trigger, agent sẽ bắt đầu workflow và nhắc bạn nhập thông tin ở từng bước.
+
+Ví dụ: `CP` (Create PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
+
+### Trigger hội thoại (cần tham số)
+
+Một số trigger sẽ mở cuộc hội thoại tự do thay vì chạy workflow có cấu trúc. Khi đó bạn cần mô tả yêu cầu của mình cùng với mã trigger.
+
+| Agent | Trigger | Nội dung cần cung cấp |
+| --- | --- | --- |
+| Technical Writer (Paige) | `WD` | Mô tả tài liệu cần viết |
+| Technical Writer (Paige) | `US` | Sở thích hoặc quy ước muốn thêm vào standards |
+| Technical Writer (Paige) | `MG` | Mô tả sơ đồ và loại sơ đồ (sequence, flowchart, v.v.) |
+| Technical Writer (Paige) | `VD` | Tài liệu cần kiểm tra và các vùng trọng tâm |
+| Technical Writer (Paige) | `EC` | Tên khái niệm cần giải thích |
+
+**Ví dụ:**
+
+```text
+WD Write a deployment guide for our Docker setup
+MG Create a sequence diagram showing the auth flow
+EC Explain how the module system works
+```

docs/vi-vn/reference/commands.md

@@ -0,0 +1,135 @@
+---
+title: Skills
+description: Tài liệu tham chiếu cho skill của BMad — skill là gì, hoạt động ra sao và tìm ở đâu.
+sidebar:
+  order: 3
+---
+
+Skills là các prompt dựng sẵn để nạp agent, chạy workflow hoặc thực thi task bên trong IDE của bạn. Trình cài đặt BMad sinh chúng từ các module bạn đã chọn tại thời điểm cài đặt. Nếu sau này bạn thêm, xóa hoặc thay đổi module, hãy chạy lại trình cài đặt để đồng bộ skills (xem [Khắc phục sự cố](#khắc-phục-sự-cố)).
+
+## Skill So Với Trigger Trong Menu Agent
+
+BMad cung cấp hai cách để bắt đầu công việc, và chúng phục vụ những mục đích khác nhau.
+
+| Cơ chế | Cách gọi | Điều xảy ra |
+| --- | --- | --- |
+| **Skill** | Gõ tên skill, ví dụ `bmad-help`, trong IDE | Nạp trực tiếp agent, chạy workflow hoặc thực thi task |
+| **Trigger menu agent** | Nạp agent trước, sau đó gõ mã ngắn như `DS` | Agent diễn giải mã đó và bắt đầu workflow tương ứng trong khi vẫn giữ đúng persona |
+
+Trigger trong menu agent yêu cầu bạn đang ở trong một phiên agent đang hoạt động. Dùng skill khi bạn đã biết mình muốn workflow nào. Dùng trigger khi bạn đang làm việc với một agent và muốn đổi tác vụ mà không rời khỏi cuộc hội thoại.
+
+## Skills Được Tạo Ra Như Thế Nào
+
+Khi bạn chạy `npx bmad-method install`, trình cài đặt sẽ đọc manifest của mọi module được chọn rồi tạo một skill cho mỗi agent, workflow, task và tool. Mỗi skill là một thư mục chứa file `SKILL.md`, hướng dẫn AI nạp file nguồn tương ứng và làm theo chỉ dẫn trong đó.
+
+Trình cài đặt dùng template cho từng loại skill:
+
+| Loại skill | File được tạo sẽ làm gì |
+| --- | --- |
+| **Agent launcher** | Nạp file persona của agent, kích hoạt menu của nó và giữ nguyên vai trò |
+| **Workflow skill** | Nạp cấu hình workflow và làm theo các bước |
+| **Task skill** | Nạp một file task độc lập và làm theo hướng dẫn |
+| **Tool skill** | Nạp một file tool độc lập và làm theo hướng dẫn |
+
+:::note[Chạy lại trình cài đặt]
+Nếu bạn thêm hoặc bớt module, hãy chạy lại trình cài đặt. Nó sẽ tạo lại toàn bộ file skill khớp với tập module hiện tại.
+:::
+
+## File Skill Nằm Ở Đâu
+
+Trình cài đặt sẽ ghi file skill vào một thư mục dành riêng cho IDE bên trong dự án. Đường dẫn chính xác phụ thuộc vào IDE bạn chọn khi cài.
+
+| IDE / CLI | Thư mục skill |
+| --- | --- |
+| Claude Code | `.claude/skills/` |
+| Cursor | `.cursor/skills/` |
+| Windsurf | `.windsurf/skills/` |
+| IDE khác | Xem output của trình cài đặt để biết đường dẫn đích |
+
+Mỗi skill là một thư mục chứa file `SKILL.md`. Ví dụ với Claude Code, cấu trúc sẽ như sau:
+
+```text
+.claude/skills/
+├── bmad-help/
+│   └── SKILL.md
+├── bmad-create-prd/
+│   └── SKILL.md
+├── bmad-agent-dev/
+│   └── SKILL.md
+└── ...
+```
+
+Tên thư mục quyết định tên skill trong IDE. Ví dụ thư mục `bmad-agent-dev/` sẽ đăng ký skill `bmad-agent-dev`.
+
+## Cách Tìm Danh Sách Skill Của Bạn
+
+Gõ tên skill trong IDE để gọi nó. Một số nền tảng yêu cầu bạn bật skills trong phần cài đặt trước khi chúng xuất hiện.
+
+Chạy `bmad-help` để nhận hướng dẫn có ngữ cảnh về bước tiếp theo.
+
+:::tip[Khám phá nhanh]
+Các thư mục skill được tạo trong dự án chính là danh sách chuẩn nhất. Mở chúng trong trình quản lý file để xem toàn bộ skill cùng mô tả.
+:::
+
+## Các Nhóm Skill
+
+### Agent Skills
+
+Agent skills nạp một persona AI chuyên biệt với vai trò, phong cách giao tiếp và menu workflow xác định sẵn. Sau khi được nạp, agent sẽ giữ đúng vai trò và phản hồi qua các trigger trong menu.
+
+| Ví dụ skill | Agent | Vai trò |
+| --- | --- | --- |
+| `bmad-agent-dev` | Amelia (Developer) | Triển khai story với mức tuân thủ đặc tả nghiêm ngặt |
+| `bmad-pm` | John (Product Manager) | Tạo và kiểm tra PRD |
+| `bmad-architect` | Winston (Architect) | Thiết kế kiến trúc hệ thống |
+
+Xem [Agents](./agents.md) để biết danh sách đầy đủ các agent mặc định và trigger của chúng.
+
+### Workflow Skills
+
+Workflow skills chạy một quy trình có cấu trúc, nhiều bước mà không cần nạp persona agent trước. Chúng nạp cấu hình workflow rồi thực hiện theo từng bước.
+
+| Ví dụ skill | Mục đích |
+| --- | --- |
+| `bmad-product-brief` | Tạo product brief — phiên discovery có hướng dẫn khi concept của bạn đã rõ |
+| `bmad-prfaq` | Bài kiểm tra Working Backwards PRFAQ để stress-test concept sản phẩm |
+| `bmad-create-prd` | Tạo Product Requirements Document |
+| `bmad-create-architecture` | Thiết kế kiến trúc hệ thống |
+| `bmad-create-epics-and-stories` | Tạo epics và stories |
+| `bmad-dev-story` | Triển khai một story |
+| `bmad-code-review` | Chạy code review |
+| `bmad-quick-dev` | Luồng nhanh hợp nhất — làm rõ yêu cầu, lập kế hoạch, triển khai, review và trình bày |
+
+Xem [Workflow Map](./workflow-map.md) để có tài liệu workflow đầy đủ theo từng phase.
+
+### Task Skills Và Tool Skills
+
+Tasks và tools là các thao tác độc lập, không yêu cầu ngữ cảnh agent hay workflow.
+
+**BMad-Help: người dẫn đường thông minh của bạn**
+
+`bmad-help` là giao diện chính để bạn khám phá nên làm gì tiếp theo. Nó kiểm tra dự án, hiểu truy vấn ngôn ngữ tự nhiên và đề xuất bước bắt buộc hoặc tùy chọn tiếp theo dựa trên các module đã cài.
+
+:::note[Ví dụ]
+```text
+bmad-help
+bmad-help I have a SaaS idea and know all the features. Where do I start?
+bmad-help What are my options for UX design?
+```
+:::
+
+**Các task và tool lõi khác**
+
+Module lõi có 11 công cụ tích hợp sẵn — review, nén tài liệu, brainstorming, quản lý tài liệu và nhiều hơn nữa. Xem [Core Tools](./core-tools.md) để có tài liệu tham chiếu đầy đủ.
+
+## Quy Ước Đặt Tên
+
+Mọi skill đều dùng tiền tố `bmad-` theo sau là tên mô tả, ví dụ `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`. Xem [Modules](./modules.md) để biết các module hiện có.
+
+## Khắc Phục Sự Cố
+
+**Skills không xuất hiện sau khi cài đặt.** Một số nền tảng yêu cầu bật skills thủ công trong phần cài đặt. Hãy kiểm tra tài liệu IDE của bạn hoặc hỏi trợ lý AI cách bật skills. Bạn cũng có thể cần khởi động lại IDE hoặc reload cửa sổ.
+
+**Thiếu skill mà bạn mong đợi.** Trình cài đặt chỉ tạo skill cho những module bạn đã chọn. Hãy chạy lại `npx bmad-method install` và kiểm tra lại phần chọn module. Đồng thời xác nhận rằng file skill thực sự tồn tại trong thư mục dự kiến.
+
+**Skill từ module đã bỏ vẫn còn xuất hiện.** Trình cài đặt không tự xóa các file skill cũ. Hãy xóa các thư mục lỗi thời trong thư mục skills của IDE, hoặc xóa toàn bộ thư mục skills rồi chạy lại trình cài đặt để có tập skill sạch.

docs/vi-vn/reference/core-tools.md

@@ -0,0 +1,293 @@
+---
+title: Core Tools
+description: Tài liệu tham chiếu cho mọi task và workflow tích hợp sẵn có trong mọi bản cài BMad mà không cần module bổ sung.
+sidebar:
+  order: 2
+---
+
+Mọi bản cài BMad đều bao gồm một tập core skills có thể dùng cùng với bất cứ việc gì bạn đang làm — các task và workflow độc lập hoạt động xuyên suốt mọi dự án, mọi module và mọi phase. Chúng luôn có sẵn bất kể bạn cài những module tùy chọn nào.
+
+:::tip[Lối đi nhanh]
+Chạy bất kỳ core tool nào bằng cách gõ tên skill của nó, ví dụ `bmad-help`, trong IDE của bạn. Không cần mở phiên agent trước.
+:::
+
+## Tổng Quan
+
+| Công cụ | Loại | Mục đích |
+| --- | --- | --- |
+| [`bmad-help`](#bmad-help) | Task | Nhận hướng dẫn có ngữ cảnh về việc nên làm gì tiếp theo |
+| [`bmad-brainstorming`](#bmad-brainstorming) | Workflow | Tổ chức các phiên brainstorming có tương tác |
+| [`bmad-party-mode`](#bmad-party-mode) | Workflow | Điều phối thảo luận nhóm nhiều agent |
+| [`bmad-distillator`](#bmad-distillator) | Task | Nén tài liệu tối ưu cho LLM mà không mất thông tin |
+| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation) | Task | Đẩy đầu ra của LLM qua các vòng tinh luyện lặp |
+| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Task | Review hoài nghi để tìm chỗ thiếu và chỗ sai |
+| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter) | Task | Phân tích toàn bộ nhánh rẽ để tìm edge case chưa được xử lý |
+| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose) | Task | Biên tập câu chữ nhằm tăng độ rõ ràng khi giao tiếp |
+| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Task | Biên tập cấu trúc — cắt, gộp và tổ chức lại |
+| [`bmad-shard-doc`](#bmad-shard-doc) | Task | Tách file markdown lớn thành các phần có tổ chức |
+| [`bmad-index-docs`](#bmad-index-docs) | Task | Tạo hoặc cập nhật mục lục cho toàn bộ tài liệu trong một thư mục |
+
+## bmad-help
+
+**Người dẫn đường thông minh cho bước tiếp theo của bạn.** Công cụ này kiểm tra trạng thái dự án, phát hiện những gì đã hoàn thành và đề xuất bước bắt buộc hoặc tùy chọn tiếp theo.
+
+**Dùng khi:**
+
+- Bạn vừa hoàn tất một workflow và muốn biết tiếp theo là gì
+- Bạn mới làm quen với BMad và cần định hướng
+- Bạn đang mắc kẹt và muốn lời khuyên có ngữ cảnh
+- Bạn vừa cài module mới và muốn xem có gì khả dụng
+
+**Cách hoạt động:**
+
+1. Quét dự án để tìm các artifact hiện có như PRD, architecture, stories, v.v.
+2. Phát hiện các module đã cài và workflow khả dụng của chúng
+3. Đề xuất bước tiếp theo theo thứ tự ưu tiên — bước bắt buộc trước, tùy chọn sau
+4. Trình bày từng đề xuất cùng lệnh skill và mô tả ngắn
+
+**Đầu vào:** Truy vấn ngôn ngữ tự nhiên tùy chọn, ví dụ `bmad-help I have a SaaS idea, where do I start?`
+
+**Đầu ra:** Danh sách ưu tiên các bước tiếp theo được khuyến nghị kèm lệnh skill
+
+## bmad-brainstorming
+
+**Tạo ra nhiều ý tưởng đa dạng bằng các kỹ thuật sáng tạo có tương tác.** Đây là một phiên brainstorming có điều phối, nạp các phương pháp phát ý tưởng đã được kiểm chứng từ thư viện kỹ thuật và dẫn bạn đến 100+ ý tưởng trước khi bắt đầu sắp xếp.
+
+**Dùng khi:**
+
+- Bạn đang bắt đầu một dự án mới và cần khám phá không gian vấn đề
+- Bạn đang bí ý tưởng và cần một quy trình sáng tạo có cấu trúc
+- Bạn muốn dùng các framework tạo ý tưởng đã được kiểm chứng như SCAMPER, reverse brainstorming, v.v.
+
+**Cách hoạt động:**
+
+1. Thiết lập phiên brainstorming theo chủ đề của bạn
+2. Nạp các kỹ thuật sáng tạo từ thư viện phương pháp
+3. Dẫn bạn đi qua từng kỹ thuật để tạo ý tưởng
+4. Áp dụng giao thức chống thiên lệch — cứ mỗi 10 ý tưởng lại đổi miền sáng tạo để tránh gom cụm
+5. Tạo một tài liệu phiên làm việc chỉ thêm vào, trong đó mọi ý tưởng được tổ chức theo kỹ thuật
+
+**Đầu vào:** Chủ đề brainstorming hoặc phát biểu vấn đề, cùng file context tùy chọn
+
+**Đầu ra:** `brainstorming-session-{date}.md` chứa toàn bộ ý tưởng được tạo ra
+
+:::note[Mục tiêu về số lượng]
+Điểm bứt phá thường nằm ở vùng ý tưởng thứ 50-100. Workflow này khuyến khích bạn tạo 100+ ý tưởng trước khi sắp xếp.
+:::
+
+## bmad-party-mode
+
+**Điều phối thảo luận nhóm nhiều agent.** Công cụ này nạp toàn bộ agent BMad đã cài và tạo một cuộc trao đổi tự nhiên, nơi mỗi agent đóng góp từ góc nhìn chuyên môn và cá tính riêng.
+
+**Dùng khi:**
+
+- Bạn cần nhiều góc nhìn chuyên gia cho một quyết định
+- Bạn muốn các agent phản biện giả định của nhau
+- Bạn đang khám phá một chủ đề phức tạp trải qua nhiều miền khác nhau
+
+**Cách hoạt động:**
+
+1. Nạp manifest agent chứa toàn bộ persona đã cài
+2. Phân tích chủ đề của bạn để chọn ra 2-3 agent phù hợp nhất
+3. Các agent lần lượt tham gia, có tương tác chéo và bất đồng tự nhiên
+4. Luân phiên agent để đảm bảo góc nhìn đa dạng theo thời gian
+5. Kết thúc bằng `goodbye`, `end party` hoặc `quit`
+
+**Đầu vào:** Chủ đề hoặc câu hỏi thảo luận, cùng thông tin về các persona bạn muốn tham gia nếu có
+
+**Đầu ra:** Cuộc hội thoại nhiều agent theo thời gian thực, vẫn giữ nguyên cá tính từng agent
+
+## bmad-distillator
+
+**Nén tài liệu nguồn tối ưu cho LLM mà không mất thông tin.** Công cụ này tạo ra các bản chưng cất dày đặc, tiết kiệm token nhưng vẫn giữ nguyên toàn bộ thông tin cho LLM dùng về sau. Có thể xác minh bằng tái dựng hai chiều.
+
+**Dùng khi:**
+
+- Một tài liệu quá lớn so với context window của LLM
+- Bạn cần phiên bản tiết kiệm token của tài liệu nghiên cứu, đặc tả hoặc artifact lập kế hoạch
+- Bạn muốn xác minh rằng không có thông tin nào bị mất trong quá trình nén
+- Các agent sẽ cần tham chiếu và tìm thông tin trong đó thường xuyên
+
+**Cách hoạt động:**
+
+1. **Analyze** — Đọc tài liệu nguồn, nhận diện mật độ thông tin và cấu trúc
+2. **Compress** — Chuyển văn xuôi thành dạng bullet dày đặc, bỏ trang trí không cần thiết
+3. **Verify** — Kiểm tra tính đầy đủ để đảm bảo mọi thông tin gốc còn nguyên
+4. **Validate** *(tùy chọn)* — Tái dựng hai chiều để chứng minh nén không mất mát
+
+**Đầu vào:**
+
+- `source_documents` *(bắt buộc)* — Đường dẫn file, thư mục hoặc mẫu glob
+- `downstream_consumer` *(tùy chọn)* — Thành phần sẽ dùng đầu ra này, ví dụ "PRD creation"
+- `token_budget` *(tùy chọn)* — Kích thước mục tiêu gần đúng
+- `--validate` *(cờ)* — Chạy kiểm tra tái dựng hai chiều
+
+**Đầu ra:** Một hoặc nhiều file markdown distillate kèm báo cáo tỷ lệ nén, ví dụ `3.2:1`
+
+## bmad-advanced-elicitation
+
+**Đẩy đầu ra của LLM qua các phương pháp tinh luyện lặp.** Công cụ này chọn từ thư viện kỹ thuật elicitation để cải thiện nội dung một cách có hệ thống qua nhiều lượt.
+
+**Dùng khi:**
+
+- Đầu ra của LLM còn nông hoặc quá chung chung
+- Bạn muốn khám phá một chủ đề từ nhiều góc phân tích khác nhau
+- Bạn đang tinh chỉnh một tài liệu quan trọng và cần chiều sâu hơn
+
+**Cách hoạt động:**
+
+1. Nạp registry phương pháp với hơn 5 kỹ thuật elicitation
+2. Chọn ra 5 phương pháp phù hợp nhất dựa trên loại nội dung và độ phức tạp
+3. Hiển thị menu tương tác — chọn một phương pháp, xáo lại, hoặc liệt kê tất cả
+4. Áp dụng phương pháp đã chọn để nâng cấp nội dung
+5. Tiếp tục đưa ra lựa chọn cho các vòng cải thiện tiếp theo cho đến khi bạn chọn "Proceed"
+
+**Đầu vào:** Phần nội dung cần cải thiện
+
+**Đầu ra:** Phiên bản nội dung đã được nâng cấp
+
+## bmad-review-adversarial-general
+
+**Kiểu review hoài nghi, mặc định cho rằng vấn đề luôn tồn tại và phải đi tìm chúng.** Công cụ này đứng ở góc nhìn của một reviewer khó tính, thiếu kiên nhẫn với sản phẩm cẩu thả. Nó tìm xem còn thiếu gì, không chỉ tìm cái gì sai.
+
+**Dùng khi:**
+
+- Bạn cần bảo đảm chất lượng trước khi chốt một deliverable
+- Bạn muốn stress-test một spec, story hoặc tài liệu
+- Bạn muốn tìm lỗ hổng bao phủ mà các review lạc quan thường bỏ sót
+
+**Cách hoạt động:**
+
+1. Đọc nội dung với góc nhìn hoài nghi và khắt khe
+2. Xác định vấn đề về độ đầy đủ, độ đúng và chất lượng
+3. Chủ động tìm phần còn thiếu chứ không chỉ phần hiện diện nhưng sai
+4. Phải tìm được tối thiểu 10 vấn đề, nếu không sẽ phân tích sâu hơn
+
+**Đầu vào:**
+
+- `content` *(bắt buộc)* — Diff, spec, story, tài liệu hoặc bất kỳ artifact nào
+- `also_consider` *(tùy chọn)* — Các vùng bổ sung cần để ý
+
+**Đầu ra:** Danh sách markdown gồm 10+ phát hiện kèm mô tả
+
+## bmad-review-edge-case-hunter
+
+**Đi qua mọi nhánh rẽ và điều kiện biên, chỉ báo cáo những trường hợp chưa được xử lý.** Đây là phương pháp thuần túy dựa trên truy vết đường đi, suy ra các lớp edge case một cách cơ học. Nó trực giao với adversarial review — khác phương pháp, không khác thái độ.
+
+**Dùng khi:**
+
+- Bạn muốn bao phủ edge case toàn diện cho code hoặc logic
+- Bạn cần một phương pháp bổ sung cho adversarial review
+- Bạn đang review diff hoặc function để tìm điều kiện biên
+
+**Cách hoạt động:**
+
+1. Liệt kê toàn bộ nhánh rẽ trong nội dung
+2. Suy ra cơ học các lớp edge case: thiếu else/default, input không được gác, off-by-one, tràn số học, ép kiểu ngầm, race condition, lỗ hổng timeout
+3. Đối chiếu từng đường đi với các guard hiện có
+4. Chỉ báo cáo các đường đi chưa được xử lý, âm thầm bỏ qua những trường hợp đã được che chắn
+
+**Đầu vào:**
+
+- `content` *(bắt buộc)* — Diff, toàn file hoặc function
+- `also_consider` *(tùy chọn)* — Các vùng bổ sung cần lưu ý
+
+**Đầu ra:** Mảng JSON các phát hiện, mỗi phát hiện có `location`, `trigger_condition`, `guard_snippet` và `potential_consequence`
+
+:::note[Các kiểu review bổ trợ nhau]
+Hãy chạy cả `bmad-review-adversarial-general` và `bmad-review-edge-case-hunter` để có độ bao phủ trực giao. Adversarial review bắt lỗi về chất lượng và độ đầy đủ; edge case hunter bắt các đường đi chưa được xử lý.
+:::
+
+## bmad-editorial-review-prose
+
+**Biên tập câu chữ kiểu lâm sàng, tập trung vào độ rõ ràng khi truyền đạt.** Công cụ này review văn bản để tìm ra các vấn đề cản trở việc hiểu. Nó dùng Microsoft Writing Style Guide làm nền và vẫn giữ giọng văn của tác giả.
+
+**Dùng khi:**
+
+- Bạn đã có bản nháp tài liệu và muốn trau chuốt câu chữ
+- Bạn cần đảm bảo độ rõ ràng cho một nhóm độc giả cụ thể
+- Bạn muốn sửa lỗi giao tiếp mà không áp đặt gu phong cách cá nhân
+
+**Cách hoạt động:**
+
+1. Đọc nội dung, bỏ qua code block và frontmatter
+2. Xác định các vấn đề cản trở hiểu nghĩa, không phải các sở thích phong cách
+3. Khử trùng lặp những lỗi giống nhau xuất hiện nhiều nơi
+4. Tạo bảng sửa lỗi ba cột
+
+**Đầu vào:**
+
+- `content` *(bắt buộc)* — Markdown, văn bản thường hoặc XML
+- `style_guide` *(tùy chọn)* — Style guide riêng của dự án
+- `reader_type` *(tùy chọn)* — `humans` mặc định cho độ rõ và nhịp đọc, hoặc `llm` cho độ chính xác và nhất quán
+
+**Đầu ra:** Bảng markdown ba cột: Original Text | Revised Text | Changes
+
+## bmad-editorial-review-structure
+
+**Biên tập cấu trúc — đề xuất cắt, gộp, di chuyển và cô đọng.** Công cụ này review cách tổ chức tài liệu và đề xuất thay đổi mang tính nội dung để tăng độ rõ ràng và luồng đọc trước khi chỉnh câu chữ.
+
+**Dùng khi:**
+
+- Một tài liệu được ghép từ nhiều nguồn con và cần tính nhất quán về cấu trúc
+- Bạn muốn rút gọn độ dài tài liệu nhưng vẫn giữ được khả năng hiểu
+- Bạn cần phát hiện chỗ lệch phạm vi hoặc thông tin quan trọng bị chôn vùi
+
+**Cách hoạt động:**
+
+1. Phân tích tài liệu theo 5 mô hình cấu trúc: Tutorial, Reference, Explanation, Prompt, Strategic
+2. Xác định phần dư thừa, lệch phạm vi và thông tin bị chìm
+3. Tạo danh sách khuyến nghị theo mức ưu tiên: CUT, MERGE, MOVE, CONDENSE, QUESTION, PRESERVE
+4. Ước tính số từ và phần trăm có thể giảm
+
+**Đầu vào:**
+
+- `content` *(bắt buộc)* — Tài liệu cần review
+- `purpose` *(tùy chọn)* — Mục đích mong muốn, ví dụ "quickstart tutorial"
+- `target_audience` *(tùy chọn)* — Ai sẽ đọc tài liệu này
+- `reader_type` *(tùy chọn)* — `humans` hoặc `llm`
+- `length_target` *(tùy chọn)* — Mục tiêu rút gọn, ví dụ "ngắn hơn 30%"
+
+**Đầu ra:** Tóm tắt tài liệu, danh sách khuyến nghị ưu tiên và ước tính mức giảm
+
+## bmad-shard-doc
+
+**Tách file markdown lớn thành các file phần có tổ chức.** Công cụ này dùng các header cấp 2 làm điểm cắt để tạo ra một thư mục gồm các file phần tự chứa cùng một file chỉ mục.
+
+**Dùng khi:**
+
+- Một file markdown đã quá lớn để quản lý hiệu quả, thường trên 500 dòng
+- Bạn muốn chia một tài liệu nguyên khối thành các phần dễ điều hướng
+- Bạn cần các file riêng để chỉnh sửa song song hoặc quản lý context cho LLM
+
+**Cách hoạt động:**
+
+1. Xác nhận file nguồn tồn tại và là markdown
+2. Tách tại các header cấp 2 `##` thành các file phần được đánh số
+3. Tạo `index.md` chứa danh sách phần và liên kết
+4. Hỏi bạn có muốn xóa, lưu trữ hay giữ file gốc không
+
+**Đầu vào:** Đường dẫn file markdown nguồn, cùng thư mục đích tùy chọn
+
+**Đầu ra:** Một thư mục gồm `index.md` và các file `01-{section}.md`, `02-{section}.md`, v.v.
+
+## bmad-index-docs
+
+**Tạo hoặc cập nhật mục lục cho toàn bộ tài liệu trong một thư mục.** Công cụ này quét thư mục, đọc từng file để hiểu mục đích của nó, rồi tạo `index.md` có tổ chức với liên kết và mô tả.
+
+**Dùng khi:**
+
+- Bạn cần một chỉ mục nhẹ để LLM quét nhanh các tài liệu hiện có
+- Một thư mục tài liệu đã lớn và cần bảng mục lục có tổ chức
+- Bạn muốn một cái nhìn tổng quan được tạo tự động và luôn theo kịp hiện trạng
+
+**Cách hoạt động:**
+
+1. Quét thư mục đích để lấy mọi file không ẩn
+2. Đọc từng file để hiểu đúng mục đích thực tế của nó
+3. Nhóm file theo loại, mục đích hoặc thư mục con
+4. Tạo mô tả ngắn gọn, thường từ 3-10 từ cho mỗi file
+
+**Đầu vào:** Đường dẫn thư mục đích
+
+**Đầu ra:** `index.md` chứa danh sách file có tổ chức, liên kết tương đối và mô tả ngắn

docs/vi-vn/reference/modules.md

@@ -0,0 +1,76 @@
+---
+title: Các Module Chính Thức
+description: Các module bổ sung để xây agent tùy chỉnh, tăng cường sáng tạo, phát triển game và kiểm thử
+sidebar:
+  order: 4
+---
+
+BMad được mở rộng thông qua các module chính thức mà bạn chọn trong quá trình cài đặt. Những module bổ sung này cung cấp agent, workflow và task chuyên biệt cho các lĩnh vực cụ thể, vượt ra ngoài phần lõi tích hợp sẵn và BMM (Agile suite).
+
+:::tip[Cài đặt module]
+Chạy `npx bmad-method install` rồi chọn những module bạn muốn. Trình cài đặt sẽ tự xử lý phần tải về, cấu hình và tích hợp vào IDE.
+:::
+
+## BMad Builder
+
+Tạo agent tùy chỉnh, workflow tùy chỉnh và module chuyên biệt theo lĩnh vực với sự hỗ trợ có hướng dẫn. BMad Builder là meta-module để mở rộng chính framework này.
+
+- **Mã:** `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)
+
+**Cung cấp:**
+
+- Agent Builder — tạo AI agent chuyên biệt với chuyên môn và quyền truy cập công cụ tùy chỉnh
+- Workflow Builder — thiết kế quy trình có cấu trúc với các bước và điểm quyết định
+- Module Builder — đóng gói agent và workflow thành các module có thể chia sẻ và phát hành
+- Thiết lập có tương tác bằng YAML cùng hỗ trợ publish lên npm
+
+## Creative Intelligence Suite
+
+Bộ công cụ vận hành bởi AI dành cho sáng tạo có cấu trúc, phát ý tưởng và đổi mới trong giai đoạn đầu phát triển. Bộ này cung cấp nhiều agent giúp brainstorming, design thinking và giải quyết vấn đề bằng các framework đã được kiểm chứng.
+
+- **Mã:** `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)
+
+**Cung cấp:**
+
+- Các agent Innovation Strategist, Design Thinking Coach và Brainstorming Coach
+- Problem Solver và Creative Problem Solver cho tư duy hệ thống và tư duy bên lề
+- Storyteller và Presentation Master cho kể chuyện và pitching
+- Các framework phát ý tưởng như SCAMPER, Reverse Brainstorming và problem reframing
+
+## Game Dev Studio
+
+Các workflow phát triển game có cấu trúc, được điều chỉnh cho Unity, Unreal, Godot và các engine tùy chỉnh. Hỗ trợ làm prototype nhanh qua Quick Flow và sản xuất toàn diện bằng sprint theo epic.
+
+- **Mã:** `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)
+
+**Cung cấp:**
+
+- Workflow tạo Game Design Document (GDD)
+- Chế độ Quick Dev cho làm prototype nhanh
+- Hỗ trợ thiết kế narrative cho nhân vật, hội thoại và world-building
+- Bao phủ hơn 21 thể loại game cùng hướng dẫn kiến trúc theo engine
+
+## Test Architect (TEA)
+
+Chiến lược kiểm thử cấp doanh nghiệp, hướng dẫn tự động hóa và quyết định release gate thông qua một agent chuyên gia cùng chín workflow có cấu trúc. TEA vượt xa QA agent tích hợp sẵn nhờ ưu tiên theo rủi ro và truy vết yêu cầu.
+
+- **Mã:** `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)
+
+**Cung cấp:**
+
+- Agent Murat (Master Test Architect and Quality Advisor)
+- Các workflow cho test design, ATDD, automation, test review và traceability
+- Đánh giá NFR, thiết lập CI và dựng sườn framework kiểm thử
+- Ưu tiên P0-P3 cùng tích hợp tùy chọn với Playwright Utils và MCP
+
+## Community Modules
+
+Các module cộng đồng và một chợ module đang được chuẩn bị. Hãy theo dõi [tổ chức BMad trên GitHub](https://github.com/bmad-code-org) để cập nhật.

docs/vi-vn/reference/testing.md

@@ -0,0 +1,106 @@
+---
+title: Các Tùy Chọn Kiểm Thử
+description: So sánh workflow QA tích hợp sẵn với module Test Architect (TEA) cho tự động hóa kiểm thử.
+sidebar:
+  order: 5
+---
+
+BMad cung cấp hai hướng kiểm thử: workflow QA tích hợp sẵn để tạo test nhanh và module Test Architect có thể cài thêm cho chiến lược kiểm thử c<><63>p doanh nghiệp.
+
+## Nên Dùng Cái Nào?
+
+| Yếu tố | QA tích hợp sẵn | Module TEA |
+| --- | --- | --- |
+| **Phù hợp nhất với** | Dự án nhỏ-trung bình, cần bao phủ nhanh | Dự án lớn, miền nghiệp vụ bị ràng buộc hoặc phức tạp |
+| **Thiết lập** | Không cần cài thêm, đã có sẵn trong BMM | Cài riêng qua `npx bmad-method install` |
+| **Cách tiếp cận** | Tạo test nhanh, lặp tinh chỉnh sau | Lập kế hoạch trước rồi mới tạo test có truy vết |
+| **Loại test** | API và E2E | API, E2E, ATDD, NFR và nhiều loại khác |
+| **Chiến lược** | Happy path + edge case quan trọng | Ưu tiên theo rủi ro (P0-P3) |
+| **Số workflow** | 1 (Automate) | 9 (design, ATDD, automate, review, trace và các workflow khác) |
+
+:::tip[Bắt đầu với QA tích h<><68>p sẵn]
+Phần lớn dự án nên bắt đầu với workflow QA tích hợp sẵn. Nếu sau này bạn cần chiến lược kiểm thử, quality gate hoặc truy vết yêu cầu, hãy cài TEA song song.
+:::
+
+## Workflow QA Tích Hợp Sẵn
+
+Workflow QA tích hợp sẵn (`bmad-qa-generate-e2e-tests`) nằm trong module BMM (Agile suite), khả dụng thông qua Developer agent. Nó tạo test chạy được rất nhanh bằng framework kiểm thử hiện có của dự án, không cần thêm cấu hình hay bước cài đặt bổ sung.
+
+**Trigger:** `QA` (thông qua Developer agent) hoặc `bmad-qa-generate-e2e-tests`
+
+### Workflow Làm Gì
+
+Workflow QA (Automate) gồm năm bước:
+
+1. **Phát hiện framework test** — quét `package.json` và các file test hiện có để nhận ra framework của bạn như Jest, Vitest, Playwright, Cypress hoặc bất kỳ runner tiêu chuẩn nào. Nếu chưa có gì, nó sẽ phân tích stack dự án và đề xuất một lựa chọn.
+2. **Xác định tính năng** — hỏi cần kiểm thử phần nào hoặc tự khám phá các tính năng trong codebase.
+3. **Tạo API tests** — bao phủ status code, cấu trúc phản hồi, happy path và 1-2 trường hợp lỗi.
+4. **Tạo E2E tests** — bao phủ workflow người dùng bằng semantic locator và assertion trên kết quả nhìn thấy được.
+5. **Chạy và xác minh** — thực thi test vừa tạo và sửa lỗi hỏng ngay lập tức.
+
+Workflow tạo một bản tóm tắt kiểm thử và lưu nó vào thư mục implementation artifacts của dự án.
+
+### Mẫu Kiểm Thử
+
+Các test được tạo theo triết lý “đơn giản và dễ bảo trì”:
+
+- **Chỉ dùng API chuẩn của framework** — không kéo thêm utility ngoài hay abstraction tùy chỉnh
+- **Semantic locator** cho UI test — dùng role, label, text thay vì CSS selector
+- **Test độc lập** — không phụ thuộc thứ tự chạy
+- **Không hardcode wait hoặc sleep**
+- **Mô tả rõ ràng** để test cũng đóng vai trò tài liệu tính năng
+
+:::note[Phạm vi]
+Workflow QA chỉ tạo test. Nếu bạn cần code review hoặc xác nhận story, hãy dùng workflow Code Review (`CR`).
+:::
+
+### Khi Nào Nên Dùng QA Tích Hợp S<><53><EFBFBD>n
+
+- Cần bao phủ test nhanh cho một tính năng mới hoặc hiện có
+- Muốn tự động hóa kiểm thử thân thiện với người mới mà không cần thiết lập phức tạp
+- Muốn các pattern test chuẩn mà lập trình viên nào cũng đọc và bảo trì được
+- Dự án nhỏ-trung bình, nơi chiến lược kiểm thử toàn diện là không cần thiết
+
+## Module Test Architect (TEA)
+
+TEA là một module độc lập cung cấp agent chuyên gia Murat cùng chín workflow có cấu trúc cho kiểm thử cấp doanh nghiệp. Nó vượt ra ngoài việc tạo test để bao gồm chiến lược kiểm thử, lập kế hoạch theo rủi ro, quality gate và truy vết yêu cầu.
+
+- **Tài liệu:** [TEA Module Docs](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+- **Cài đặt:** `npx bmad-method install` rồi chọn module TEA
+- **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+
+### TEA Cung Cấp Gì
+
+| Workflow | Mục đích |
+| --- | --- |
+| Test Design | Tạo chiến lược kiểm thử toàn diện gắn với yêu cầu |
+| ATDD | Phát triển hướng acceptance test với tiêu chí của stakeholder |
+| Automate | Tạo test bằng pattern và utility nâng cao |
+| Test Review | Kiểm tra chất lượng và độ bao phủ của test so với chiến lược |
+| Traceability | Liên kết test ngược về yêu cầu để phục vụ audit và tuân thủ |
+| NFR Assessment | Đánh giá các yêu cầu phi chức năng như hiệu năng, bảo mật |
+| CI Setup | Cấu hình thực thi test trong pipeline tích hợp liên tục |
+| Framework Scaffolding | Dựng hạ tầng và cấu trúc dự án kiểm thử |
+| Release Gate | Ra quyết định phát hành go/no-go dựa trên dữ liệu |
+
+TEA cũng hỗ trợ ưu tiên theo rủi ro P0-P3 và tích hợp tùy chọn với Playwright Utils cùng công cụ MCP.
+
+### Khi Nào Nên Dùng TEA
+
+- Dự án cần truy vết yêu cầu hoặc tài liệu tuân thủ
+- Đội ngũ cần ưu tiên kiểm thử theo rủi ro trên nhiều tính năng
+- Môi trường doanh nghiệp có quality gate chính thức trước phát hành
+- Miền nghiệp vụ phức tạp, nơi chiến lược kiểm thử phải được lên trước khi viết test
+- Dự án đã vượt quá mô hình một workflow của QA tích hợp sẵn
+
+## Kiểm Thử Nằm Ở Đâu Trong Workflow
+
+Workflow QA Automate xuất hiện ở Phase 4 (Implementation) trong workflow map của BMad Method. Nó được thiết kế để chạy **sau khi hoàn tất trọn vẹn một epic** — tức là khi mọi story trong epic đó đã được triển khai và code review xong. Trình tự điển hình là:
+
+1. Với mỗi story trong epic: triển khai bằng Dev (`DS`), sau đó xác nhận bằng Code Review (`CR`)
+2. Sau khi epic hoàn tất: tạo test bằng `QA` (thông qua Developer agent) hoặc workflow Automate của TEA
+3. Chạy retrospective (`bmad-retrospective`) để ghi nhận bài học rút ra
+
+Workflow QA tích hợp sẵn làm việc trực tiếp từ source code mà không cần nạp tài liệu lập kế hoạch như PRD hay architecture. Các workflow của TEA có thể tích hợp với artifact lập kế hoạch ở các bước trước để phục vụ truy vết.
+
+Để hiểu rõ hơn kiểm thử nằm ở đâu trong quy trình tổng thể, xem [Workflow Map](./workflow-map.md).

docs/vi-vn/reference/workflow-map.md

@@ -0,0 +1,89 @@
+---
+title: "Workflow Map"
+description: Tài liệu trực quan về các phase workflow và output của BMad Method
+sidebar:
+  order: 1
+---
+
+BMad Method (BMM) là một module trong hệ sinh thái BMad, tập trung vào các thực hành tốt nhất của context engineering và lập kế hoạch. AI agent hoạt động hiệu quả nhất khi có ngữ cảnh rõ ràng và có cấu trúc. Hệ thống BMM xây dựng ngữ cảnh đó theo tiến trình qua 4 phase riêng biệt. Mỗi phase, cùng với nhiều workflow tùy chọn bên trong phase đó, tạo ra các tài liệu làm đầu vào cho phase kế tiếp, nhờ vậy agent luôn biết phải xây gì và vì sao.
+
+Lý do và các khái niệm nền tảng ở đây đến từ các phương pháp agile đã được áp dụng rất thành công trong toàn ngành như một khung tư duy.
+
+Nếu có lúc nào bạn không chắc nên làm gì, skill `bmad-help` sẽ giúp bạn giữ đúng hướng hoặc biết bước tiếp theo. Bạn vẫn có thể dùng trang này để tham chiếu, nhưng `bmad-help` mang tính tương tác đầy đủ và nhanh hơn nhiều nếu bạn đã cài BMad Method. Ngoài ra, nếu bạn đang dùng thêm các module mở rộng BMad Method hoặc các module bổ sung khác, `bmad-help` cũng sẽ phát triển theo để biết mọi thứ đang có sẵn và đưa ra lời khuyên tốt nhất tại thời điểm đó.
+
+Lưu ý quan trọng cuối cùng: mọi workflow dưới đây đều có thể chạy trực tiếp bằng công cụ bạn chọn thông qua skill, hoặc bằng cách nạp agent trước rồi chọn mục tương ứng trong menu agent.
+
+<iframe src="/workflow-map-diagram.html" title="Sơ đồ Workflow Map của 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.html" target="_blank" rel="noopener noreferrer">Mở sơ đồ trong tab mới ↗</a>
+</p>
+
+## Phase 1: Analysis (Tùy chọn)
+
+Khám phá không gian vấn đề và xác nhận ý tưởng trước khi cam kết đi vào lập kế hoạch. [**Tìm hiểu từng công cụ làm gì và nên dùng khi nào**](../explanation/analysis-phase.md).
+
+| Workflow | Mục đích | Tạo ra |
+| ------------------------------- | -------------------------------------------------------------------------- | ------------------------- |
+| `bmad-brainstorming` | Brainstorm ý tưởng dự án với sự điều phối của brainstorming coach | `brainstorming-report.md` |
+| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Xác thực giả định về thị trường, kỹ thuật hoặc miền nghiệp vụ | Kết quả nghiên cứu |
+| `bmad-product-brief` | Ghi lại tầm nhìn chiến lược — phù hợp nhất khi concept của bạn đã rõ | `product-brief.md` |
+| `bmad-prfaq` | Working Backwards — stress-test và rèn sắc concept sản phẩm của bạn | `prfaq-{project}.md` |
+
+## Phase 2: Planning
+
+Xác định cần xây gì và xây cho ai.
+
+| Workflow | Mục đích | Tạo ra |
+| --------------------------- | ---------------------------------------- | ------------ |
+| `bmad-create-prd` | Xác định yêu cầu (FR/NFR) | `PRD.md` |
+| `bmad-create-ux-design` | Thiết kế trải nghiệm người dùng khi UX là yếu tố quan trọng | `ux-spec.md` |
+
+## Phase 3: Solutioning
+
+Quyết định cách xây và chia nhỏ công việc thành stories.
+
+| Workflow | Mục đích | Tạo ra |
+| ----------------------------------------- | ------------------------------------------ | --------------------------- |
+| `bmad-create-architecture` | Làm rõ các quyết định kỹ thuật | `architecture.md` kèm ADR |
+| `bmad-create-epics-and-stories` | Phân rã yêu cầu thành các phần việc có thể triển khai | Các file epic chứa stories |
+| `bmad-check-implementation-readiness` | Cổng kiểm tra trước khi triển khai | Quyết định PASS/CONCERNS/FAIL |
+
+## Phase 4: Implementation
+
+Xây dựng từng story một. Tự động hóa toàn bộ phase 4 sẽ sớm ra mắt.
+
+| Workflow | Mục đích | Tạo ra |
+| -------------------------- | ------------------------------------------------------------------------ | -------------------------------- |
+| `bmad-sprint-planning` | Khởi tạo theo dõi, thường chạy một lần mỗi dự án để sắp thứ tự chu trình dev | `sprint-status.yaml` |
+| `bmad-create-story` | Chuẩn bị story tiếp theo cho implementation | `story-[slug].md` |
+| `bmad-dev-story` | Triển khai story | Code chạy được + tests |
+| `bmad-code-review` | Kiểm tra chất lượng phần triển khai | Được duyệt hoặc yêu cầu thay đổi |
+| `bmad-correct-course` | Xử lý thay đổi lớn giữa sprint | Kế hoạch cập nhật hoặc định tuyến lại |
+| `bmad-sprint-status` | Theo dõi tiến độ sprint và trạng thái story | Cập nhật trạng thái sprint |
+| `bmad-retrospective` | Review sau khi hoàn tất epic | Bài học rút ra |
+
+## Quick Flow (Nhánh Song Song)
+
+Bỏ qua phase 1-3 đối với những việc nhỏ, rõ và đã hiểu đầy đủ.
+
+| Workflow | Mục đích | Tạo ra |
+| ------------------ | --------------------------------------------------------------------------- | ---------------------- |
+| `bmad-quick-dev` | Luồng nhanh hợp nhất — làm rõ yêu cầu, lập kế hoạch, triển khai, review và trình bày | `spec-*.md` + mã nguồn |
+
+## Quản Lý Context
+
+Mỗi tài liệu sẽ trở thành context cho phase tiếp theo. PRD cho architect biết những ràng buộc nào quan trọng. Architecture chỉ cho dev agent những pattern cần tuân theo. File story cung cấp context tập trung và đầy đủ cho việc triển khai. Nếu không có cấu trúc này, agent sẽ đưa ra quyết định thiếu nhất quán.
+
+### Project Context
+
+:::tip[Khuyến nghị]
+Hãy tạo `project-context.md` để bảo đảm AI agent tuân theo quy tắc và sở thích của dự án. File này hoạt động như một bản hiến pháp cho dự án của bạn, nó dẫn dắt các quyết định triển khai xuyên suốt mọi workflow. File tùy chọn này có thể được tạo ở cuối bước Architecture Creation, hoặc cũng có thể được sinh trong dự án hiện hữu để ghi lại những điều quan trọng cần giữ đồng bộ với quy ước đang có.
+:::
+
+**Cách tạo:**
+
+- **Thủ công** — Tạo `_bmad-output/project-context.md` với stack công nghệ và các quy tắc triển khai của bạn
+- **Tự sinh** — Chạy `bmad-generate-project-context` để sinh tự động từ architecture hoặc codebase
+
+[**Tìm hiểu thêm về project-context.md**](../explanation/project-context.md)

docs/vi-vn/roadmap.mdx

@@ -0,0 +1,136 @@
+---
+title: Lộ trình
+description: Điều gì sẽ đến tiếp theo với BMad - tính năng mới, cải tiến và đóng góp từ cộng đồng
+---
+
+# Lộ Trình Công Khai Của BMad Method
+
+BMad Method, BMad Method Module (BMM) và BMad Builder (BMB) đang tiếp tục phát triển. Đây là những gì chúng tôi đang thực hiện và sắp ra mắt.
+
+<div class="roadmap-container">
+
+  <h2 class="roadmap-section-title">Đang triển khai</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🧩</span>
+      <h4>Kiến Trúc Skills Phổ Quát</h4>
+      <p>Một skill, dùng trên mọi nền tảng. Viết một lần, chạy ở khắp nơi.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏗️</span>
+      <h4>BMad Builder v1</h4>
+      <p>Tạo AI agent và workflow sẵn sàng cho production với evals, teams và graceful degradation được tích hợp sẵn.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🧠</span>
+      <h4>Hệ Thống Project Context</h4>
+      <p>AI thực sự hiểu dự án của bạn. Ngữ cảnh nhận biết framework và phát triển cùng codebase của bạn.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">📦</span>
+      <h4>Skills Tập Trung</h4>
+      <p>Cài một lần, dùng ở mọi nơi. Chia sẻ skills giữa các dự án mà không làm rối file.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🔄</span>
+      <h4>Skills Thích Ứng</h4>
+      <p>Skills hiểu công cụ bạn đang dùng. Biến thể tối ưu cho Claude, Codex, Kimi, OpenCode và nhiều công cụ khác.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">📝</span>
+      <h4>Blog BMad Team Pros</h4>
+      <p>Các bài hướng dẫn, bài viết và góc nhìn từ đội ngũ. Sắp ra mắt.</p>
+    </div>
+  </div>
+
+  <h2 class="roadmap-section-title">Mới bắt đầu</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏪</span>
+      <h4>Chợ Skills</h4>
+      <p>Khám phá, cài đặt và cập nhật skills do cộng đồng xây dựng. Chỉ cần một lệnh curl là có thêm siêu năng lực.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎨</span>
+      <h4>Tùy Biến Workflow</h4>
+      <p>Biến nó thành của riêng bạn. Tích hợp Jira, Linear, output tùy chỉnh: workflow của bạn, luật của bạn.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🚀</span>
+      <h4>Tối Ưu Hóa Phase 1-3</h4>
+      <p>Lập kế hoạch cực nhanh với cơ chế thu thập context bằng sub-agent. YOLO mode kết hợp với hướng dẫn có kiểm soát.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🌐</span>
+      <h4>Sẵn Sàng Cho Doanh Nghiệp</h4>
+      <p>SSO, audit logs, team workspaces. Toàn bộ phần “không hào nhoáng” nhưng khiến doanh nghiệp yên tâm triển khai.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">💎</span>
+      <h4>Bùng Nổ Module Cộng Đồng</h4>
+      <p>Giải trí, bảo mật, trị liệu, roleplay và nhiều hơn nữa. Mở rộng nền tảng BMad Method.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">⚡</span>
+      <h4>Tự Động Hóa Dev Loop</h4>
+      <p>Chế độ autopilot tùy chọn cho phát triển phần mềm. Để AI xử lý flow trong khi vẫn giữ chất lượng ở mức cao.</p>
+    </div>
+  </div>
+
+  <h2 class="roadmap-section-title">Cộng đồng và đội ngũ</h2>
+
+  <div class="roadmap-future">
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎙️</span>
+      <h4>Podcast The BMad Method</h4>
+      <p>Các cuộc trò chuyện về phát triển phần mềm AI-native. Ra mắt ngày 1 tháng 3 năm 2026.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🎓</span>
+      <h4>Lớp Master Class The BMad Method</h4>
+      <p>Đi từ người dùng thành chuyên gia. Đào sâu vào từng phase, từng workflow và từng bí quyết.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🏗️</span>
+      <h4>Lớp Master Class BMad Builder</h4>
+      <p>Tự xây agent của riêng bạn. Kỹ thuật nâng cao cho lúc bạn đã sẵn sàng tạo ra thứ mới, không chỉ sử dụng.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">⚡</span>
+      <h4>BMad Prototype First</h4>
+      <p>Từ ý tưởng đến prototype chạy được chỉ trong một phiên làm việc. Tạo ứng dụng mơ ước của bạn như một tác phẩm thủ công tinh chỉnh.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🌴</span>
+      <h4>BMad BALM!</h4>
+      <p>Quản trị cuộc sống cho người dùng AI-native. Tasks, habits, goals: AI copilot của bạn cho mọi thứ.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🖥️</span>
+      <h4>Giao Diện Chính Thức</h4>
+      <p>Một giao diện đẹp cho toàn bộ hệ sinh thái BMad. Sức mạnh của CLI, độ hoàn thiện của GUI.</p>
+    </div>
+    <div class="roadmap-future-card">
+      <span class="roadmap-emoji">🔒</span>
+      <h4>BMad in a Box</h4>
+      <p>Tự host, air-gapped, chuẩn doanh nghiệp. Trợ lý AI của bạn, hạ tầng của bạn, quyền kiểm soát của bạn.</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;">Muốn đóng góp?</h3>
+    <p style="color: var(--slate-color-400); margin: 0;">
+      Đây mới chỉ là một phần của những gì đang được lên kế hoạch. Đội ngũ mã nguồn mở BMad luôn chào đón contributor!<br />
+      <a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Tham gia cùng chúng tôi trên GitHub</a> để cùng định hình tương lai của phát triển phần mềm hướng AI.
+    </p>
+    <p style="color: var(--slate-color-400); margin: 1.5rem 0 0;">
+      Nếu bạn thích những gì chúng tôi đang xây dựng, chúng tôi trân trọng cả <a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">hỗ trợ</a> một lần lẫn hàng tháng.
+    </p>
+    <p style="color: var(--slate-color-400); margin: 1rem 0 0;">
+      Với tài trợ doanh nghiệp, hợp tác, diễn thuyết, đào tạo hoặc liên hệ truyền thông:{" "}
+      <a href="mailto:contact@bmadcode.com" style="color: var(--color-in-progress);">contact@bmadcode.com</a>
+    </p>
+  </div>
+</div>

docs/vi-vn/tutorials/getting-started.md

@@ -0,0 +1,276 @@
+---
+title: "Bắt đầu"
+description: Cài đặt BMad và xây dựng dự án đầu tiên của bạn
+---
+
+Xây dựng phần mềm nhanh hơn bằng các workflow vận hành bởi AI, với những agent chuyên biệt hướng dẫn bạn qua các bước lập kế hoạch, kiến trúc và triển khai.
+
+## Bạn Sẽ Học Được Gì
+
+- Cài đặt và khởi tạo BMad Method cho một dự án mới
+- Dùng **BMad-Help** — trợ lý thông minh biết bước tiếp theo bạn nên làm gì
+- Chọn nhánh lập kế hoạch phù hợp với quy mô dự án
+- Đi qua các phase từ yêu cầu đến code chạy được
+- Sử dụng agent và workflow hiệu quả
+
+:::note[Điều kiện tiên quyết]
+- **Node.js 20+** — Bắt buộc cho trình cài đặt
+- **Git** — Khuyến nghị để quản lý phiên bản
+- **IDE có AI** — Claude Code, Cursor hoặc công cụ tương tự
+- **Một ý tưởng dự án** — Chỉ cần đơn giản cũng đủ để học
+:::
+
+:::tip[Cách Dễ Nhất]
+**Cài đặt** → `npx bmad-method install`
+**Hỏi** → `bmad-help what should I do first?`
+**Xây dựng** → Để BMad-Help dẫn bạn qua từng workflow
+:::
+
+## Làm Quen Với BMad-Help: Người Dẫn Đường Thông Minh Của Bạn
+
+**BMad-Help là cách nhanh nhất để bắt đầu với BMad.** Bạn không cần phải nhớ workflow hay phase nào cả, chỉ cần hỏi, và BMad-Help sẽ:
+
+- **Kiểm tra dự án của bạn** để xem những gì đã hoàn thành
+- **Hiển thị các lựa chọn** dựa trên những module bạn đã cài
+- **Đề xuất bước tiếp theo** — bao gồm cả tác vụ bắt buộc đầu tiên
+- **Trả lời câu hỏi** như “Tôi có ý tưởng cho một sản phẩm SaaS, tôi nên bắt đầu từ đâu?”
+
+### Cách Dùng BMad-Help
+
+Chạy trong AI IDE của bạn bằng cách gọi skill:
+
+```text
+bmad-help
+```
+
+Hoặc ghép cùng câu hỏi để nhận hướng dẫn có ngữ cảnh:
+
+```text
+bmad-help I have an idea for a SaaS product, I already know all the features I want. where do I get started?
+```
+
+BMad-Help sẽ trả lời:
+- Điều gì được khuyến nghị trong tình huống của bạn
+- Tác vụ bắt buộc đầu tiên là gì
+- Phần còn lại của quy trình sẽ trông như thế nào
+
+### Nó Cũng Điều Khiển Workflow
+
+BMad-Help không chỉ trả lời câu hỏi — **nó còn tự động chạy ở cuối mỗi workflow** để cho bạn biết chính xác bước tiếp theo cần làm là gì. Không phải đoán, không phải lục tài liệu, chỉ có chỉ dẫn rõ ràng về workflow bắt buộc tiếp theo.
+
+:::tip[Bắt Đầu Từ Đây]
+Sau khi cài BMad, hãy gọi skill `bmad-help` ngay. Nó sẽ nhận biết các module bạn đã cài và hướng bạn đến điểm bắt đầu phù hợp cho dự án.
+:::
+
+## Hiểu Về BMad
+
+BMad giúp bạn xây dựng phần mềm thông qua các workflow có hướng dẫn với những AI agent chuyên biệt. Quy trình gồm bốn phase:
+
+| Phase | Tên | Điều xảy ra |
+| ----- | -------------- | --------------------------------------------------- |
+| 1 | Analysis | Brainstorming, nghiên cứu, product brief hoặc PRFAQ *(tùy chọn)* |
+| 2 | Planning | Tạo tài liệu yêu cầu (PRD hoặc spec) |
+| 3 | Solutioning | Thiết kế kiến trúc *(chỉ dành cho BMad Method/Enterprise)* |
+| 4 | Implementation | Xây dựng theo từng epic, từng story |
+
+**[Mở Workflow Map](../reference/workflow-map.md)** để khám phá các phase, workflow và cách quản lý context.
+
+Dựa trên độ phức tạp của dự án, BMad cung cấp ba nhánh lập kế hoạch:
+
+| Nhánh | Phù hợp nhất với | Tài liệu được tạo |
+| --------------- | ------------------------------------------------------ | -------------------------------------- |
+| **Quick Flow** | Sửa lỗi, tính năng đơn giản, phạm vi rõ ràng (1-15 story) | Chỉ spec |
+| **BMad Method** | Sản phẩm, nền tảng, tính năng phức tạp (10-50+ story) | PRD + Architecture + UX |
+| **Enterprise** | Yêu cầu tuân thủ, hệ thống đa tenant (30+ story) | PRD + Architecture + Security + DevOps |
+
+:::note
+Số lượng story chỉ là gợi ý, không phải định nghĩa cứng. Hãy chọn nhánh dựa trên nhu cầu lập kế hoạch, không phải phép đếm story.
+:::
+
+## Cài Đặt
+
+Mở terminal trong thư mục dự án và chạy:
+
+```bash
+npx bmad-method install
+```
+
+Nếu bạn muốn dùng bản prerelease mới nhất thay vì kênh release mặc định, hãy dùng `npx bmad-method@next install`.
+
+Khi được hỏi chọn module, hãy chọn **BMad Method**.
+
+Trình cài đặt sẽ tạo hai thư mục:
+- `_bmad/` — agents, workflows, tasks và cấu hình
+- `_bmad-output/` — hiện tại để trống, nhưng đây là nơi các artifact của bạn sẽ được lưu
+
+:::tip[Bước Tiếp Theo Của Bạn]
+Mở AI IDE trong thư mục dự án rồi chạy:
+
+```text
+bmad-help
+```
+
+BMad-Help sẽ nhận biết bạn đã làm đến đâu và đề xuất chính xác bước tiếp theo. Bạn cũng có thể hỏi những câu như “Tôi có những lựa chọn nào?” hoặc “Tôi có ý tưởng SaaS, nên bắt đầu từ đâu?”
+:::
+
+:::note[Cách Nạp Agent Và Chạy Workflow]
+Mỗi workflow có một **skill** được gọi bằng tên trong IDE của bạn, ví dụ `bmad-create-prd`. Công cụ AI sẽ nhận diện tên `bmad-*` và chạy nó, bạn không cần nạp agent riêng. Bạn cũng có thể gọi trực tiếp skill của agent để trò chuyện tổng quát, ví dụ `bmad-agent-pm` cho PM agent.
+:::
+
+:::caution[Chat Mới]
+Luôn bắt đầu một chat mới cho mỗi workflow. Điều này tránh các vấn đề do giới hạn context gây ra.
+:::
+
+## Bước 1: Tạo Kế Hoạch
+
+Đi qua các phase 1-3. **Dùng chat mới cho từng workflow.**
+
+:::tip[Project Context (Tùy chọn)]
+Trước khi bắt đầu, hãy cân nhắc tạo `project-context.md` để ghi lại các ưu tiên kỹ thuật và quy tắc triển khai. Nhờ vậy mọi AI agent sẽ tuân theo cùng một quy ước trong suốt dự án.
+
+Bạn có thể tạo thủ công tại `_bmad-output/project-context.md` hoặc sinh ra sau phần kiến trúc bằng `bmad-generate-project-context`. [Xem thêm](../explanation/project-context.md).
+:::
+
+### Phase 1: Analysis (Tùy chọn)
+
+Tất cả workflow trong phase này đều là tùy chọn. [**Chưa chắc nên dùng cái nào?**](../explanation/analysis-phase.md)
+- **brainstorming** (`bmad-brainstorming`) — Gợi ý ý tưởng có hướng dẫn
+- **research** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Nghiên cứu thị trường, miền nghiệp vụ và kỹ thuật
+- **product-brief** (`bmad-product-brief`) — Tài liệu nền tảng được khuyến nghị khi concept của bạn đã rõ
+- **prfaq** (`bmad-prfaq`) — Bài kiểm tra Working Backwards để stress-test và rèn sắc concept sản phẩm của bạn
+
+### Phase 2: Planning (Bắt buộc)
+
+**Với nhánh BMad Method và Enterprise:**
+1. Gọi **PM agent** (`bmad-agent-pm`) trong một chat mới
+2. Chạy workflow `bmad-create-prd` (`bmad-create-prd`)
+3. Kết quả: `PRD.md`
+
+**Với nhánh Quick Flow:**
+- Chạy `bmad-quick-dev` — workflow này gộp cả planning và implementation trong một lần, nên bạn có thể chuyển thẳng sang triển khai
+
+:::note[Thiết kế UX (Tùy chọn)]
+Nếu dự án của bạn có giao diện người dùng, hãy gọi **UX-Designer agent** (`bmad-agent-ux-designer`) và chạy workflow thiết kế UX (`bmad-create-ux-design`) sau khi tạo PRD.
+:::
+
+### Phase 3: Solutioning (BMad Method/Enterprise)
+
+**Tạo Architecture**
+1. Gọi **Architect agent** (`bmad-agent-architect`) trong một chat mới
+2. Chạy `bmad-create-architecture` (`bmad-create-architecture`)
+3. Kết quả: tài liệu kiến trúc chứa các quyết định kỹ thuật
+
+**Tạo Epics và Stories**
+
+:::tip[Cải tiến trong V6]
+Epics và stories giờ được tạo *sau* kiến trúc. Điều này giúp story có chất lượng tốt hơn vì các quyết định kiến trúc như database, API pattern và tech stack ảnh hưởng trực tiếp đến cách chia nhỏ công việc.
+:::
+
+1. Gọi **PM agent** (`bmad-agent-pm`) trong một chat mới
+2. Chạy `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
+3. Workflow sẽ dùng cả PRD lẫn Architecture để tạo story có đủ ngữ cảnh kỹ thuật
+
+**Kiểm tra mức sẵn sàng để triển khai** *(Rất nên dùng)*
+1. Gọi **Architect agent** (`bmad-agent-architect`) trong một chat mới
+2. Chạy `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
+3. Xác nhận tính nhất quán giữa toàn bộ tài liệu lập kế hoạch
+
+## Bước 2: Xây Dựng Dự Án
+
+Sau khi lập kế hoạch xong, chuyển sang implementation. **Mỗi workflow nên chạy trong một chat mới.**
+
+### Khởi Tạo Sprint Planning
+
+Gọi **Developer agent** (`bmad-agent-dev`) và chạy `bmad-sprint-planning` (`bmad-sprint-planning`). Workflow này sẽ tạo `sprint-status.yaml` để theo dõi toàn bộ epic và story.
+
+### Chu Trình Xây Dựng
+
+Với mỗi story, lặp lại chu trình này trong chat mới:
+
+| Bước | Agent | Workflow | Lệnh | Mục đích |
+| ---- | ----- | -------------- | -------------------------- | ---------------------------------- |
+| 1 | DEV | `bmad-create-story` | `bmad-create-story` | Tạo file story từ epic |
+| 2 | DEV | `bmad-dev-story` | `bmad-dev-story` | Triển khai story |
+| 3 | DEV | `bmad-code-review` | `bmad-code-review` | Kiểm tra chất lượng *(khuyến nghị)* |
+
+Sau khi hoàn tất tất cả story trong một epic, hãy gọi **Developer agent** (`bmad-agent-dev`) và chạy `bmad-retrospective` (`bmad-retrospective`).
+
+## Bạn Đã Hoàn Thành Những Gì
+
+Bạn đã nắm được nền tảng để xây dựng với BMad:
+
+- Đã cài BMad và cấu hình cho IDE của bạn
+- Đã khởi tạo dự án theo nhánh lập kế hoạch phù hợp
+- Đã tạo các tài liệu lập kế hoạch (PRD, Architecture, Epics và Stories)
+- Đã hiểu chu trình triển khai trong implementation
+
+Dự án của bạn bây giờ sẽ có dạng:
+
+```text
+your-project/
+├── _bmad/                                   # Cấu hình BMad
+├── _bmad-output/
+│   ├── planning-artifacts/
+│   │   ├── PRD.md                           # Tài liệu yêu cầu của bạn
+│   │   ├── architecture.md                  # Các quyết định kỹ thuật
+│   │   └── epics/                           # Các file epic và story
+│   ├── implementation-artifacts/
+│   │   └── sprint-status.yaml               # Theo dõi sprint
+│   └── project-context.md                   # Quy tắc triển khai (tùy chọn)
+└── ...
+```
+
+## Tra Cứu Nhanh
+
+| Workflow | Lệnh | Agent | Mục đích |
+| ------------------------------------- | ------------------------------------------ | --------- | ----------------------------------------------- |
+| **`bmad-help`** ⭐ | `bmad-help` | Bất kỳ | **Người dẫn đường thông minh của bạn — hỏi gì cũng được!** |
+| `bmad-create-prd` | `bmad-create-prd` | PM | Tạo tài liệu yêu cầu sản phẩm |
+| `bmad-create-architecture` | `bmad-create-architecture` | Architect | Tạo tài liệu kiến trúc |
+| `bmad-generate-project-context` | `bmad-generate-project-context` | Analyst | Tạo file project context |
+| `bmad-create-epics-and-stories` | `bmad-create-epics-and-stories` | PM | Phân rã PRD thành epics |
+| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Kiểm tra độ nhất quán của kế hoạch |
+| `bmad-sprint-planning` | `bmad-sprint-planning` | DEV | Khởi tạo theo dõi sprint |
+| `bmad-create-story` | `bmad-create-story` | DEV | Tạo file story |
+| `bmad-dev-story` | `bmad-dev-story` | DEV | Triển khai một story |
+| `bmad-code-review` | `bmad-code-review` | DEV | Review phần code đã triển khai |
+
+## Câu Hỏi Thường Gặp
+
+**Lúc nào cũng cần kiến trúc à?**
+Chỉ với nhánh BMad Method và Enterprise. Quick Flow bỏ qua bước kiến trúc và chuyển thẳng từ spec sang implementation.
+
+**Tôi có thể đổi kế hoạch về sau không?**
+Có. Workflow `bmad-correct-course` (`bmad-correct-course`) xử lý thay đổi phạm vi giữa chừng.
+
+**Nếu tôi muốn brainstorming trước thì sao?**
+Gọi Analyst agent (`bmad-agent-analyst`) và chạy `bmad-brainstorming` (`bmad-brainstorming`) trước khi bắt đầu PRD.
+
+**Tôi có cần tuân theo đúng thứ tự tuyệt đối không?**
+Không hẳn. Khi đã quen flow, bạn có thể chạy workflow trực tiếp bằng bảng Tra Cứu Nhanh ở trên.
+
+## Nhận Hỗ Trợ
+
+:::tip[Điểm Dừng Đầu Tiên: BMad-Help]
+**Hãy gọi `bmad-help` bất cứ lúc nào** — đây là cách nhanh nhất để gỡ vướng. Bạn có thể hỏi:
+- "Tôi nên làm gì sau khi cài đặt?"
+- "Tôi đang kẹt ở workflow X"
+- "Tôi có những lựa chọn nào cho Y?"
+- "Cho tôi xem đến giờ đã làm được gì"
+
+BMad-Help sẽ kiểm tra dự án, phát hiện những gì bạn đã hoàn thành và chỉ cho bạn chính xác bước cần làm tiếp theo.
+:::
+
+- **Trong workflow** — Các agent sẽ hướng dẫn bạn bằng câu hỏi và giải thích
+- **Cộng đồng** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
+
+## Những Điểm Cần Ghi Nhớ
+
+:::tip[Hãy Nhớ Các Điểm Này]
+- **Bắt đầu với `bmad-help`** — Trợ lý thông minh hiểu dự án và các lựa chọn của bạn
+- **Luôn dùng chat mới** — Mỗi workflow nên bắt đầu trong một chat riêng
+- **Nhánh rất quan trọng** — Quick Flow dùng `bmad-quick-dev`; Method/Enterprise cần PRD và kiến trúc
+- **BMad-Help chạy tự động** — Mỗi workflow đều kết thúc bằng hướng dẫn về bước tiếp theo
+:::
+
+Sẵn sàng bắt đầu chưa? Hãy cài BMad, gọi `bmad-help`, và để người dẫn đường thông minh của bạn đưa bạn đi tiếp.

docs/zh-cn/_STYLE_GUIDE.md

@@ -353,7 +353,7 @@ Only for BMad Method and Enterprise tracks. Quick Flow skips to implementation.
 
 ### Can I change my plan later?
 
-Yes. The SM agent has a `bmad-correct-course` workflow for handling scope changes.
+Yes. The `bmad-correct-course` workflow handles scope changes mid-implementation.
 
 **Have a question not answered here?** [Open an issue](...) or ask in [Discord](...).
 ```

docs/zh-cn/how-to/upgrade-to-v6.md

@@ -65,8 +65,8 @@ v6 新技能会安装到：
 
 1. 完成 v6 安装
 2. 将 `epics.md` 或 `epics/epic*.md` 放入 `_bmad-output/planning-artifacts/`
-3. 运行 Scrum Master 的 `bmad-sprint-planning` 工作流
-4. 告诉 SM 哪些史诗/故事已经完成
+3. 运行 Developer 的 `bmad-sprint-planning` 工作流
+4. 告知智能体哪些史诗/故事已经完成
 
 ## 你将获得
 

docs/zh-cn/reference/agents.md

@@ -14,14 +14,13 @@ sidebar:
 | Analyst (Mary) | `bmad-analyst` | `BP`、`RS`、`CB`、`DP` | Brainstorm、Research、Create Brief、Document Project |
 | Product Manager (John) | `bmad-pm` | `CP`、`VP`、`EP`、`CE`、`IR`、`CC` | Create/Validate/Edit PRD、Create Epics and Stories、Implementation Readiness、Correct Course |
 | Architect (Winston) | `bmad-architect` | `CA`、`IR` | Create Architecture、Implementation Readiness |
-| Scrum Master (Bob) | `bmad-sm` | `SP`、`CS`、`ER`、`CC` | Sprint Planning、Create Story、Epic Retrospective、Correct Course |
-| Developer (Amelia) | `bmad-dev` | `DS`、`QD`、`QA`、`CR` | Dev Story、Quick Dev、QA Test Generation、Code Review |
+| Developer (Amelia) | `bmad-agent-dev` | `DS`、`QD`、`QA`、`CR`、`SP`、`CS`、`ER` | Dev Story、Quick Dev、QA Test Generation、Code Review、Sprint Planning、Create Story、Epic Retrospective |
 | UX Designer (Sally) | `bmad-ux-designer` | `CU` | Create UX Design |
 | Technical Writer (Paige) | `bmad-tech-writer` | `DP`、`WD`、`US`、`MG`、`VD`、`EC` | Document Project、Write Document、Update Standards、Mermaid Generate、Validate Doc、Explain Concept |
 
 ## 使用说明
 
-- `Skill ID` 是直接调用该智能体的名称（例如 `bmad-dev`）
+- `Skill ID` 是直接调用该智能体的名称（例如 `bmad-agent-dev`）
 - 触发器是进入智能体会话后可使用的菜单短码
 - QA 测试生成由 `bmad-qa-generate-e2e-tests` workflow skill 处理，通过 Developer 智能体调用；完整 TEA 能力位于独立模块
 

docs/zh-cn/reference/commands.md

@@ -48,12 +48,12 @@ sidebar:
 │   └── SKILL.md
 ├── bmad-create-prd/
 │   └── SKILL.md
-├── bmad-dev/
+├── bmad-agent-dev/
 │   └── SKILL.md
 └── ...
 ```
 
-skill 目录名就是调用名，例如 `bmad-dev/` 对应 skill `bmad-dev`。
+skill 目录名就是调用名，例如 `bmad-agent-dev/` 对应 skill `bmad-agent-dev`。
 
 ## 如何发现可用 skills
 
@@ -73,10 +73,9 @@ skill 目录名就是调用名，例如 `bmad-dev/` 对应 skill `bmad-dev`。
 
 | 示例 skill | 角色 | 用途 |
 | --- | --- | --- |
-| `bmad-dev` | Developer（Amelia） | 按规范实现 story |
+| `bmad-agent-dev` | Developer（Amelia） | 按规范实现 story |
 | `bmad-pm` | Product Manager（John） | 创建与校验 PRD |
 | `bmad-architect` | Architect（Winston） | 架构设计与约束定义 |
-| `bmad-sm` | Scrum Master（Bob） | 冲刺与 story 流程管理 |
 
 完整列表见 [智能体参考](./agents.md)。
 
@@ -105,7 +104,7 @@ skill 目录名就是调用名，例如 `bmad-dev/` 对应 skill `bmad-dev`。
 
 ## 命名规则
 
-所有技能统一以 `bmad-` 开头，后接语义化名称（如 `bmad-dev`、`bmad-create-prd`、`bmad-help`）。
+所有技能统一以 `bmad-` 开头，后接语义化名称（如 `bmad-agent-dev`、`bmad-create-prd`、`bmad-help`）。
 
 ## 故障排查
 

docs/zh-cn/tutorials/getting-started.md

@@ -180,7 +180,7 @@ BMad-Help 将检测你已完成的内容，并准确推荐下一步该做什么
 
 ### 初始化冲刺规划
 
-调用 **SM 智能体**（`bmad-agent-sm`）并运行 `bmad-sprint-planning`（`bmad-sprint-planning`）。这会创建 `sprint-status.yaml` 来跟踪所有史诗和故事。
+调用 **Developer 智能体**（`bmad-agent-dev`）并运行 `bmad-sprint-planning`（`bmad-sprint-planning`）。这会创建 `sprint-status.yaml` 来跟踪所有史诗和故事。
 
 ### 构建周期
 
@@ -188,11 +188,11 @@ BMad-Help 将检测你已完成的内容，并准确推荐下一步该做什么
 
 | 步骤 | 智能体 | 工作流       | 命令                    | 目的                            |
 | ---- | ------ | ------------ | ----------------------- | ------------------------------- |
-| 1    | SM     | `bmad-create-story` | `bmad-create-story` | 从史诗创建故事文件              |
+| 1    | DEV    | `bmad-create-story` | `bmad-create-story` | 从史诗创建故事文件              |
 | 2    | DEV    | `bmad-dev-story`    | `bmad-dev-story`    | 实现故事                        |
 | 3    | DEV    | `bmad-code-review`  | `bmad-code-review`  | 质量验证 *（推荐）*             |
 
-完成史诗中的所有故事后，调用 **SM 智能体**（`bmad-agent-sm`）并运行 `bmad-retrospective`（`bmad-retrospective`）。
+完成史诗中的所有故事后，调用 **Developer 智能体**（`bmad-agent-dev`）并运行 `bmad-retrospective`（`bmad-retrospective`）。
 
 ## 你已完成的工作
 
@@ -229,8 +229,8 @@ your-project/
 | `bmad-generate-project-context`     | `bmad-generate-project-context`        | Analyst  | 创建项目上下文文件                           |
 | `bmad-create-epics-and-stories`     | `bmad-create-epics-and-stories`        | PM       | 将 PRD 分解为史诗                            |
 | `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | 验证规划一致性                              |
-| `bmad-sprint-planning`              | `bmad-sprint-planning`                 | SM       | 初始化冲刺跟踪                               |
-| `bmad-create-story`                 | `bmad-create-story`                    | SM       | 创建故事文件                                 |
+| `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      | 审查已实现的代码                             |
 
@@ -240,7 +240,7 @@ your-project/
 仅对于 BMad Method 和 Enterprise 路径。Quick Flow 从技术规范跳转到实现。
 
 **我可以稍后更改我的计划吗？**
-可以。SM 智能体提供 `bmad-correct-course` 工作流（`bmad-correct-course`）来处理范围变化。
+可以。`bmad-correct-course` 工作流用于处理实现过程中的范围变化。
 
 **如果我想先进行头脑风暴怎么办？**
 在开始 PRD 之前，调用 Analyst 智能体（`bmad-agent-analyst`）并运行 `bmad-brainstorming`（`bmad-brainstorming`）。

removals.txt

@@ -0,0 +1,17 @@
+# BMad Method - Skill Removal List
+# Entries listed here will be removed from IDE skill directories during install/update.
+# One entry per line. Lines starting with # are comments.
+# Each entry is a skill directory name (canonicalId) that was removed or renamed.
+
+# Removed agents (v6.2.0 - v6.2.2)
+bmad-agent-sm
+bmad-agent-qa
+bmad-agent-quick-flow-solo-dev
+
+# Removed skills (v6.2.0 - v6.2.2)
+bmad-create-product-brief
+bmad-product-brief-preview
+bmad-quick-spec
+bmad-quick-flow
+bmad-quick-dev-new-preview
+bmad-init

src/bmm-skills/2-plan-workflows/bmad-create-ux-design/steps/step-13-responsive-accessibility.md

@@ -240,7 +240,7 @@ When user selects 'C', append the content directly to the document using the str
 ✅ Appropriate breakpoint strategy established
 ✅ Accessibility requirements determined and documented
 ✅ Comprehensive testing strategy planned
-✅ Implementation guidelines provided for development team
+✅ Implementation guidelines provided for Developer agent
 ✅ A/P/C menu presented and handled correctly
 ✅ Content properly appended to document when C selected
 

src/bmm-skills/2-plan-workflows/bmad-edit-prd/data/prd-purpose.md

@@ -0,0 +1,197 @@
+# BMAD PRD Purpose
+
+**The PRD is the top of the required funnel that feeds all subsequent product development work in rhw BMad Method.**
+
+---
+
+## What is a BMAD PRD?
+
+A dual-audience document serving:
+1. **Human Product Managers and builders** - Vision, strategy, stakeholder communication
+2. **LLM Downstream Consumption** - UX Design → Architecture → Epics → Development AI Agents
+
+Each successive document becomes more AI-tailored and granular.
+
+---
+
+## Core Philosophy: Information Density
+
+**High Signal-to-Noise Ratio**
+
+Every sentence must carry information weight. LLMs consume precise, dense content efficiently.
+
+**Anti-Patterns (Eliminate These):**
+- ❌ "The system will allow users to..." → ✅ "Users can..."
+- ❌ "It is important to note that..." → ✅ State the fact directly
+- ❌ "In order to..." → ✅ "To..."
+- ❌ Conversational filler and padding → ✅ Direct, concise statements
+
+**Goal:** Maximum information per word. Zero fluff.
+
+---
+
+## The Traceability Chain
+
+**PRD starts the chain:**
+```
+Vision → Success Criteria → User Journeys → Functional Requirements → (future: User Stories)
+```
+
+**In the PRD, establish:**
+- Vision → Success Criteria alignment
+- Success Criteria → User Journey coverage
+- User Journey → Functional Requirement mapping
+- All requirements traceable to user needs
+
+**Why:** Each downstream artifact (UX, Architecture, Epics, Stories) must trace back to documented user needs and business objectives. This chain ensures we build the right thing.
+
+---
+
+## What Makes Great Functional Requirements?
+
+### FRs are Capabilities, Not Implementation
+
+**Good FR:** "Users can reset their password via email link"
+**Bad FR:** "System sends JWT via email and validates with database" (implementation leakage)
+
+**Good FR:** "Dashboard loads in under 2 seconds for 95th percentile"
+**Bad FR:** "Fast loading time" (subjective, unmeasurable)
+
+### SMART Quality Criteria
+
+**Specific:** Clear, precisely defined capability
+**Measurable:** Quantifiable with test criteria
+**Attainable:** Realistic within constraints
+**Relevant:** Aligns with business objectives
+**Traceable:** Links to source (executive summary or user journey)
+
+### FR Anti-Patterns
+
+**Subjective Adjectives:**
+- ❌ "easy to use", "intuitive", "user-friendly", "fast", "responsive"
+- ✅ Use metrics: "completes task in under 3 clicks", "loads in under 2 seconds"
+
+**Implementation Leakage:**
+- ❌ Technology names, specific libraries, implementation details
+- ✅ Focus on capability and measurable outcomes
+
+**Vague Quantifiers:**
+- ❌ "multiple users", "several options", "various formats"
+- ✅ "up to 100 concurrent users", "3-5 options", "PDF, DOCX, TXT formats"
+
+**Missing Test Criteria:**
+- ❌ "The system shall provide notifications"
+- ✅ "The system shall send email notifications within 30 seconds of trigger event"
+
+---
+
+## What Makes Great Non-Functional Requirements?
+
+### NFRs Must Be Measurable
+
+**Template:**
+```
+"The system shall [metric] [condition] [measurement method]"
+```
+
+**Examples:**
+- ✅ "The system shall respond to API requests in under 200ms for 95th percentile as measured by APM monitoring"
+- ✅ "The system shall maintain 99.9% uptime during business hours as measured by cloud provider SLA"
+- ✅ "The system shall support 10,000 concurrent users as measured by load testing"
+
+### NFR Anti-Patterns
+
+**Unmeasurable Claims:**
+- ❌ "The system shall be scalable" → ✅ "The system shall handle 10x load growth through horizontal scaling"
+- ❌ "High availability required" → ✅ "99.9% uptime as measured by cloud provider SLA"
+
+**Missing Context:**
+- ❌ "Response time under 1 second" → ✅ "API response time under 1 second for 95th percentile under normal load"
+
+---
+
+## Domain-Specific Requirements
+
+**Auto-Detect and Enforce Based on Project Context**
+
+Certain industries have mandatory requirements that must be present:
+
+- **Healthcare:** HIPAA Privacy & Security Rules, PHI encryption, audit logging, MFA
+- **Fintech:** PCI-DSS Level 1, AML/KYC compliance, SOX controls, financial audit trails
+- **GovTech:** NIST framework, Section 508 accessibility (WCAG 2.1 AA), FedRAMP, data residency
+- **E-Commerce:** PCI-DSS for payments, inventory accuracy, tax calculation by jurisdiction
+
+**Why:** Missing these requirements in the PRD means they'll be missed in architecture and implementation, creating expensive rework. During PRD creation there is a step to cover this - during validation we want to make sure it was covered. For this purpose steps will utilize a domain-complexity.csv and project-types.csv.
+
+---
+
+## Document Structure (Markdown, Human-Readable)
+
+### Required Sections
+1. **Executive Summary** - Vision, differentiator, target users
+2. **Success Criteria** - Measurable outcomes (SMART)
+3. **Product Scope** - MVP, Growth, Vision phases
+4. **User Journeys** - Comprehensive coverage
+5. **Domain Requirements** - Industry-specific compliance (if applicable)
+6. **Innovation Analysis** - Competitive differentiation (if applicable)
+7. **Project-Type Requirements** - Platform-specific needs
+8. **Functional Requirements** - Capability contract (FRs)
+9. **Non-Functional Requirements** - Quality attributes (NFRs)
+
+### Formatting for Dual Consumption
+
+**For Humans:**
+- Clear, professional language
+- Logical flow from vision to requirements
+- Easy for stakeholders to review and approve
+
+**For LLMs:**
+- ## Level 2 headers for all main sections (enables extraction)
+- Consistent structure and patterns
+- Precise, testable language
+- High information density
+
+---
+
+## Downstream Impact
+
+**How the PRD Feeds Next Artifacts:**
+
+**UX Design:**
+- User journeys → interaction flows
+- FRs → design requirements
+- Success criteria → UX metrics
+
+**Architecture:**
+- FRs → system capabilities
+- NFRs → architecture decisions
+- Domain requirements → compliance architecture
+- Project-type requirements → platform choices
+
+**Epics & Stories (created after architecture):**
+- FRs → user stories (1 FR could map to 1-3 stories potentially)
+- Acceptance criteria → story acceptance tests
+- Priority → sprint sequencing
+- Traceability → stories map back to vision
+
+**Development AI Agents:**
+- Precise requirements → implementation clarity
+- Test criteria → automated test generation
+- Domain requirements → compliance enforcement
+- Measurable NFRs → performance targets
+
+---
+
+## Summary: What Makes a Great BMAD PRD?
+
+✅ **High Information Density** - Every sentence carries weight, zero fluff
+✅ **Measurable Requirements** - All FRs and NFRs are testable with specific criteria
+✅ **Clear Traceability** - Each requirement links to user need and business objective
+✅ **Domain Awareness** - Industry-specific requirements auto-detected and included
+✅ **Zero Anti-Patterns** - No subjective adjectives, implementation leakage, or vague quantifiers
+✅ **Dual Audience Optimized** - Human-readable AND LLM-consumable
+✅ **Markdown Format** - Professional, clean, accessible to all stakeholders
+
+---
+
+**Remember:** The PRD is the foundation. Quality here ripples through every subsequent phase. A dense, precise, well-traced PRD makes UX design, architecture, epic breakdown, and AI development dramatically more effective.

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-01-discovery.md

@@ -1,6 +1,6 @@
 ---
 # File references (ONLY variables used in this step)
-prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md'
+prdPurpose: '../data/prd-purpose.md'
 ---
 
 # Step E-1: Discovery & Understanding

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-01b-legacy-conversion.md

@@ -1,7 +1,7 @@
 ---
 # File references (ONLY variables used in this step)
 prdFile: '{prd_file_path}'
-prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md'
+prdPurpose: '../data/prd-purpose.md'
 ---
 
 # Step E-1B: Legacy PRD Conversion Assessment

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-02-review.md

@@ -2,7 +2,7 @@
 # File references (ONLY variables used in this step)
 prdFile: '{prd_file_path}'
 validationReport: '{validation_report_path}'  # If provided
-prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md'
+prdPurpose: '../data/prd-purpose.md'
 ---
 
 # Step E-2: Deep Review & Analysis

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-03-edit.md

@@ -1,7 +1,7 @@
 ---
 # File references (ONLY variables used in this step)
 prdFile: '{prd_file_path}'
-prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md'
+prdPurpose: '../data/prd-purpose.md'
 ---
 
 # Step E-3: Edit & Update

src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-04-complete.md

@@ -1,7 +1,6 @@
 ---
 # File references (ONLY variables used in this step)
 prdFile: '{prd_file_path}'
-validationWorkflow: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-01-discovery.md'
 ---
 
 # Step E-4: Complete & Validate
@@ -117,8 +116,7 @@ Display:
   - Display: "This will run all 13 validation checks on the updated PRD."
   - Display: "Preparing to validate: {prd_file_path}"
   - Display: "**Proceeding to validation...**"
-  - Read fully and follow: {validationWorkflow} (steps-v/step-v-01-discovery.md)
-  - Note: This hands off to the validation workflow which will run its complete 13-step process
+  - Invoke the `bmad-validate-prd` skill to run the complete validation workflow
 
 - **IF E (Edit More):**
   - Display: "**Additional Edits**"

src/bmm-skills/3-solutioning/bmad-check-implementation-readiness/steps/step-01-document-discovery.md

@@ -20,7 +20,7 @@ To discover, inventory, and organize all project documents, identifying duplicat
 
 ### Role Reinforcement:
 
-- ✅ You are an expert Product Manager and Scrum Master
+- ✅ You are an expert Product Manager
 - ✅ Your focus is on finding organizing and documenting what exists
 - ✅ You identify ambiguities and ask for clarification
 - ✅ Success is measured in clear file inventory and conflict resolution

src/bmm-skills/3-solutioning/bmad-check-implementation-readiness/steps/step-02-prd-analysis.md

@@ -21,7 +21,7 @@ To fully read and analyze the PRD document (whole or sharded) to extract all Fun
 
 ### Role Reinforcement:
 
-- ✅ You are an expert Product Manager and Scrum Master
+- ✅ You are an expert Product Manager
 - ✅ Your expertise is in requirements analysis and traceability
 - ✅ You think critically about requirement completeness
 - ✅ Success is measured in thorough requirement extraction

src/bmm-skills/3-solutioning/bmad-check-implementation-readiness/steps/step-03-epic-coverage-validation.md

@@ -20,7 +20,7 @@ To validate that all Functional Requirements from the PRD are captured in the ep
 
 ### Role Reinforcement:
 
-- ✅ You are an expert Product Manager and Scrum Master
+- ✅ You are an expert Product Manager
 - ✅ Your expertise is in requirements traceability
 - ✅ You ensure no requirements fall through the cracks
 - ✅ Success is measured in complete FR coverage

src/bmm-skills/3-solutioning/bmad-check-implementation-readiness/workflow.md

@@ -2,7 +2,7 @@
 
 **Goal:** Validate that PRD, Architecture, Epics and Stories are complete and aligned before Phase 4 implementation starts, with a focus on ensuring epics and stories are logical and have accounted for all requirements and planning.
 
-**Your Role:** You are an expert Product Manager and Scrum Master, renowned and respected in the field of requirements traceability and spotting gaps in planning. Your success is measured in spotting the failures others have made in planning or preparation of epics and stories to produce the users product vision.
+**Your Role:** You are an expert Product Manager, renowned and respected in the field of requirements traceability and spotting gaps in planning. Your success is measured in spotting the failures others have made in planning or preparation of epics and stories to produce the user's product vision.
 
 ## WORKFLOW ARCHITECTURE
 

src/bmm-skills/3-solutioning/bmad-create-epics-and-stories/workflow.md

@@ -1,6 +1,6 @@
 # Create Epics and Stories
 
-**Goal:** Transform PRD requirements and Architecture decisions into comprehensive stories organized by user value, creating detailed, actionable stories with complete acceptance criteria for development teams.
+**Goal:** Transform PRD requirements and Architecture decisions into comprehensive stories organized by user value, creating detailed, actionable stories with complete acceptance criteria for the Developer agent.
 
 **Your Role:** In addition to your name, communication_style, and persona, you are also a product strategist and technical specifications writer collaborating with a product owner. This is a partnership, not a client-vendor relationship. You bring expertise in requirements decomposition, technical implementation context, and acceptance criteria writing, while the user brings their product vision, user needs, and business requirements. Work together as equals.
 

src/bmm-skills/4-implementation/bmad-agent-dev/SKILL.md

@@ -45,6 +45,9 @@ When you are in this persona and the user calls a skill, this persona must carry
 | QD | Unified quick flow — clarify intent, plan, implement, review, present | bmad-quick-dev |
 | QA | Generate API and E2E tests for existing features | bmad-qa-generate-e2e-tests |
 | CR | Initiate a comprehensive code review across multiple quality facets | bmad-code-review |
+| SP | Generate or update the sprint plan that sequences tasks for implementation | bmad-sprint-planning |
+| CS | Prepare a story with all required context for implementation | bmad-create-story |
+| ER | Party mode review of all work completed across an epic | bmad-retrospective |
 
 ## On Activation
 

src/bmm-skills/4-implementation/bmad-agent-sm/SKILL.md

@@ -1,55 +0,0 @@
----
-name: bmad-agent-sm
-description: Scrum master for sprint planning and story preparation. Use when the user asks to talk to Bob or requests the scrum master.
----
-
-# Bob
-
-## Overview
-
-This skill provides a Technical Scrum Master who manages sprint planning, story preparation, and agile ceremonies. Act as Bob — crisp, checklist-driven, with zero tolerance for ambiguity. A servant leader who helps with any task while keeping the team focused and stories crystal clear.
-
-## Identity
-
-Certified Scrum Master with deep technical background. Expert in agile ceremonies, story preparation, and creating clear actionable user stories.
-
-## Communication Style
-
-Crisp and checklist-driven. Every word has a purpose, every requirement crystal clear. Zero tolerance for ambiguity.
-
-## Principles
-
-- I strive to be a servant leader and conduct myself accordingly, helping with any task and offering suggestions.
-- I love to talk about Agile process and theory whenever anyone wants to talk about it.
-
-You must fully embody this persona so the user gets the best experience and help they need, therefore its important to remember you must not break character until the users dismisses this persona.
-
-When you are in this persona and the user calls a skill, this persona must carry through and remain active.
-
-## Capabilities
-
-| Code | Description | Skill |
-|------|-------------|-------|
-| SP | Generate or update the sprint plan that sequences tasks for the dev agent to follow | bmad-sprint-planning |
-| CS | Prepare a story with all required context for implementation by the developer agent | bmad-create-story |
-| ER | Party mode review of all work completed across an epic | bmad-retrospective |
-| CC | Determine how to proceed if major need for change is discovered mid implementation | bmad-correct-course |
-
-## On Activation
-
-1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
-   - Use `{user_name}` for greeting
-   - Use `{communication_language}` for all communications
-   - Use `{document_output_language}` for output documents
-   - Use `{planning_artifacts}` for output location and artifact scanning
-   - Use `{project_knowledge}` for additional context scanning
-
-2. **Continue with steps below:**
-   - **Load project context** — Search for `**/project-context.md`. If found, load as foundational reference for project standards and conventions. If not found, continue without it.
-   - **Greet and present capabilities** — Greet `{user_name}` warmly by name, always speaking in `{communication_language}` and applying your persona throughout the session.
-
-3. Remind the user they can invoke the `bmad-help` skill at any time for advice and then present the capabilities table from the Capabilities section above.
-
-   **STOP and WAIT for user input** — Do NOT execute menu items automatically. Accept number, menu code, or fuzzy command match.
-
-**CRITICAL Handling:** When user responds with a code, line number or skill, invoke the corresponding skill by its exact registered name from the Capabilities table. DO NOT invent capabilities on the fly.

src/bmm-skills/4-implementation/bmad-agent-sm/bmad-skill-manifest.yaml

@@ -1,11 +0,0 @@
-type: agent
-name: bmad-agent-sm
-displayName: Bob
-title: Scrum Master
-icon: "🏃"
-capabilities: "sprint planning, story preparation, agile ceremonies, backlog management"
-role: Technical Scrum Master + Story Preparation Specialist
-identity: "Certified Scrum Master with deep technical background. Expert in agile ceremonies, story preparation, and creating clear actionable user stories."
-communicationStyle: "Crisp and checklist-driven. Every word has a purpose, every requirement crystal clear. Zero tolerance for ambiguity."
-principles: "I strive to be a servant leader and conduct myself accordingly, helping with any task and offering suggestions. I love to talk about Agile process and theory whenever anyone wants to talk about it."
-module: bmm

src/bmm-skills/4-implementation/bmad-code-review/steps/step-01-gather-context.md

@@ -15,18 +15,37 @@ story_key: '' # set at runtime when discovered from sprint status
 
 ## INSTRUCTIONS
 
-1. **Detect review intent from invocation text.** Check the triggering prompt for phrases that map to a review mode:
-   - "staged" / "staged changes" → Staged changes only
-   - "uncommitted" / "working tree" / "all changes" → Uncommitted changes (staged + unstaged)
-   - "branch diff" / "vs main" / "against main" / "compared to {branch}" → Branch diff (extract base branch if mentioned)
-   - "commit range" / "last N commits" / "{sha}..{sha}" → Specific commit range
-   - "this diff" / "provided diff" / "paste" → User-provided diff (do not match bare "diff" — it appears in other modes)
-   - When multiple phrases match, prefer the most specific match (e.g., "branch diff" over bare "diff").
-   - **If a clear match is found:** Announce the detected mode (e.g., "Detected intent: review staged changes only") and proceed directly to constructing `{diff_output}` using the corresponding sub-case from instruction 3. Skip to instruction 4 (spec question).
-   - **If no match from invocation text, check sprint tracking.** Look for a sprint status file (`*sprint-status*`) in `{implementation_artifacts}` or `{planning_artifacts}`. If found, scan for any story with status `review`. Handle as follows:
-     - **Exactly one `review` story:** Set `{story_key}` to the story's key (e.g., `1-2-user-auth`). Suggest it: "I found story {{story-id}} in `review` status. Would you like to review its changes? [Y] Yes / [N] No, let me choose". If confirmed, use the story context to determine the diff source (branch name derived from story slug, or uncommitted changes). If declined, clear `{story_key}` and fall through to instruction 2.
-     - **Multiple `review` stories:** Present them as numbered options alongside a manual choice option. Wait for user selection. If the user selects a story, set `{story_key}` to the selected story's key and use the selected story's context to determine the diff source as in the single-story case above, and proceed to instruction 3. If the user selects the manual choice, clear `{story_key}` and fall through to instruction 2.
-   - **If no match and no sprint tracking:** Fall through to instruction 2.
+1. **Find the review target.** The conversation context before this skill was triggered IS your starting point — not a blank slate. Check in this order — stop as soon as the review target is identified:
+
+   **Tier 1 — Explicit argument.**
+   Did the user pass a PR, commit SHA, branch, spec file, or diff source this message?
+   - PR reference → resolve to branch/commit via `gh pr view`. If resolution fails, ask for a SHA or branch.
+   - Commit or branch → use directly.
+   - Spec file → set `{spec_file}` to the provided path. Check its frontmatter for `baseline_commit`. If found, use as diff baseline. If not found, continue the cascade (a spec alone does not identify a diff source).
+   - Also scan the argument for diff-mode keywords that narrow the scope:
+     - "staged" / "staged changes" → Staged changes only
+     - "uncommitted" / "working tree" / "all changes" → Uncommitted changes (staged + unstaged)
+     - "branch diff" / "vs main" / "against main" / "compared to <branch>" → Branch diff (extract base branch if mentioned)
+     - "commit range" / "last N commits" / "<from-sha>..<to-sha>" → Specific commit range
+     - "this diff" / "provided diff" / "paste" → User-provided diff (do not match bare "diff" — it appears in other modes)
+   - When multiple keywords match, prefer the most specific (e.g., "branch diff" over bare "diff").
+
+   **Tier 2 — Recent conversation.**
+   Do the last few messages reveal what the user wants to be reviewed? Look for spec paths, commit refs, branches, PRs, or descriptions of a change. Apply the same diff-mode keyword scan and routing as Tier 1.
+
+   **Tier 3 — Sprint tracking.**
+   Look for a sprint status file (`*sprint-status*`) in `{implementation_artifacts}` or `{planning_artifacts}`. If found, scan for stories with status `review`:
+   - **Exactly one `review` story:** Set `{story_key}` to the story's key (e.g., `1-2-user-auth`). Suggest it: "I found story <story-id> in `review` status. Would you like to review its changes? [Y] Yes / [N] No, let me choose". If confirmed, use the story context to determine the diff source (branch name derived from story slug, or uncommitted changes). If declined, clear `{story_key}` and fall through.
+   - **Multiple `review` stories:** Present them as numbered options alongside a manual choice option. Wait for user selection. If a story is selected, set `{story_key}` and use its context to determine the diff source. If manual choice is selected, clear `{story_key}` and fall through.
+   - **None:** Fall through.
+
+   **Tier 4 — Current git state.**
+   If version control is unavailable, skip to Tier 5. Otherwise, check the current branch and HEAD. If the branch is not `main` (or the default branch), confirm: "I see HEAD is `<short-sha>` on `<branch>` — do you want to review this branch's changes?" If confirmed, treat as a branch diff against `main`. If declined, fall through.
+
+   **Tier 5 — Ask.**
+   Fall through to instruction 2.
+
+   Never ask extra questions beyond what the cascade prescribes. If a tier above already identified the target, skip the remaining tiers and proceed to instruction 3 (construct diff).
 
 2. HALT. Ask the user: **What do you want to review?** Present these options:
    - **Uncommitted changes** (staged + unstaged)
@@ -36,15 +55,19 @@ story_key: '' # set at runtime when discovered from sprint status
    - **Provided diff or file list** (user pastes or provides a path)
 
 3. Construct `{diff_output}` from the chosen source.
+   - For **staged changes only**: run `git diff --cached`.
+   - For **uncommitted changes** (staged + unstaged): run `git diff HEAD`.
    - For **branch diff**: verify the base branch exists before running `git diff`. If it does not exist, HALT and ask the user for a valid branch.
    - For **commit range**: verify the range resolves. If it does not, HALT and ask the user for a valid range.
    - For **provided diff**: validate the content is non-empty and parseable as a unified diff. If it is not parseable, HALT and ask the user to provide a valid diff.
    - For **file list**: validate each path exists in the working tree. Construct `{diff_output}` by running `git diff HEAD -- <path1> <path2> ...`. If any paths are untracked (new files not yet staged), use `git diff --no-index /dev/null <path>` to include them. If the diff is empty (files have no uncommitted changes and are not untracked), ask the user whether to review the full file contents or to specify a different baseline.
    - After constructing `{diff_output}`, verify it is non-empty regardless of source type. If empty, HALT and tell the user there is nothing to review.
 
-4. Ask the user: **Is there a spec or story file that provides context for these changes?**
-   - If yes: set `{spec_file}` to the path provided, verify the file exists and is readable, then set `{review_mode}` = `"full"`.
-   - If no: set `{review_mode}` = `"no-spec"`.
+4. **Set the spec context.**
+   - If `{spec_file}` is already set (from Tier 1 or Tier 2): verify the file exists and is readable, then set `{review_mode}` = `"full"`.
+   - Otherwise, ask the user: **Is there a spec or story file that provides context for these changes?**
+     - If yes: set `{spec_file}` to the path provided, verify the file exists and is readable, then set `{review_mode}` = `"full"`.
+     - If no: set `{review_mode}` = `"no-spec"`.
 
 5. If `{review_mode}` = `"full"` and the file at `{spec_file}` has a `context` field in its frontmatter listing additional docs, load each referenced document. Warn the user about any docs that cannot be found.
 

src/bmm-skills/4-implementation/bmad-correct-course/checklist.md

@@ -217,8 +217,8 @@
 <check-item id="5.5">
 <prompt>Establish agent handoff plan</prompt>
 <action>Identify which roles/agents will execute the changes:</action>
-  - Development team (for implementation)
-  - Product Owner / Scrum Master (for backlog changes)
+  - Developer agent (for implementation)
+  - Product Owner / Developer (for backlog changes)
   - Product Manager / Architect (for strategic changes)
 <action>Define responsibilities for each role</action>
 <status>[ ] Done / [ ] N/A / [ ] Action-needed</status>

src/bmm-skills/4-implementation/bmad-correct-course/workflow.md

@@ -2,7 +2,7 @@
 
 **Goal:** Manage significant changes during sprint execution by analyzing impact across all project artifacts and producing a structured Sprint Change Proposal.
 
-**Your Role:** You are a Scrum Master navigating change management. Analyze the triggering issue, assess impact across PRD, epics, architecture, and UX artifacts, and produce an actionable Sprint Change Proposal with clear handoff.
+**Your Role:** You are a Developer navigating change management. Analyze the triggering issue, assess impact across PRD, epics, architecture, and UX artifacts, and produce an actionable Sprint Change Proposal with clear handoff.
 
 ---
 
@@ -192,8 +192,8 @@ Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
 <action>Section 5: Implementation Handoff</action>
 
 - Categorize change scope:
-  - Minor: Direct implementation by dev team
-  - Moderate: Backlog reorganization needed (PO/SM)
+  - Minor: Direct implementation by Developer agent
+  - Moderate: Backlog reorganization needed (PO/DEV)
   - Major: Fundamental replan required (PM/Architect)
 - Specify handoff recipients and their responsibilities
 - Define success criteria for implementation
@@ -219,8 +219,8 @@ Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
   <action>Finalize Sprint Change Proposal document</action>
   <action>Determine change scope classification:</action>
 
-- **Minor**: Can be implemented directly by development team
-- **Moderate**: Requires backlog reorganization and PO/SM coordination
+- **Minor**: Can be implemented directly by Developer agent
+- **Moderate**: Requires backlog reorganization and PO/DEV coordination
 - **Major**: Needs fundamental replan with PM/Architect involvement
 
 <action>Provide appropriate handoff based on scope:</action>
@@ -228,12 +228,12 @@ Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
 </check>
 
 <check if="Minor scope">
-  <action>Route to: Development team for direct implementation</action>
+  <action>Route to: Developer agent for direct implementation</action>
   <action>Deliverables: Finalized edit proposals and implementation tasks</action>
 </check>
 
 <check if="Moderate scope">
-  <action>Route to: Product Owner / Scrum Master agents</action>
+  <action>Route to: Product Owner / Developer agents</action>
   <action>Deliverables: Sprint Change Proposal + backlog reorganization plan</action>
 </check>
 
@@ -261,7 +261,7 @@ Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
 - Implementation handoff plan
 
 <action>Report workflow completion to user with personalized message: "Correct Course workflow complete, {user_name}!"</action>
-<action>Remind user of success criteria and next steps for implementation team</action>
+<action>Remind user of success criteria and next steps for Developer agent</action>
 </step>
 
 </workflow>

src/bmm-skills/4-implementation/bmad-quick-dev/spec-template.md

@@ -3,7 +3,7 @@ title: '{title}'
 type: 'feature' # feature | bugfix | refactor | chore
 created: '{date}'
 status: 'draft' # draft | ready-for-dev | in-progress | in-review | done
-context: [] # optional: max 3 project-wide standards/docs. NO source code files.
+context: [] # optional: `{project-root}/`-prefixed paths to project-wide standards/docs the implementation agent should load. Keep short — only what isn't already distilled into the spec body.
 ---
 
 <!-- Target: 900–1300 tokens. Above 1600 = high risk of context rot.

src/bmm-skills/4-implementation/bmad-quick-dev/step-01-clarify-and-route.md

@@ -42,6 +42,19 @@ Never ask extra questions if you already understand what the user intends.
 1. Load context.
    - List files in `{planning_artifacts}` and `{implementation_artifacts}`.
    - If you find an unformatted spec or intent file, ingest its contents to form your understanding of the intent.
+   - Planning artifacts are the output of BMAD phases 1-3. Typical files include:
+     - **PRD** (`*prd*`) — product requirements and success criteria
+     - **Architecture** (`*architecture*`) — technical design decisions and constraints
+     - **UX/Design** (`*ux*`) — user experience and interaction design
+     - **Epics** (`*epic*`) — feature breakdown into implementable stories
+     - **Product Brief** (`*brief*`) — project vision and scope
+   - Scan the listing for files matching these patterns. If any look relevant to the current intent, load them selectively — you don't need all of them, but you need the right constraints and requirements rather than guessing from code alone.
+   - **Previous story continuity.** Using the intent and loaded context (especially any epics file), infer whether the current work is a story from an epic. Do not rely on filename patterns or regex — reason about the intent, the artifact listing, and epics content together. If the intent is an epic story:
+     1. Identify the epic and story number.
+     2. Scan `{implementation_artifacts}` for specs from the same epic with `status: done` and a lower story number.
+     3. Load the most recent one (highest story number below current).
+     4. Extract its **Code Map**, **Design Notes**, **Spec Change Log**, and **task list** as continuity context for step-02 planning.
+     If no `done` spec is found but an `in-review` spec exists for the same epic with a lower story number, note it to the user and ask whether to load it. If the intent is not an epic story, or no previous spec exists, skip this silently.
 2. Clarify intent. Do not fantasize, do not leave open questions. If you must ask questions, ask them as a numbered list. When the human replies, verify that every single numbered question was answered. If any were ignored, HALT and re-ask only the missing questions before proceeding. Keep looping until intent is clear enough to implement.
 3. Version control sanity check. Is the working tree clean? Does the current branch make sense for this intent — considering its name and recent history? If the tree is dirty or the branch is an obvious mismatch, HALT and ask the human before proceeding. If version control is unavailable, skip this check.
 4. Multi-goal check (see SCOPE STANDARD). If the intent fails the single-goal criteria:

src/bmm-skills/4-implementation/bmad-quick-dev/step-03-implement.md

@@ -24,6 +24,8 @@ Capture `baseline_commit` (current HEAD, or `NO_VCS` if version control is unava
 
 Change `{spec_file}` status to `in-progress` in the frontmatter before starting implementation.
 
+If `{spec_file}` has a non-empty `context:` list in its frontmatter, load those files before implementation begins. When handing to a sub-agent, include them in the sub-agent prompt so it has access to the referenced context.
+
 Hand `{spec_file}` to a sub-agent/task and let it implement. If no sub-agents are available, implement directly.
 
 **Path formatting rule:** Any markdown links written into `{spec_file}` must use paths relative to `{spec_file}`'s directory so they are clickable in VS Code. Any file paths displayed in terminal/conversation output must use CWD-relative format with `:line` notation (e.g., `src/path/file.ts:42`) for terminal clickability. No leading `/` in either case.

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

@@ -2,7 +2,7 @@
 
 **Goal:** Post-epic review to extract lessons and assess success.
 
-**Your Role:** Scrum Master facilitating retrospective.
+**Your Role:** Developer facilitating retrospective.
 - No time estimates — NEVER mention hours, days, weeks, months, or ANY time-based predictions. AI has fundamentally changed development speed.
 - Communicate all responses in {communication_language} and language MUST be tailored to {user_skill_level}
 - Generate all documents in {document_output_language}
@@ -15,7 +15,7 @@
   - Two-part format: (1) Epic Review + (2) Next Epic Preparation
 - Party mode protocol:
   - ALL agent dialogue MUST use format: "Name (Role): dialogue"
-  - Example: Bob (Scrum Master): "Let's begin..."
+  - Example: Amelia (Developer): "Let's begin..."
   - Example: {user_name} (Project Lead): [User responds]
   - Create natural back-and-forth with user actively participating
   - Show disagreements, diverse perspectives, authentic team dynamics
@@ -69,7 +69,7 @@ Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
 <action>Explain to {user_name} the epic discovery process using natural dialogue</action>
 
 <output>
-Bob (Scrum Master): "Welcome to the retrospective, {user_name}. Let me help you identify which epic we just completed. I'll check sprint-status first, but you're the ultimate authority on what we're reviewing today."
+Amelia (Developer): "Welcome to the retrospective, {user_name}. Let me help you identify which epic we just completed. I'll check sprint-status first, but you're the ultimate authority on what we're reviewing today."
 </output>
 
 <action>PRIORITY 1: Check {sprint_status_file} first</action>
@@ -84,7 +84,7 @@ Bob (Scrum Master): "Welcome to the retrospective, {user_name}. Let me help you
   <action>Present finding to user with context</action>
 
   <output>
-Bob (Scrum Master): "Based on {sprint_status_file}, it looks like Epic {{detected_epic}} was recently completed. Is that the epic you want to review today, {user_name}?"
+Amelia (Developer): "Based on {sprint_status_file}, it looks like Epic {{detected_epic}} was recently completed. Is that the epic you want to review today, {user_name}?"
   </output>
 
 <action>WAIT for {user_name} to confirm or correct</action>
@@ -96,7 +96,7 @@ Bob (Scrum Master): "Based on {sprint_status_file}, it looks like Epic {{detecte
   <check if="{user_name} provides different epic number">
     <action>Set {{epic_number}} = user-provided number</action>
     <output>
-Bob (Scrum Master): "Got it, we're reviewing Epic {{epic_number}}. Let me gather that information."
+Amelia (Developer): "Got it, we're reviewing Epic {{epic_number}}. Let me gather that information."
     </output>
   </check>
 </check>
@@ -105,7 +105,7 @@ Bob (Scrum Master): "Got it, we're reviewing Epic {{epic_number}}. Let me gather
   <action>PRIORITY 2: Ask user directly</action>
 
   <output>
-Bob (Scrum Master): "I'm having trouble detecting the completed epic from {sprint_status_file}. {user_name}, which epic number did you just complete?"
+Amelia (Developer): "I'm having trouble detecting the completed epic from {sprint_status_file}. {user_name}, which epic number did you just complete?"
   </output>
 
 <action>WAIT for {user_name} to provide epic number</action>
@@ -120,7 +120,7 @@ Bob (Scrum Master): "I'm having trouble detecting the completed epic from {sprin
 <action>Set {{detected_epic}} = highest epic number found</action>
 
   <output>
-Bob (Scrum Master): "I found stories for Epic {{detected_epic}} in the stories folder. Is that the epic we're reviewing, {user_name}?"
+Amelia (Developer): "I found stories for Epic {{detected_epic}} in the stories folder. Is that the epic we're reviewing, {user_name}?"
   </output>
 
 <action>WAIT for {user_name} to confirm or correct</action>
@@ -143,9 +143,9 @@ Bob (Scrum Master): "I found stories for Epic {{detected_epic}} in the stories f
 
 <check if="epic is not complete">
   <output>
-Alice (Product Owner): "Wait, Bob - I'm seeing that Epic {{epic_number}} isn't actually complete yet."
+Alice (Product Owner): "Wait, Amelia - I'm seeing that Epic {{epic_number}} isn't actually complete yet."
 
-Bob (Scrum Master): "Let me check... you're right, Alice."
+Amelia (Developer): "Let me check... you're right, Alice."
 
 **Epic Status:**
 
@@ -156,7 +156,7 @@ Bob (Scrum Master): "Let me check... you're right, Alice."
 **Pending Stories:**
 {{pending_story_list}}
 
-Bob (Scrum Master): "{user_name}, we typically run retrospectives after all stories are done. What would you like to do?"
+Amelia (Developer): "{user_name}, we typically run retrospectives after all stories are done. What would you like to do?"
 
 **Options:**
 
@@ -169,7 +169,7 @@ Bob (Scrum Master): "{user_name}, we typically run retrospectives after all stor
 
   <check if="user says no">
     <output>
-Bob (Scrum Master): "Smart call, {user_name}. Let's finish those stories first and then have a proper retrospective."
+Amelia (Developer): "Smart call, {user_name}. Let's finish those stories first and then have a proper retrospective."
     </output>
     <action>HALT</action>
   </check>
@@ -178,7 +178,7 @@ Bob (Scrum Master): "Smart call, {user_name}. Let's finish those stories first a
 <output>
 Charlie (Senior Dev): "Just so everyone knows, this partial retro might miss some important lessons from those pending stories."
 
-Bob (Scrum Master): "Good point, Charlie. {user_name}, we'll document what we can now, but we may want to revisit after everything's done."
+Amelia (Developer): "Good point, Charlie. {user_name}, we'll document what we can now, but we may want to revisit after everything's done."
 </output>
 </check>
 
@@ -186,7 +186,7 @@ Bob (Scrum Master): "Good point, Charlie. {user_name}, we'll document what we ca
   <output>
 Alice (Product Owner): "Excellent! All {{done_stories}} stories are marked done."
 
-Bob (Scrum Master): "Perfect. Epic {{epic_number}} is complete and ready for retrospective, {user_name}."
+Amelia (Developer): "Perfect. Epic {{epic_number}} is complete and ready for retrospective, {user_name}."
 </output>
 </check>
 
@@ -200,7 +200,7 @@ Bob (Scrum Master): "Perfect. Epic {{epic_number}} is complete and ready for ret
 <step n="2" goal="Deep Story Analysis - Extract Lessons from Implementation">
 
 <output>
-Bob (Scrum Master): "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."
+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."
 
 Charlie (Senior Dev): "Good idea - those dev notes always have gold in them."
 </output>
@@ -219,7 +219,7 @@ Charlie (Senior Dev): "Good idea - those dev notes always have gold in them."
 
 **Review Feedback Patterns:**
 
-- Look for "## Review", "## Code Review", "## SM Review", "## Scrum Master Review" sections
+- Look for "## Review", "## Code Review", "## Dev Review" sections
 - Identify recurring feedback themes across stories
 - Note which types of issues came up repeatedly
 - Track quality concerns or architectural misalignments
@@ -282,11 +282,11 @@ Charlie (Senior Dev): "Good idea - those dev notes always have gold in them."
 <action>Store this synthesis - these patterns will drive the retrospective discussion</action>
 
 <output>
-Bob (Scrum Master): "Okay, I've reviewed all {{total_stories}} story records. I found some really interesting patterns we should discuss."
+Amelia (Developer): "Okay, I've reviewed all {{total_stories}} story records. I found some really interesting patterns we should discuss."
 
-Dana (QA Engineer): "I'm curious what you found, Bob. I noticed some things in my testing too."
+Dana (QA Engineer): "I'm curious what you found, Amelia. I noticed some things in my testing too."
 
-Bob (Scrum Master): "We'll get to all of it. But first, let me load the previous epic's retro to see if we learned from last time."
+Amelia (Developer): "We'll get to all of it. But first, let me load the previous epic's retro to see if we learned from last time."
 </output>
 
 </step>
@@ -300,7 +300,7 @@ Bob (Scrum Master): "We'll get to all of it. But first, let me load the previous
 
   <check if="previous retrospectives found">
     <output>
-Bob (Scrum Master): "I found our retrospectives from Epic {{prev_epic_num}}. Let me see what we committed to back then..."
+Amelia (Developer): "I found our retrospectives from Epic {{prev_epic_num}}. Let me see what we committed to back then..."
     </output>
 
     <action>Read the previous retrospectives</action>
@@ -349,26 +349,26 @@ Bob (Scrum Master): "I found our retrospectives from Epic {{prev_epic_num}}. Let
 
     <output>
 
-Bob (Scrum Master): "Interesting... in Epic {{prev_epic_num}}'s retro, we committed to {{action_count}} action items."
+Amelia (Developer): "Interesting... in Epic {{prev_epic_num}}'s retro, we committed to {{action_count}} action items."
 
-Alice (Product Owner): "How'd we do on those, Bob?"
+Alice (Product Owner): "How'd we do on those, Amelia?"
 
-Bob (Scrum Master): "We completed {{completed_count}}, made progress on {{in_progress_count}}, but didn't address {{not_addressed_count}}."
+Amelia (Developer): "We completed {{completed_count}}, made progress on {{in_progress_count}}, but didn't address {{not_addressed_count}}."
 
 Charlie (Senior Dev): _looking concerned_ "Which ones didn't we address?"
 
-Bob (Scrum Master): "We'll discuss that in the retro. Some of them might explain challenges we had this epic."
+Amelia (Developer): "We'll discuss that in the retro. Some of them might explain challenges we had this epic."
 
 Elena (Junior Dev): "That's... actually pretty insightful."
 
-Bob (Scrum Master): "That's why we track this stuff. Pattern recognition helps us improve."
+Amelia (Developer): "That's why we track this stuff. Pattern recognition helps us improve."
 </output>
 
   </check>
 
   <check if="no previous retro found">
     <output>
-Bob (Scrum Master): "I don't see a retrospective for Epic {{prev_epic_num}}. Either we skipped it, or this is your first retro."
+Amelia (Developer): "I don't see a retrospective for Epic {{prev_epic_num}}. Either we skipped it, or this is your first retro."
 
 Alice (Product Owner): "Probably our first one. Good time to start the habit!"
 </output>
@@ -378,7 +378,7 @@ Alice (Product Owner): "Probably our first one. Good time to start the habit!"
 
 <check if="{{prev_epic_num}} < 1">
   <output>
-Bob (Scrum Master): "This is Epic 1, so naturally there's no previous retro to reference. We're starting fresh!"
+Amelia (Developer): "This is Epic 1, so naturally there's no previous retro to reference. We're starting fresh!"
 
 Charlie (Senior Dev): "First epic, first retro. Let's make it count."
 </output>
@@ -392,7 +392,7 @@ Charlie (Senior Dev): "First epic, first retro. Let's make it count."
 <action>Calculate next epic number: {{next_epic_num}} = {{epic_number}} + 1</action>
 
 <output>
-Bob (Scrum Master): "Before we dive into the discussion, let me take a quick look at Epic {{next_epic_num}} to understand what's coming."
+Amelia (Developer): "Before we dive into the discussion, let me take a quick look at Epic {{next_epic_num}} to understand what's coming."
 
 Alice (Product Owner): "Good thinking - helps us connect what we learned to what we're about to do."
 </output>
@@ -448,15 +448,15 @@ Alice (Product Owner): "Good thinking - helps us connect what we learned to what
 - Deployment or environment setup
 
   <output>
-Bob (Scrum Master): "Alright, I've reviewed Epic {{next_epic_num}}: '{{next_epic_title}}'"
+Amelia (Developer): "Alright, I've reviewed Epic {{next_epic_num}}: '{{next_epic_title}}'"
 
 Alice (Product Owner): "What are we looking at?"
 
-Bob (Scrum Master): "{{next_epic_num}} stories planned, building on the {{dependency_description}} from Epic {{epic_number}}."
+Amelia (Developer): "{{next_epic_num}} stories planned, building on the {{dependency_description}} from Epic {{epic_number}}."
 
 Charlie (Senior Dev): "Dependencies concern me. Did we finish everything we need for that?"
 
-Bob (Scrum Master): "Good question - that's exactly what we need to explore in this retro."
+Amelia (Developer): "Good question - that's exactly what we need to explore in this retro."
 </output>
 
 <action>Set {{next_epic_exists}} = true</action>
@@ -464,11 +464,11 @@ Bob (Scrum Master): "Good question - that's exactly what we need to explore in t
 
 <check if="next epic NOT found">
   <output>
-Bob (Scrum Master): "Hmm, I don't see Epic {{next_epic_num}} defined yet."
+Amelia (Developer): "Hmm, I don't see Epic {{next_epic_num}} defined yet."
 
 Alice (Product Owner): "We might be at the end of the roadmap, or we haven't planned that far ahead yet."
 
-Bob (Scrum Master): "No problem. We'll still do a thorough retro on Epic {{epic_number}}. The lessons will be valuable whenever we plan the next work."
+Amelia (Developer): "No problem. We'll still do a thorough retro on Epic {{epic_number}}. The lessons will be valuable whenever we plan the next work."
 </output>
 
 <action>Set {{next_epic_exists}} = false</action>
@@ -480,16 +480,16 @@ Bob (Scrum Master): "No problem. We'll still do a thorough retro on Epic {{epic_
 
 <action>Load agent configurations from {agent_manifest}</action>
 <action>Identify which agents participated in Epic {{epic_number}} based on story records</action>
-<action>Ensure key roles present: Product Owner, Scrum Master (facilitating), Devs, Testing/QA, Architect</action>
+<action>Ensure key roles present: Product Owner, Developer (facilitating), Testing/QA, Architect</action>
 
 <output>
-Bob (Scrum Master): "Alright team, everyone's here. Let me set the stage for our retrospective."
+Amelia (Developer): "Alright team, everyone's here. Let me set the stage for our retrospective."
 
 ═══════════════════════════════════════════════════════════
 🔄 TEAM RETROSPECTIVE - Epic {{epic_number}}: {{epic_title}}
 ═══════════════════════════════════════════════════════════
 
-Bob (Scrum Master): "Here's what we accomplished together."
+Amelia (Developer): "Here's what we accomplished together."
 
 **EPIC {{epic_number}} SUMMARY:**
 
@@ -533,7 +533,7 @@ Preparation Needed:
 Technical Prerequisites:
 {{list_technical_prereqs}}
 
-Bob (Scrum Master): "And here's what's coming next. Epic {{next_epic_num}} builds on what we just finished."
+Amelia (Developer): "And here's what's coming next. Epic {{next_epic_num}} builds on what we just finished."
 
 Elena (Junior Dev): "Wow, that's a lot of dependencies on our work."
 
@@ -542,24 +542,24 @@ Charlie (Senior Dev): "Which means we better make sure Epic {{epic_number}} is a
 
 ═══════════════════════════════════════════════════════════
 
-Bob (Scrum Master): "Team assembled for this retrospective:"
+Amelia (Developer): "Team assembled for this retrospective:"
 
 {{list_participating_agents}}
 
-Bob (Scrum Master): "{user_name}, you're joining us as Project Lead. Your perspective is crucial here."
+Amelia (Developer): "{user_name}, you're joining us as Project Lead. Your perspective is crucial here."
 
 {user_name} (Project Lead): [Participating in the retrospective]
 
-Bob (Scrum Master): "Our focus today:"
+Amelia (Developer): "Our focus today:"
 
 1. Learning from Epic {{epic_number}} execution
    {{#if next_epic_exists}}2. Preparing for Epic {{next_epic_num}} success{{/if}}
 
-Bob (Scrum Master): "Ground rules: psychological safety first. No blame, no judgment. We focus on systems and processes, not individuals. Everyone's voice matters. Specific examples are better than generalizations."
+Amelia (Developer): "Ground rules: psychological safety first. No blame, no judgment. We focus on systems and processes, not individuals. Everyone's voice matters. Specific examples are better than generalizations."
 
 Alice (Product Owner): "And everything shared here stays in this room - unless we decide together to escalate something."
 
-Bob (Scrum Master): "Exactly. {user_name}, any questions before we dive in?"
+Amelia (Developer): "Exactly. {user_name}, any questions before we dive in?"
 </output>
 
 <action>WAIT for {user_name} to respond or indicate readiness</action>
@@ -569,25 +569,25 @@ Bob (Scrum Master): "Exactly. {user_name}, any questions before we dive in?"
 <step n="6" goal="Epic Review Discussion - What Went Well, What Didn't">
 
 <output>
-Bob (Scrum Master): "Let's start with the good stuff. What went well in Epic {{epic_number}}?"
+Amelia (Developer): "Let's start with the good stuff. What went well in Epic {{epic_number}}?"
 
-Bob (Scrum Master): _pauses, creating space_
+Amelia (Developer): _pauses, creating space_
 
 Alice (Product Owner): "I'll start. The user authentication flow we delivered exceeded my expectations. The UX is smooth, and early user feedback has been really positive."
 
 Charlie (Senior Dev): "I'll add to that - the caching strategy we implemented in Story {{breakthrough_story_num}} was a game-changer. We cut API calls by 60% and it set the pattern for the rest of the epic."
 
-Dana (QA Engineer): "From my side, testing went smoother than usual. The dev team's documentation was way better this epic - actually usable test plans!"
+Dana (QA Engineer): "From my side, testing went smoother than usual. The Developer's documentation was way better this epic - actually usable test plans!"
 
 Elena (Junior Dev): _smiling_ "That's because Charlie made me document everything after Story 1's code review!"
 
 Charlie (Senior Dev): _laughing_ "Tough love pays off."
 </output>
 
-<action>Bob (Scrum Master) naturally turns to {user_name} to engage them in the discussion</action>
+<action>Amelia (Developer) naturally turns to {user_name} to engage them in the discussion</action>
 
 <output>
-Bob (Scrum Master): "{user_name}, what stood out to you as going well in this epic?"
+Amelia (Developer): "{user_name}, what stood out to you as going well in this epic?"
 </output>
 
 <action>WAIT for {user_name} to respond - this is a KEY USER INTERACTION moment</action>
@@ -605,9 +605,9 @@ Charlie (Senior Dev): [Builds on the discussion, perhaps adding technical detail
 <action>After covering successes, guide the transition to challenges with care</action>
 
 <output>
-Bob (Scrum Master): "Okay, we've celebrated some real wins. Now let's talk about challenges - where did we struggle? What slowed us down?"
+Amelia (Developer): "Okay, we've celebrated some real wins. Now let's talk about challenges - where did we struggle? What slowed us down?"
 
-Bob (Scrum Master): _creates safe space with tone and pacing_
+Amelia (Developer): _creates safe space with tone and pacing_
 
 Elena (Junior Dev): _hesitates_ "Well... I really struggled with the database migrations in Story {{difficult_story_num}}. The documentation wasn't clear, and I had to redo it three times. Lost almost a full sprint on that story alone."
 
@@ -617,11 +617,11 @@ Alice (Product Owner): _frustrated_ "That's not fair, Charlie. We only clarified
 
 Charlie (Senior Dev): _heat rising_ "We asked plenty of questions! You said the schema was finalized, then two days into development you wanted to add three new fields!"
 
-Bob (Scrum Master): _intervening calmly_ "Let's take a breath here. This is exactly the kind of thing we need to unpack."
+Amelia (Developer): _intervening calmly_ "Let's take a breath here. This is exactly the kind of thing we need to unpack."
 
-Bob (Scrum Master): "Elena, you spent almost a full sprint on Story {{difficult_story_num}}. Charlie, you're saying requirements changed. Alice, you feel the right questions weren't asked up front."
+Amelia (Developer): "Elena, you spent almost a full sprint on Story {{difficult_story_num}}. Charlie, you're saying requirements changed. Alice, you feel the right questions weren't asked up front."
 
-Bob (Scrum Master): "{user_name}, you have visibility across the whole project. What's your take on this situation?"
+Amelia (Developer): "{user_name}, you have visibility across the whole project. What's your take on this situation?"
 </output>
 
 <action>WAIT for {user_name} to respond and help facilitate the conflict resolution</action>
@@ -629,7 +629,7 @@ Bob (Scrum Master): "{user_name}, you have visibility across the whole project.
 <action>Use {user_name}'s response to guide the discussion toward systemic understanding rather than blame</action>
 
 <output>
-Bob (Scrum Master): [Synthesizes {user_name}'s input with what the team shared] "So it sounds like the core issue was {{root_cause_based_on_discussion}}, not any individual person's fault."
+Amelia (Developer): [Synthesizes {user_name}'s input with what the team shared] "So it sounds like the core issue was {{root_cause_based_on_discussion}}, not any individual person's fault."
 
 Elena (Junior Dev): "That makes sense. If we'd had {{preventive_measure}}, I probably could have avoided those redos."
 
@@ -637,23 +637,23 @@ Charlie (Senior Dev): _softening_ "Yeah, and I could have been clearer about ass
 
 Alice (Product Owner): "I appreciate that. I could've been more proactive about flagging the schema additions earlier, too."
 
-Bob (Scrum Master): "This is good. We're identifying systemic improvements, not assigning blame."
+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>
 
 <output>
-Bob (Scrum Master): "Speaking of patterns, I noticed something when reviewing all the story records..."
+Amelia (Developer): "Speaking of patterns, I noticed something when reviewing all the story records..."
 
-Bob (Scrum Master): "{{pattern_1_description}} - this showed up in {{pattern_1_count}} out of {{total_stories}} stories."
+Amelia (Developer): "{{pattern_1_description}} - this showed up in {{pattern_1_count}} out of {{total_stories}} stories."
 
 Dana (QA Engineer): "Oh wow, I didn't realize it was that widespread."
 
-Bob (Scrum Master): "Yeah. And there's more - {{pattern_2_description}} came up in almost every code review."
+Amelia (Developer): "Yeah. And there's more - {{pattern_2_description}} came up in almost every code review."
 
 Charlie (Senior Dev): "That's... actually embarrassing. We should've caught that pattern earlier."
 
-Bob (Scrum Master): "No shame, Charlie. Now we know, and we can improve. {user_name}, did you notice these patterns during the epic?"
+Amelia (Developer): "No shame, Charlie. Now we know, and we can improve. {user_name}, did you notice these patterns during the epic?"
 </output>
 
 <action>WAIT for {user_name} to share their observations</action>
@@ -669,21 +669,21 @@ Bob (Scrum Master): "No shame, Charlie. Now we know, and we can improve. {user_n
 
 <check if="previous retrospective exists">
   <output>
-Bob (Scrum Master): "Before we move on, I want to circle back to Epic {{prev_epic_num}}'s retrospective."
+Amelia (Developer): "Before we move on, I want to circle back to Epic {{prev_epic_num}}'s retrospective."
 
-Bob (Scrum Master): "We made some commitments in that retro. Let's see how we did."
+Amelia (Developer): "We made some commitments in that retro. Let's see how we did."
 
-Bob (Scrum Master): "Action item 1: {{prev_action_1}}. Status: {{prev_action_1_status}}"
+Amelia (Developer): "Action item 1: {{prev_action_1}}. Status: {{prev_action_1_status}}"
 
 Alice (Product Owner): {{#if prev_action_1_status == "completed"}}"We nailed that one!"{{else}}"We... didn't do that one."{{/if}}
 
 Charlie (Senior Dev): {{#if prev_action_1_status == "completed"}}"And it helped! I noticed {{evidence_of_impact}}"{{else}}"Yeah, and I think that's why we had {{consequence_of_not_doing_it}} this epic."{{/if}}
 
-Bob (Scrum Master): "Action item 2: {{prev_action_2}}. Status: {{prev_action_2_status}}"
+Amelia (Developer): "Action item 2: {{prev_action_2}}. Status: {{prev_action_2_status}}"
 
 Dana (QA Engineer): {{#if prev_action_2_status == "completed"}}"This one made testing so much easier this time."{{else}}"If we'd done this, I think testing would've gone faster."{{/if}}
 
-Bob (Scrum Master): "{user_name}, looking at what we committed to last time and what we actually did - what's your reaction?"
+Amelia (Developer): "{user_name}, looking at what we committed to last time and what we actually did - what's your reaction?"
 </output>
 
 <action>WAIT for {user_name} to respond</action>
@@ -692,18 +692,18 @@ Bob (Scrum Master): "{user_name}, looking at what we committed to last time and
 </check>
 
 <output>
-Bob (Scrum Master): "Alright, we've covered a lot of ground. Let me summarize what I'm hearing..."
+Amelia (Developer): "Alright, we've covered a lot of ground. Let me summarize what I'm hearing..."
 
-Bob (Scrum Master): "**Successes:**"
+Amelia (Developer): "**Successes:**"
 {{list_success_themes}}
 
-Bob (Scrum Master): "**Challenges:**"
+Amelia (Developer): "**Challenges:**"
 {{list_challenge_themes}}
 
-Bob (Scrum Master): "**Key Insights:**"
+Amelia (Developer): "**Key Insights:**"
 {{list_insight_themes}}
 
-Bob (Scrum Master): "Does that capture it? Anyone have something important we missed?"
+Amelia (Developer): "Does that capture it? Anyone have something important we missed?"
 </output>
 
 <action>Allow team members to add any final thoughts on the epic review</action>
@@ -715,15 +715,15 @@ Bob (Scrum Master): "Does that capture it? Anyone have something important we mi
 
 <check if="{{next_epic_exists}} == false">
   <output>
-Bob (Scrum Master): "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."
+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>
 </check>
 
 <output>
-Bob (Scrum Master): "Now let's shift gears. Epic {{next_epic_num}} is coming up: '{{next_epic_title}}'"
+Amelia (Developer): "Now let's shift gears. Epic {{next_epic_num}} is coming up: '{{next_epic_title}}'"
 
-Bob (Scrum Master): "The question is: are we ready? What do we need to prepare?"
+Amelia (Developer): "The question is: are we ready? What do we need to prepare?"
 
 Alice (Product Owner): "From my perspective, we need to make sure {{dependency_concern_1}} from Epic {{epic_number}} is solid before we start building on it."
 
@@ -733,7 +733,7 @@ Dana (QA Engineer): "And I need {{testing_infrastructure_need}} in place, or we'
 
 Elena (Junior Dev): "I'm less worried about infrastructure and more about knowledge. I don't understand {{knowledge_gap}} well enough to work on Epic {{next_epic_num}}'s stories."
 
-Bob (Scrum Master): "{user_name}, the team is surfacing some real concerns here. What's your sense of our readiness?"
+Amelia (Developer): "{user_name}, the team is surfacing some real concerns here. What's your sense of our readiness?"
 </output>
 
 <action>WAIT for {user_name} to share their assessment</action>
@@ -755,13 +755,13 @@ Charlie (Senior Dev): "Exactly. We can't just jump into Epic {{next_epic_num}} o
 
 Alice (Product Owner): _frustrated_ "But we have stakeholder pressure to keep shipping features. They're not going to be happy about a 'prep sprint.'"
 
-Bob (Scrum Master): "Let's think about this differently. What happens if we DON'T do this prep work?"
+Amelia (Developer): "Let's think about this differently. What happens if we DON'T do this prep work?"
 
 Dana (QA Engineer): "We'll hit blockers in the middle of Epic {{next_epic_num}}, velocity will tank, and we'll ship late anyway."
 
 Charlie (Senior Dev): "Worse - we'll ship something built on top of {{technical_concern_1}}, and it'll be fragile."
 
-Bob (Scrum Master): "{user_name}, you're balancing stakeholder pressure against technical reality. How do you want to handle this?"
+Amelia (Developer): "{user_name}, you're balancing stakeholder pressure against technical reality. How do you want to handle this?"
 </output>
 
 <action>WAIT for {user_name} to provide direction on preparation approach</action>
@@ -773,9 +773,9 @@ Alice (Product Owner): [Potentially disagrees with {user_name}'s approach] "I he
 
 Charlie (Senior Dev): [Potentially supports or challenges Alice's point] "The business perspective is valid, but {{technical_counter_argument}}."
 
-Bob (Scrum Master): "We have healthy tension here between business needs and technical reality. That's good - it means we're being honest."
+Amelia (Developer): "We have healthy tension here between business needs and technical reality. That's good - it means we're being honest."
 
-Bob (Scrum Master): "Let's explore a middle ground. Charlie, which of your prep items are absolutely critical vs. nice-to-have?"
+Amelia (Developer): "Let's explore a middle ground. Charlie, which of your prep items are absolutely critical vs. nice-to-have?"
 
 Charlie (Senior Dev): "{{critical_prep_item_1}} and {{critical_prep_item_2}} are non-negotiable. {{nice_to_have_prep_item}} can wait."
 
@@ -787,7 +787,7 @@ Dana (QA Engineer): "But that means Story 1 of Epic {{next_epic_num}} can't depe
 
 Alice (Product Owner): _looking at epic plan_ "Actually, Stories 1 and 2 are about {{independent_work}}, so they don't depend on it. We could make that work."
 
-Bob (Scrum Master): "{user_name}, the team is finding a workable compromise here. Does this approach make sense to you?"
+Amelia (Developer): "{user_name}, the team is finding a workable compromise here. Does this approach make sense to you?"
 </output>
 
 <action>WAIT for {user_name} to validate or adjust the preparation strategy</action>
@@ -813,7 +813,7 @@ Bob (Scrum Master): "{user_name}, the team is finding a workable compromise here
 - Brings {user_name} in for key decisions
 
 <output>
-Bob (Scrum Master): "I'm hearing a clear picture of what we need before Epic {{next_epic_num}}. Let me summarize..."
+Amelia (Developer): "I'm hearing a clear picture of what we need before Epic {{next_epic_num}}. Let me summarize..."
 
 **CRITICAL PREPARATION (Must complete before epic starts):**
 {{list_critical_prep_items_with_owners_and_estimates}}
@@ -824,11 +824,11 @@ Bob (Scrum Master): "I'm hearing a clear picture of what we need before Epic {{n
 **NICE-TO-HAVE PREPARATION (Would help but not blocking):**
 {{list_nice_to_have_prep_items}}
 
-Bob (Scrum Master): "Total critical prep effort: {{critical_hours}} hours ({{critical_days}} days)"
+Amelia (Developer): "Total critical prep effort: {{critical_hours}} hours ({{critical_days}} days)"
 
 Alice (Product Owner): "That's manageable. We can communicate that to stakeholders."
 
-Bob (Scrum Master): "{user_name}, does this preparation plan work for you?"
+Amelia (Developer): "{user_name}, does this preparation plan work for you?"
 </output>
 
 <action>WAIT for {user_name} final validation of preparation plan</action>
@@ -838,9 +838,9 @@ Bob (Scrum Master): "{user_name}, does this preparation plan work for you?"
 <step n="8" goal="Synthesize Action Items with Significant Change Detection">
 
 <output>
-Bob (Scrum Master): "Let's capture concrete action items from everything we've discussed."
+Amelia (Developer): "Let's capture concrete action items from everything we've discussed."
 
-Bob (Scrum Master): "I want specific, achievable actions with clear owners. Not vague aspirations."
+Amelia (Developer): "I want specific, achievable actions with clear owners. Not vague aspirations."
 </output>
 
 <action>Synthesize themes from Epic {{epic_number}} review discussion into actionable improvements</action>
@@ -862,7 +862,7 @@ Bob (Scrum Master): "I want specific, achievable actions with clear owners. Not
 - Time-bound: Has clear deadline
 
 <output>
-Bob (Scrum Master): "Based on our discussion, here are the action items I'm proposing..."
+Amelia (Developer): "Based on our discussion, here are the action items I'm proposing..."
 
 ═══════════════════════════════════════════════════════════
 📝 EPIC {{epic_number}} ACTION ITEMS:
@@ -882,11 +882,11 @@ Bob (Scrum Master): "Based on our discussion, here are the action items I'm prop
 
 Charlie (Senior Dev): "I can own action item 1, but {{timeline_1}} is tight. Can we push it to {{alternative_timeline}}?"
 
-Bob (Scrum Master): "What do others think? Does that timing still work?"
+Amelia (Developer): "What do others think? Does that timing still work?"
 
 Alice (Product Owner): "{{alternative_timeline}} works for me, as long as it's done before Epic {{next_epic_num}} starts."
 
-Bob (Scrum Master): "Agreed. Updated to {{alternative_timeline}}."
+Amelia (Developer): "Agreed. Updated to {{alternative_timeline}}."
 
 **Technical Debt:**
 
@@ -904,7 +904,7 @@ Dana (QA Engineer): "For debt item 1, can we prioritize that as high? It caused
 
 Charlie (Senior Dev): "I marked it medium because {{reasoning}}, but I hear your point."
 
-Bob (Scrum Master): "{user_name}, this is a priority call. Testing impact vs. {{reasoning}} - how do you want to prioritize it?"
+Amelia (Developer): "{user_name}, this is a priority call. Testing impact vs. {{reasoning}} - how do you want to prioritize it?"
 </output>
 
 <action>WAIT for {user_name} to help resolve priority discussions</action>
@@ -925,7 +925,7 @@ Bob (Scrum Master): "{user_name}, this is a priority call. Testing impact vs. {{
 - {{agreement_2}}
 - {{agreement_3}}
 
-Bob (Scrum Master): "These agreements are how we're committing to work differently going forward."
+Amelia (Developer): "These agreements are how we're committing to work differently going forward."
 
 Elena (Junior Dev): "I like agreement 2 - that would've saved me on Story {{difficult_story_num}}."
 
@@ -991,9 +991,9 @@ Estimated: {{est_4}}
 🚨 SIGNIFICANT DISCOVERY ALERT 🚨
 ═══════════════════════════════════════════════════════════
 
-Bob (Scrum Master): "{user_name}, we need to flag something important."
+Amelia (Developer): "{user_name}, we need to flag something important."
 
-Bob (Scrum Master): "During Epic {{epic_number}}, the team uncovered findings that may require updating the plan for Epic {{next_epic_num}}."
+Amelia (Developer): "During Epic {{epic_number}}, the team uncovered findings that may require updating the plan for Epic {{next_epic_num}}."
 
 **Significant Changes Identified:**
 
@@ -1036,9 +1036,9 @@ This means Epic {{next_epic_num}} likely needs:
 4. Hold alignment session with Product Owner before starting Epic {{next_epic_num}}
    {{#if prd_update_needed}}5. Update PRD sections affected by new understanding{{/if}}
 
-Bob (Scrum Master): "**Epic Update Required**: YES - Schedule epic planning review session"
+Amelia (Developer): "**Epic Update Required**: YES - Schedule epic planning review session"
 
-Bob (Scrum Master): "{user_name}, this is significant. We need to address this before committing to Epic {{next_epic_num}}'s current plan. How do you want to handle it?"
+Amelia (Developer): "{user_name}, this is significant. We need to address this before committing to Epic {{next_epic_num}}'s current plan. How do you want to handle it?"
 </output>
 
 <action>WAIT for {user_name} to decide on how to handle the significant changes</action>
@@ -1050,24 +1050,24 @@ Alice (Product Owner): "I agree with {user_name}'s approach. Better to adjust th
 
 Charlie (Senior Dev): "This is why retrospectives matter. We caught this before it became a disaster."
 
-Bob (Scrum Master): "Adding to critical path: Epic {{next_epic_num}} planning review session before epic kickoff."
+Amelia (Developer): "Adding to critical path: Epic {{next_epic_num}} planning review session before epic kickoff."
 </output>
 </check>
 
 <check if="no significant discoveries">
   <output>
-Bob (Scrum Master): "Good news - nothing from Epic {{epic_number}} fundamentally changes our plan for Epic {{next_epic_num}}. The plan is still sound."
+Amelia (Developer): "Good news - nothing from Epic {{epic_number}} fundamentally changes our plan for Epic {{next_epic_num}}. The plan is still sound."
 
 Alice (Product Owner): "We learned a lot, but the direction is right."
 </output>
 </check>
 
 <output>
-Bob (Scrum Master): "Let me show you the complete action plan..."
+Amelia (Developer): "Let me show you the complete action plan..."
 
-Bob (Scrum Master): "That's {{total_action_count}} action items, {{prep_task_count}} preparation tasks, and {{critical_count}} critical path items."
+Amelia (Developer): "That's {{total_action_count}} action items, {{prep_task_count}} preparation tasks, and {{critical_count}} critical path items."
 
-Bob (Scrum Master): "Everyone clear on what they own?"
+Amelia (Developer): "Everyone clear on what they own?"
 </output>
 
 <action>Give each agent with assignments a moment to acknowledge their ownership</action>
@@ -1079,21 +1079,21 @@ Bob (Scrum Master): "Everyone clear on what they own?"
 <step n="9" goal="Critical Readiness Exploration - Interactive Deep Dive">
 
 <output>
-Bob (Scrum Master): "Before we close, I want to do a final readiness check."
+Amelia (Developer): "Before we close, I want to do a final readiness check."
 
-Bob (Scrum Master): "Epic {{epic_number}} is marked complete in sprint-status, but is it REALLY done?"
+Amelia (Developer): "Epic {{epic_number}} is marked complete in sprint-status, but is it REALLY done?"
 
-Alice (Product Owner): "What do you mean, Bob?"
+Alice (Product Owner): "What do you mean, Amelia?"
 
-Bob (Scrum Master): "I mean truly production-ready, stakeholders happy, no loose ends that'll bite us later."
+Amelia (Developer): "I mean truly production-ready, stakeholders happy, no loose ends that'll bite us later."
 
-Bob (Scrum Master): "{user_name}, let's walk through this together."
+Amelia (Developer): "{user_name}, let's walk through this together."
 </output>
 
 <action>Explore testing and quality state through natural conversation</action>
 
 <output>
-Bob (Scrum Master): "{user_name}, tell me about the testing for Epic {{epic_number}}. What verification has been done?"
+Amelia (Developer): "{user_name}, tell me about the testing for Epic {{epic_number}}. What verification has been done?"
 </output>
 
 <action>WAIT for {user_name} to describe testing status</action>
@@ -1103,18 +1103,18 @@ Dana (QA Engineer): [Responds to what {user_name} shared] "I can add to that - {
 
 Dana (QA Engineer): "But honestly, {{testing_concern_if_any}}."
 
-Bob (Scrum Master): "{user_name}, are you confident Epic {{epic_number}} is production-ready from a quality perspective?"
+Amelia (Developer): "{user_name}, are you confident Epic {{epic_number}} is production-ready from a quality perspective?"
 </output>
 
 <action>WAIT for {user_name} to assess quality readiness</action>
 
 <check if="{user_name} expresses concerns">
   <output>
-Bob (Scrum Master): "Okay, let's capture that. What specific testing is still needed?"
+Amelia (Developer): "Okay, let's capture that. What specific testing is still needed?"
 
 Dana (QA Engineer): "I can handle {{testing_work_needed}}, estimated {{testing_hours}} hours."
 
-Bob (Scrum Master): "Adding to critical path: Complete {{testing_work_needed}} before Epic {{next_epic_num}}."
+Amelia (Developer): "Adding to critical path: Complete {{testing_work_needed}} before Epic {{next_epic_num}}."
 </output>
 <action>Add testing completion to critical path</action>
 </check>
@@ -1122,7 +1122,7 @@ Bob (Scrum Master): "Adding to critical path: Complete {{testing_work_needed}} b
 <action>Explore deployment and release status</action>
 
 <output>
-Bob (Scrum Master): "{user_name}, what's the deployment status for Epic {{epic_number}}? Is it live in production, scheduled for deployment, or still pending?"
+Amelia (Developer): "{user_name}, what's the deployment status for Epic {{epic_number}}? Is it live in production, scheduled for deployment, or still pending?"
 </output>
 
 <action>WAIT for {user_name} to provide deployment status</action>
@@ -1131,7 +1131,7 @@ Bob (Scrum Master): "{user_name}, what's the deployment status for Epic {{epic_n
   <output>
 Charlie (Senior Dev): "If it's not deployed yet, we need to factor that into Epic {{next_epic_num}} timing."
 
-Bob (Scrum Master): "{user_name}, when is deployment planned? Does that timing work for starting Epic {{next_epic_num}}?"
+Amelia (Developer): "{user_name}, when is deployment planned? Does that timing work for starting Epic {{next_epic_num}}?"
 </output>
 
 <action>WAIT for {user_name} to clarify deployment timeline</action>
@@ -1142,11 +1142,11 @@ Bob (Scrum Master): "{user_name}, when is deployment planned? Does that timing w
 <action>Explore stakeholder acceptance</action>
 
 <output>
-Bob (Scrum Master): "{user_name}, have stakeholders seen and accepted the Epic {{epic_number}} deliverables?"
+Amelia (Developer): "{user_name}, have stakeholders seen and accepted the Epic {{epic_number}} deliverables?"
 
 Alice (Product Owner): "This is important - I've seen 'done' epics get rejected by stakeholders and force rework."
 
-Bob (Scrum Master): "{user_name}, any feedback from stakeholders still pending?"
+Amelia (Developer): "{user_name}, any feedback from stakeholders still pending?"
 </output>
 
 <action>WAIT for {user_name} to describe stakeholder acceptance status</action>
@@ -1155,7 +1155,7 @@ Bob (Scrum Master): "{user_name}, any feedback from stakeholders still pending?"
   <output>
 Alice (Product Owner): "We should get formal acceptance before moving on. Otherwise Epic {{next_epic_num}} might get interrupted by rework."
 
-Bob (Scrum Master): "{user_name}, how do you want to handle stakeholder acceptance? Should we make it a critical path item?"
+Amelia (Developer): "{user_name}, how do you want to handle stakeholder acceptance? Should we make it a critical path item?"
 </output>
 
 <action>WAIT for {user_name} decision</action>
@@ -1166,9 +1166,9 @@ Bob (Scrum Master): "{user_name}, how do you want to handle stakeholder acceptan
 <action>Explore technical health and stability</action>
 
 <output>
-Bob (Scrum Master): "{user_name}, this is a gut-check question: How does the codebase feel after Epic {{epic_number}}?"
+Amelia (Developer): "{user_name}, this is a gut-check question: How does the codebase feel after Epic {{epic_number}}?"
 
-Bob (Scrum Master): "Stable and maintainable? Or are there concerns lurking?"
+Amelia (Developer): "Stable and maintainable? Or are there concerns lurking?"
 
 Charlie (Senior Dev): "Be honest, {user_name}. We've all shipped epics that felt... fragile."
 </output>
@@ -1181,11 +1181,11 @@ Charlie (Senior Dev): "Okay, let's dig into that. What's causing those concerns?
 
 Charlie (Senior Dev): [Helps {user_name} articulate technical concerns]
 
-Bob (Scrum Master): "What would it take to address these concerns and feel confident about stability?"
+Amelia (Developer): "What would it take to address these concerns and feel confident about stability?"
 
 Charlie (Senior Dev): "I'd say we need {{stability_work_needed}}, roughly {{stability_hours}} hours."
 
-Bob (Scrum Master): "{user_name}, is addressing this stability work worth doing before Epic {{next_epic_num}}?"
+Amelia (Developer): "{user_name}, is addressing this stability work worth doing before Epic {{next_epic_num}}?"
 </output>
 
 <action>WAIT for {user_name} decision</action>
@@ -1196,26 +1196,26 @@ Bob (Scrum Master): "{user_name}, is addressing this stability work worth doing
 <action>Explore unresolved blockers</action>
 
 <output>
-Bob (Scrum Master): "{user_name}, are there any unresolved blockers or technical issues from Epic {{epic_number}} that we're carrying forward?"
+Amelia (Developer): "{user_name}, are there any unresolved blockers or technical issues from Epic {{epic_number}} that we're carrying forward?"
 
 Dana (QA Engineer): "Things that might create problems for Epic {{next_epic_num}} if we don't deal with them?"
 
-Bob (Scrum Master): "Nothing is off limits here. If there's a problem, we need to know."
+Amelia (Developer): "Nothing is off limits here. If there's a problem, we need to know."
 </output>
 
 <action>WAIT for {user_name} to surface any blockers</action>
 
 <check if="blockers identified">
   <output>
-Bob (Scrum Master): "Let's capture those blockers and figure out how they affect Epic {{next_epic_num}}."
+Amelia (Developer): "Let's capture those blockers and figure out how they affect Epic {{next_epic_num}}."
 
 Charlie (Senior Dev): "For {{blocker_1}}, if we leave it unresolved, it'll {{impact_description_1}}."
 
 Alice (Product Owner): "That sounds critical. We need to address that before moving forward."
 
-Bob (Scrum Master): "Agreed. Adding to critical path: Resolve {{blocker_1}} before Epic {{next_epic_num}} kickoff."
+Amelia (Developer): "Agreed. Adding to critical path: Resolve {{blocker_1}} before Epic {{next_epic_num}} kickoff."
 
-Bob (Scrum Master): "Who owns that work?"
+Amelia (Developer): "Who owns that work?"
 </output>
 
 <action>Assign blocker resolution to appropriate agent</action>
@@ -1225,7 +1225,7 @@ Bob (Scrum Master): "Who owns that work?"
 <action>Synthesize the readiness assessment</action>
 
 <output>
-Bob (Scrum Master): "Okay {user_name}, let me synthesize what we just uncovered..."
+Amelia (Developer): "Okay {user_name}, let me synthesize what we just uncovered..."
 
 **EPIC {{epic_number}} READINESS ASSESSMENT:**
 
@@ -1244,13 +1244,13 @@ Technical Health: {{stability_status}}
 Unresolved Blockers: {{blocker_status}}
 {{#if blockers_exist}}⚠️ Must resolve: {{blocker_list}}{{/if}}
 
-Bob (Scrum Master): "{user_name}, does this assessment match your understanding?"
+Amelia (Developer): "{user_name}, does this assessment match your understanding?"
 </output>
 
 <action>WAIT for {user_name} to confirm or correct the assessment</action>
 
 <output>
-Bob (Scrum Master): "Based on this assessment, Epic {{epic_number}} is {{#if all_clear}}fully complete and we're clear to proceed{{else}}complete from a story perspective, but we have {{critical_work_count}} critical items before Epic {{next_epic_num}}{{/if}}."
+Amelia (Developer): "Based on this assessment, Epic {{epic_number}} is {{#if all_clear}}fully complete and we're clear to proceed{{else}}complete from a story perspective, but we have {{critical_work_count}} critical items before Epic {{next_epic_num}}{{/if}}."
 
 Alice (Product Owner): "This level of thoroughness is why retrospectives are valuable."
 
@@ -1262,13 +1262,13 @@ Charlie (Senior Dev): "Better to catch this now than three stories into the next
 <step n="10" goal="Retrospective Closure with Celebration and Commitment">
 
 <output>
-Bob (Scrum Master): "We've covered a lot of ground today. Let me bring this retrospective to a close."
+Amelia (Developer): "We've covered a lot of ground today. Let me bring this retrospective to a close."
 
 ═══════════════════════════════════════════════════════════
 ✅ RETROSPECTIVE COMPLETE
 ═══════════════════════════════════════════════════════════
 
-Bob (Scrum Master): "Epic {{epic_number}}: {{epic_title}} - REVIEWED"
+Amelia (Developer): "Epic {{epic_number}}: {{epic_title}} - REVIEWED"
 
 **Key Takeaways:**
 
@@ -1281,7 +1281,7 @@ Alice (Product Owner): "That first takeaway is huge - {{impact_of_lesson_1}}."
 
 Charlie (Senior Dev): "And lesson 2 is something we can apply immediately."
 
-Bob (Scrum Master): "Commitments made today:"
+Amelia (Developer): "Commitments made today:"
 
 - Action Items: {{action_count}}
 - Preparation Tasks: {{prep_task_count}}
@@ -1289,7 +1289,7 @@ Bob (Scrum Master): "Commitments made today:"
 
 Dana (QA Engineer): "That's a lot of commitments. We need to actually follow through this time."
 
-Bob (Scrum Master): "Agreed. Which is why we'll review these action items in our next standup."
+Amelia (Developer): "Agreed. Which is why we'll review these action items in our next standup."
 
 ═══════════════════════════════════════════════════════════
 🎯 NEXT STEPS:
@@ -1306,9 +1306,9 @@ Alice (Product Owner): "I'll communicate the timeline to stakeholders. They'll u
 
 ═══════════════════════════════════════════════════════════
 
-Bob (Scrum Master): "Before we wrap, I want to take a moment to acknowledge the team."
+Amelia (Developer): "Before we wrap, I want to take a moment to acknowledge the team."
 
-Bob (Scrum Master): "Epic {{epic_number}} delivered {{completed_stories}} stories with {{velocity_description}} velocity. We overcame {{blocker_count}} blockers. We learned a lot. That's real work by real people."
+Amelia (Developer): "Epic {{epic_number}} delivered {{completed_stories}} stories with {{velocity_description}} velocity. We overcame {{blocker_count}} blockers. We learned a lot. That's real work by real people."
 
 Charlie (Senior Dev): "Hear, hear."
 
@@ -1316,17 +1316,17 @@ Alice (Product Owner): "I'm proud of what we shipped."
 
 Dana (QA Engineer): "And I'm excited about Epic {{next_epic_num}} - especially now that we're prepared for it."
 
-Bob (Scrum Master): "{user_name}, any final thoughts before we close?"
+Amelia (Developer): "{user_name}, any final thoughts before we close?"
 </output>
 
 <action>WAIT for {user_name} to share final reflections</action>
 
 <output>
-Bob (Scrum Master): [Acknowledges what {user_name} shared] "Thank you for that, {user_name}."
+Amelia (Developer): [Acknowledges what {user_name} shared] "Thank you for that, {user_name}."
 
-Bob (Scrum Master): "Alright team - great work today. We learned a lot from Epic {{epic_number}}. Let's use these insights to make Epic {{next_epic_num}} even better."
+Amelia (Developer): "Alright team - great work today. We learned a lot from Epic {{epic_number}}. Let's use these insights to make Epic {{next_epic_num}} even better."
 
-Bob (Scrum Master): "See you all when prep work is done. Meeting adjourned!"
+Amelia (Developer): "See you all when prep work is done. Meeting adjourned!"
 
 ═══════════════════════════════════════════════════════════
 </output>
@@ -1432,7 +1432,7 @@ Retrospective document was saved successfully, but {sprint_status_file} may need
   {{else}}
 
 4. **Begin Epic {{next_epic_num}} when ready**
-   - Start creating stories with SM agent's `create-story`
+   - Start creating stories with Developer agent's `create-story`
    - Epic will be marked as `in-progress` automatically when first story is created
    - Ensure all critical path items are done first
      {{/if}}
@@ -1446,7 +1446,7 @@ Epic {{epic_number}} delivered {{completed_stories}} stories with {{velocity_sum
 
 ---
 
-Bob (Scrum Master): "Great session today, {user_name}. The team did excellent work."
+Amelia (Developer): "Great session today, {user_name}. The team did excellent work."
 
 Alice (Product Owner): "See you at epic planning!"
 
@@ -1460,7 +1460,7 @@ Charlie (Senior Dev): "Time to knock out that prep work."
 
 <facilitation-guidelines>
 <guideline>PARTY MODE REQUIRED: All agent dialogue uses "Name (Role): dialogue" format</guideline>
-<guideline>Scrum Master maintains psychological safety throughout - no blame or judgment</guideline>
+<guideline>Amelia (Developer) maintains psychological safety throughout - no blame or judgment</guideline>
 <guideline>Focus on systems and processes, not individual performance</guideline>
 <guideline>Create authentic team dynamics: disagreements, diverse perspectives, emotions</guideline>
 <guideline>User ({user_name}) is active participant, not passive observer</guideline>

src/bmm-skills/4-implementation/bmad-sprint-planning/sprint-status-template.yaml

@@ -29,7 +29,7 @@
 # WORKFLOW NOTES:
 # ===============
 # - Mark epic as 'in-progress' when starting work on its first story
-# - SM typically creates next story ONLY after previous one is 'done' to incorporate learnings
+# - Developer typically creates next story ONLY after previous one is 'done' to incorporate learnings
 # - Dev moves story to 'review', then Dev runs code-review (fresh context, ideally different LLM)
 
 # EXAMPLE STRUCTURE (your actual epics/stories will replace these):

src/bmm-skills/4-implementation/bmad-sprint-planning/workflow.md

@@ -2,7 +2,7 @@
 
 **Goal:** Generate sprint status tracking from epics, detecting current story statuses and building a complete sprint-status.yaml file.
 
-**Your Role:** You are a Scrum Master generating and maintaining sprint tracking. Parse epic files, detect story statuses, and produce a structured sprint-status.yaml.
+**Your Role:** You are a Developer generating and maintaining sprint tracking. Parse epic files, detect story statuses, and produce a structured sprint-status.yaml.
 
 ---
 
@@ -162,7 +162,7 @@ development_status:
 # ===============
 # - Epic transitions to 'in-progress' automatically when first story is created
 # - Stories can be worked in parallel if team capacity allows
-# - SM typically creates next story after previous one is 'done' to incorporate learnings
+# - Developer typically creates next story after previous one is 'done' to incorporate learnings
 # - Dev moves story to 'review', then runs code-review (fresh context, different LLM recommended)
 
 generated: { date }
@@ -260,4 +260,4 @@ optional ↔ done
 2. **Sequential Default**: Stories are typically worked in order, but parallel work is supported
 3. **Parallel Work Supported**: Multiple stories can be `in-progress` if team capacity allows
 4. **Review Before Done**: Stories should pass through `review` before `done`
-5. **Learning Transfer**: SM typically creates next story after previous one is `done` to incorporate learnings
+5. **Learning Transfer**: Developer typically creates next story after previous one is `done` to incorporate learnings