refactor(catalog): rename after/before to preceded-by/followed-by (#2360)

* refactor(catalog): rename after/before columns to preceded-by/followed-by

The bare prepositions `after` and `before` had no subject anchor, leaving
the dependency direction ambiguous: "X has Y in its `after` column" reads
plausibly as either "Y comes after X" or "X comes after Y". An LLM
catalog consumer just got the direction wrong because of this.

`preceded-by` / `followed-by` are passive-voice participles whose grammar
locks the subject (the skill in this row) and forces a single reading:
"X is preceded by Y" can only mean Y comes first.

Rename applied to:
- module-help.csv headers (bmm-skills, core-skills)
- bmad-help SKILL.md schema doc + descriptions
- installer.js mergeModuleHelpCatalogs header string
- plugin-resolver.js _buildSynthesizedHelpCsv header string
- bmad-manifest.json keys (bmad-product-brief, bmad-prfaq)
- distillate-format-reference.md example manifest

The separate `required` column continues to carry hard-gate semantics;
the renamed columns are pure soft sequencing hints, as already documented
in bmad-help.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* style(installer): wrap long header strings per prettier

* feat(installer): warn on non-canonical module-help.csv headers

mergeModuleHelpCatalogs now compares each per-module file's header
against the canonical schema and emits a one-shot prompts.log.warn per
module on drift, naming both the expected and actual header. Data
continues to load positionally so external modules built against the
old after/before schema still install cleanly — the warning is the
maintainer signal to rename their columns.

Centralize the canonical header in modules/module-help-schema.js so the
merger and the synthesizer (PluginResolver._buildSynthesizedHelpCsv)
read the same source of truth; future column renames are one edit.

Verified by installing all four bmad-org external modules
(bmb, cis, gds, tea) — every one ships the legacy after/before header
today and now fires an advisory warning while still merging cleanly
into _bmad/_config/bmad-help.csv with the canonical column names.

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.claude-plugin/marketplace.json

@@ -0,0 +1,74 @@
+{
+  "name": "bmad-method",
+  "owner": {
+    "name": "Brian (BMad) Madison"
+  },
+  "description": "Breakthrough Method of Agile AI-driven Development — a full-lifecycle framework with agents and workflows for analysis, planning, architecture, and implementation.",
+  "license": "MIT",
+  "homepage": "https://github.com/bmad-code-org/BMAD-METHOD",
+  "repository": "https://github.com/bmad-code-org/BMAD-METHOD",
+  "keywords": ["bmad", "agile", "ai", "orchestrator", "development", "methodology", "agents"],
+  "plugins": [
+    {
+      "name": "bmad-pro-skills",
+      "source": "./",
+      "description": "Next level skills for power users — advanced prompting techniques, agent management, and more.",
+      "version": "6.6.0",
+      "author": {
+        "name": "Brian (BMad) Madison"
+      },
+      "skills": [
+        "./src/core-skills/bmad-help",
+        "./src/core-skills/bmad-brainstorming",
+        "./src/core-skills/bmad-distillator",
+        "./src/core-skills/bmad-party-mode",
+        "./src/core-skills/bmad-shard-doc",
+        "./src/core-skills/bmad-advanced-elicitation",
+        "./src/core-skills/bmad-editorial-review-prose",
+        "./src/core-skills/bmad-editorial-review-structure",
+        "./src/core-skills/bmad-index-docs",
+        "./src/core-skills/bmad-review-adversarial-general",
+        "./src/core-skills/bmad-review-edge-case-hunter"
+      ]
+    },
+    {
+      "name": "bmad-method-lifecycle",
+      "source": "./",
+      "description": "Full-lifecycle AI development framework — agents and workflows for product analysis, planning, architecture, and implementation.",
+      "version": "6.6.0",
+      "author": {
+        "name": "Brian (BMad) Madison"
+      },
+      "skills": [
+        "./src/bmm-skills/1-analysis/bmad-product-brief",
+        "./src/bmm-skills/1-analysis/bmad-agent-analyst",
+        "./src/bmm-skills/1-analysis/bmad-agent-tech-writer",
+        "./src/bmm-skills/1-analysis/bmad-document-project",
+        "./src/bmm-skills/1-analysis/research/bmad-domain-research",
+        "./src/bmm-skills/1-analysis/research/bmad-market-research",
+        "./src/bmm-skills/1-analysis/research/bmad-technical-research",
+        "./src/bmm-skills/2-plan-workflows/bmad-agent-pm",
+        "./src/bmm-skills/2-plan-workflows/bmad-agent-ux-designer",
+        "./src/bmm-skills/2-plan-workflows/bmad-create-prd",
+        "./src/bmm-skills/2-plan-workflows/bmad-edit-prd",
+        "./src/bmm-skills/2-plan-workflows/bmad-validate-prd",
+        "./src/bmm-skills/2-plan-workflows/bmad-create-ux-design",
+        "./src/bmm-skills/3-solutioning/bmad-agent-architect",
+        "./src/bmm-skills/3-solutioning/bmad-create-architecture",
+        "./src/bmm-skills/3-solutioning/bmad-check-implementation-readiness",
+        "./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-dev-story",
+        "./src/bmm-skills/4-implementation/bmad-quick-dev",
+        "./src/bmm-skills/4-implementation/bmad-sprint-planning",
+        "./src/bmm-skills/4-implementation/bmad-sprint-status",
+        "./src/bmm-skills/4-implementation/bmad-code-review",
+        "./src/bmm-skills/4-implementation/bmad-create-story",
+        "./src/bmm-skills/4-implementation/bmad-correct-course",
+        "./src/bmm-skills/4-implementation/bmad-retrospective",
+        "./src/bmm-skills/4-implementation/bmad-qa-generate-e2e-tests"
+      ]
+    }
+  ]
+}

.github/workflows/publish.yaml

@@ -5,8 +5,9 @@ on:
     branches: [main]
     paths:
       - "src/**"
-      - "tools/cli/**"
+      - "tools/installer/**"
       - "package.json"
+      - "removals.txt"
   workflow_dispatch:
     inputs:
       channel:
@@ -135,6 +136,22 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Advance @next dist-tag to stable
+        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
+        # Failure here leaves @next stale until the next push-driven prerelease
+        # republishes — annoying but not release-breaking. Don't fail the job
+        # after a successful stable publish + tag + GH release.
+        continue-on-error: true
+        run: |
+          # Without this, @latest can leapfrog @next (e.g. latest=6.5.0 while
+          # next=6.4.1-next.0) and `npx bmad-method@next install` silently
+          # downgrades users. Point @next at the just-published stable so
+          # @next >= @latest always holds; the next push-driven prerelease will
+          # bump from this base via the existing derive step above.
+          VERSION=$(node -p 'require("./package.json").version')
+          npm dist-tag add "bmad-method@${VERSION}" next
+          echo "Advanced @next dist-tag to ${VERSION}"
+
       - name: Notify Discord
         if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
         continue-on-error: true

.gitignore

@@ -50,6 +50,9 @@ z*/
 
 _bmad
 _bmad-output
+
+# Personal customization files (team files are committed, personal files are not)
+_bmad/custom/*.user.toml
 .clinerules
 # .augment/ is gitignored except tracked config files — add exceptions explicitly
 .augment/*

CHANGELOG.md

@@ -1,5 +1,151 @@
 # Changelog
 
+## v6.6.0 - 2026-04-28
+
+### 💥 Breaking Changes
+
+* `--tools none` is no longer accepted; fresh `--yes` installs now require an explicit `--tools <id>`. Existing-install flows are unchanged. Run `npx bmad-method --list-tools` to see supported IDs (#2346)
+* `project_name` has moved from `[modules.bmm]` to `[core]` in `config.toml`. Existing installs are auto-migrated on next install/update — no manual action required (#2348)
+
+### 🎁 Features
+
+* **Non-interactive config for CI/Docker** — new `--set <module>.<key>=<value>` (repeatable) and `--list-options [module]` flags allow installer configuration without prompts. Routes values to the correct config file with prototype-pollution defenses (#2354)
+* **Brownfield epic scoping** — Create Epics and Stories workflow now detects file-overlap between epics and applies an Implementation Efficiency principle plus a design completeness gate, reducing unnecessary file churn (#1826)
+
+### 🐛 Fixes
+
+* **Custom module installer** — Azure DevOps URLs now parse correctly with multi-segment paths and `_git` prefixes (#2269); HTTP (non-HTTPS) Git URLs are preserved for self-hosted servers (#2344); community installs route through `PluginResolver` so marketplace plugins with nested `module.yaml` install all skills (#2331); URL-source modules resolve from disk cache on re-install instead of warning (#2323); local `--custom-content` modules resolve correctly and `[modules.<code>]` TOML keys use the module code rather than display name (#2316); `--yes` with `--custom-source` now runs the full update path so version tags are respected (#2336)
+* **Installer safety** — `--list-tools` flag added; empty/typo'd tool IDs rejected with specific errors (#2346)
+* **Channel and dist-tag handling** — installer launched from a prerelease (e.g. `@next`) now defaults external module channels to `next` instead of silently downgrading to stable (#2321); stable publishes advance the `@next` dist-tag so prerelease users no longer leapfrog or miss update notifications (#2320)
+* **Architecture validation gate** — step-07 validation template no longer ships pre-checked; status field is now templated against actual checklist completion (#2347)
+* **bmad-help data integrity** — `bmad-help.csv` is no longer transformed at merge time and is emitted in its documented schema; 31 misaligned rows in core/bmm `module-help.csv` repaired (#2349)
+* **Config robustness** — malformed `module.yaml` (scalars, arrays) is now rejected before crash (#2348)
+* **Legacy cleanup** — pre-v6.2.0 wrapper skills (`bmad-bmm-*`, `bmad-agent-bmm-*`) are removed automatically on upgrade so they no longer error with missing-file warnings (#2315)
+
+### 📚 Docs
+
+* Complete Chinese (zh-CN) translations for `named-agents.md` and `expand-bmad-for-your-org.md`; localized BMad Ecosystem sidebar (CIS, BMB, TEA, WDS) across zh-cn, vi-vn, fr-fr, cs-cz (#2355)
+
+## v6.5.0 - 2026-04-26
+
+### 🎁 Features
+
+* Support for 18 new agent platforms: AdaL, Sourcegraph Amp, IBM Bob, Command Code, Snowflake Cortex Code, Factory Droid, Firebender, Block Goose, Kode, Mistral Vibe, Mux, Neovate, OpenClaw, OpenHands, Pochi, Replit Agent, Warp, Zencoder — bringing total supported platforms to 42 (#2313)
+* All platforms that support the cross-tool `.agents/skills/` standard now use it (#2313)
+
+## v6.4.0 - 2026-04-24
+
+### ✨ Headline
+
+**Full agent and workflow customization across the entire BMad Method.** Every agent and workflow in BMM, Core, CIS, GDS, and TEA can now be customized via TOML overrides in `_bmad/custom/`. Customize agents to apply tooling, version control, or behavior changes across whole groups of workflows. Drop in fine-grained per-workflow overrides where you need them. Built for power users who want BMad to fit their stack without forking.
+
+**Stable and bleeding-edge release channels, standardized across all modules.** Pick `stable` or `next` per module, pin specific versions, and switch channels interactively or via CLI flags (`--channel`, `--all-stable`, `--all-next`, `--next=CODE`, `--pin CODE=TAG`). Same model across BMM, Core, and every external module.
+
+### 💥 Breaking Changes
+
+* Customization is now TOML-based; the briefly introduced YAML-based customization is no longer supported (#2284, #2283)
+
+### 🎁 Features
+
+**Customization framework**
+
+* TOML-based agent and workflow customization with flat schema, structural merge rules (scalars, tables, code-keyed arrays, append arrays), and `persistent_facts` unification (#2284)
+* Central `_bmad/config.toml` surface with four-file architecture (`config.toml`, `config.user.toml`, `custom/config.toml`, `custom/config.user.toml`) for agent roster and scope-partitioned install answers (#2285)
+* `customize.toml` support extended to 17 bmm-skills workflows with flattened SKILL.md architecture and standardized `[workflow]` block (#2287)
+* `customize.toml` extended to all six developer-execution workflows: bmad-dev-story, bmad-code-review, bmad-sprint-planning, bmad-sprint-status, bmad-quick-dev, bmad-checkpoint-preview (#2308)
+* `bmad-customize` skill — guided authoring of TOML overrides in `_bmad/custom/` with stdlib-only resolver verification (#2289)
+* Wire `on_complete` hook into all 23 workflow terminal steps with full customize.toml documentation (#2290)
+
+**Release channels & installer**
+
+* Channel-based version resolution for external modules with interactive channel management (`stable` / `next` / `pinned`) and CLI flags (`--channel`, `--all-stable`, `--all-next`, `--next=CODE`, `--pin CODE=TAG`) (#2305)
+* GitHub API as primary fetch with raw CDN fallback in installer registry client to support corporate proxies (#2248)
+
+**Other**
+
+* Kimi Code CLI support for installing BMM skills in `.kimi/skills/` (#2302)
+* `bmad-create-story` now reads every UPDATE-marked file before generating dev notes so brownfield stories preserve current behavior instead of improvising at implementation time (#2274)
+* Sync `sprint-status.yaml` from quick-dev on epic-story implementation with idempotent writes tracking `in-progress` and `review` transitions (#2234)
+* Enforce model parity for all code review subagents to match orchestrator session capability for improved rare-event detection (#2236)
+* Set `team: software-development` on all six BMM agents for unified grouping in party-mode and retrospective skills (#2286)
+
+### 🐛 Bug Fixes
+
+* PRD workflow no longer silently de-scopes user requirements or invents MVP/Growth/Vision phasing; requires explicit confirmation before any scope reduction (#1927)
+* Installer shows live npm version for external modules instead of stale cached metadata (#2307)
+* Resolve external-module agents from cache during manifest write so agents land in `config.toml` (#2295)
+* Fix installer version resolution for external modules with shared resolver preferring package.json > module.yaml > marketplace.json (#2298)
+* Replace fs-extra with native `node:fs` to prevent file loss during multi-module installs from deferred retry-queue races (#2253)
+* Add `move()` and overwrite support to fs-native wrapper for directory migrations during upgrades (#2253)
+* Stop skill scanner from recursing into discovered skills to prevent spurious errors on nested template files (#2255)
+* Source built-in modules locally in installer UI to preserve core and bmm in module list when registry is unreachable (#2251)
+* Remove dead Batch-apply option from code-review patch menu and rename apply options for clarity (#2225)
+
+### ♻️ Refactoring
+
+* Remove 1,683 lines of dead code: three entirely dead files (agent-command-generator.js, bmad-artifacts.js, module-injections.js) and ~50 unused exports across installer modules (#2247)
+* Remove dead template and agent-command pipeline from installer; SKILL.md directory copying is the sole installation path (#2244)
+
+### 📚 Documentation
+
+* Sync and update Vietnamese (vi-VN) docs with missing pages and refreshed translations (#2291, #2222)
+* Sync French (fr-FR) translations with upstream, restore Amelia as dev agent, fix sidebar ordering (#2231)
+* Add Czech (cs-CZ) `analysis-phase.md` translation; normalize typographic quotes (#2240, #2241, #2242)
+* Add missing Chinese (zh-CN) translations for 3 documents (#2254)
+* Update stale Analyst agent triggers and add PRFAQ link (#2238)
+* Remove Bob from workflow map diagrams reflecting consolidation into Amelia in v6.3.0 (#2252)
+
+## v6.3.0 - 2026-04-09
+
+### 💥 Breaking Changes
+
+* Remove custom content installation feature; use marketplace-based plugin installation instead (#2227)
+* Remove bmad-init skill; all agents and skills now load config directly from `{project-root}/_bmad/bmm/config.yaml` (#2159)
+* Remove spec-wip.md singleton; quick-dev now writes directly to `spec-{slug}.md` with status field, enabling parallel sessions (#2214)
+* Consolidate three agent personas into Developer agent (Amelia): remove Barry quick-flow-solo-dev (#2177), Quinn QA agent (#2179), and Bob Scrum Master agent (#2186)
+
+### 🎁 Features
+
+* Universal source support for custom module installs with 5-strategy PluginResolver cascade supporting any Git host (GitHub, GitLab, Bitbucket, self-hosted) and local file paths (#2233)
+* Community module browser with three-tier selection: official, community (category drill-down from marketplace index), and custom URL with unverified source warning (#2229)
+* Switch module source of truth from bundled config to remote marketplace registry with network-failure fallback (#2228)
+* Add bmad-prfaq skill implementing Amazon's Working Backwards methodology as alternative Phase 1 analysis path with 5-stage coached workflow and subagent architecture (#2157)
+* Add bmad-checkpoint-preview skill for guided, concern-ordered human review of commits, branches, or PRs (#2145)
+* Epic context compilation for quick-dev step-01: sub-agent compiles planning docs into cached `epic-{N}-context.md` for story implementation (#2218)
+* Previous story continuity in quick-dev: load completed spec from same epic as implementation context (#2201)
+* Planning artifact awareness in quick-dev: selectively load PRD, architecture, UX, and epics docs for context-informed specs (#2185)
+* One-shot route now generates lightweight spec trace file for consistent artifact tracking (#2121)
+* Improve checkpoint-preview UX with clickable spec paths, external edit detection, and missing-file halt (#2217)
+* Add Junie (JetBrains AI) platform support (#2142)
+* Restore KiloCoder support with native-skills installation (#2151)
+* Add bmad-help support for llms.txt general questions (#2230)
+
+### ♻️ Refactoring
+
+* Consolidate party-mode into single SKILL.md with real subagent spawning via Agent tool, replacing multi-file workflow architecture (#2160)
+
+### 🐛 Bug Fixes
+
+* Fix version display bug where marketplace.json walk-up reported wrong version (#2233)
+* Fix checkpoint-preview step-05 advancing without user confirmation by adding explicit HALT (#2184)
+* Address adversarial triage findings: clarify review_mode transitions, label walkthrough branches, fix terse commit handling (#2180)
+* Preserve local custom module sources during quick update (#2172)
+* Support skills/ folder as fallback module source location for bmb compatibility (#2149)
+
+### 🔧 Maintenance
+
+* Overhaul installer branding with responsive BMAD METHOD logo, blue color scheme, unified version sourcing from marketplace.json, and surgical manifest-based skill cleanup (#2223)
+* Stop copying skill prompts to _bmad by default (#2182)
+* Add Python 3.10+ and uv as documented prerequisites (#2221)
+
+### 📚 Documentation
+
+* Complete Czech (cs-CZ) documentation translation (#2134)
+* Complete Vietnamese (vi-VN) documentation translation (#2110, #2192)
+* Rewrite get-answers-about-bmad as 1-2-3 escalation flow, remove deprecated references (#2213)
+* Add checkpoint-preview explainer page and workflow diagram (#2183)
+* Update docs theme to match bmadcode.com with responsive logo and blue color scheme (#2176)
+
 ## v6.2.2 - 2026-03-25
 
 ### ♻️ Refactoring

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.
+| ----------------------- | -------------------------------------------------------- |
+| 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
@@ -50,6 +52,15 @@ Follow the installer prompts, then open your AI IDE (Claude Code, Cursor, etc.)
 npx bmad-method install --directory /path/to/project --modules bmm --tools claude-code --yes
 ```
 
+Override any module config option with `--set <module>.<key>=<value>` (repeatable). Run `--list-options [module]` to see locally-known official keys (built-in modules plus any external officials cached on this machine):
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm --tools claude-code \
+  --set bmm.project_knowledge=research \
+  --set bmm.user_skill_level=expert
+```
+
 [See all installation options](https://docs.bmad-method.org/how-to/non-interactive-installation/)
 
 > **Not sure what to do?** Ask `bmad-help` — it tells you exactly what's next and what's optional. You can also ask questions like `bmad-help I just finished the architecture, what do I do next?`
@@ -79,18 +90,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,109 @@
+![BMad Method](banner-bmad-method.png)
+
+[![Version](https://img.shields.io/npm/v/bmad-method?color=blue&label=version)](https://www.npmjs.com/package/bmad-method)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)](https://nodejs.org)
+[![Python Version](https://img.shields.io/badge/python-%3E%3D3.10-blue?logo=python&logoColor=white)](https://www.python.org)
+[![uv](https://img.shields.io/badge/uv-package%20manager-blueviolet?logo=uv)](https://docs.astral.sh/uv/)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white)](https://discord.gg/gk8jAdXWmj)
+
+[English](README.md) | [简体中文](README_CN.md) | Tiếng Việt
+
+**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+ · [Python](https://www.python.org) 3.10+ · [uv](https://docs.astral.sh/uv/)
+
+```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
+- [YouTube](https://youtube.com/@BMadCode) - Video hướng dẫn, master class và nhiều nội dung khác
+- [X / Twitter](https://x.com/BMadCode)
+- [Website](https://bmadcode.com)
+- [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. Hãy nhấn sao cho repo này, [mời tôi một ly cà phê](https://buymeacoffee.com/bmad), hoặc gửi email tới <contact@bmadcode.com> nếu bạn muốn tài trợ doanh nghiệp.
+
+## Đó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/analysis-phase.md

@@ -0,0 +1,70 @@
+---
+title: "Fáze analýzy: od nápadu k základům"
+description: Co je brainstorming, výzkum, product brief a PRFAQ — a kdy který nástroj použít
+sidebar:
+  order: 1
+---
+
+Fáze analýzy (fáze 1) vám pomůže jasně si promyslet váš produkt, než se pustíte do jeho tvorby. Každý nástroj v této fázi je volitelný, ale úplné vynechání analýzy znamená, že váš PRD je postaven na předpokladech namísto vhledu.
+
+## Proč analýza před plánováním?
+
+PRD odpovídá na otázku „Co bychom měli postavit a proč?“. Pokud jej nakrmíte vágním myšlením, získáte vágní PRD — a každý navazující dokument tuto vágnost zdědí. Architektura postavená na slabém PRD sází na špatnou techniku. Příběhy odvozené ze slabé architektury opomíjejí okrajové případy. Náklady se zvyšují.
+
+Existují analytické nástroje, které vám PRD zostří. Napadají problém z různých úhlů — kreativní průzkum, realita trhu, jasnost zákazníka, proveditelnost — takže v době, kdy sedíte s agentem PM, víte, co a pro koho stavíte.
+
+## Nástroje
+
+### Brainstorming
+
+**Co to je.** Zprostředkované tvůrčí sezení s využitím osvědčených technik generování nápadů. AI funguje jako kouč, který z vás tahá nápady prostřednictvím strukturovaných cvičení — negeneruje nápady za vás.
+
+**Proč je to tady.** Neotřelé nápady potřebují prostor pro rozvoj, než se zakotví v požadavcích. Brainstorming tento prostor vytváří. Je cenný zejména tehdy, když máte problémovou oblast, ale nemáte jasné řešení, nebo když chcete prozkoumat více směrů, než se k něčemu zavážete.
+
+**Kdy jej použít.** Máte nejasnou představu o tom, co chcete vytvořit, ale nemáte vykrystalizovaný koncept. Nebo máte koncept, ale chcete ho otestovat pod tlakem oproti alternativám.
+
+Viz [Brainstorming](./brainstorming.md), kde se dozvíte, jak relace fungují.
+
+### Výzkum (trhu, domény, technický)
+
+**Co to je.** Tři cílené pracovní postupy výzkumu, které zkoumají různé rozměry vašeho nápadu. Výzkum trhu zkoumá konkurenci, trendy a nálady uživatelů. Doménový výzkum vytváří odborné znalosti v daném oboru a terminologii. Technický výzkum hodnotí proveditelnost, možnosti architektury a přístupy k implementaci.
+
+**Proč je to tady.** Stavět na předpokladech je nejrychlejší způsob, jak vytvořit něco, co nikdo nepotřebuje. Výzkum zakládá váš koncept na realitě — co již existuje u konkurence, s čím uživatelé skutečně bojují, co je technicky proveditelné a jakým omezením specifickým pro dané odvětví budete čelit.
+
+**Kdy ho použít.** Vstupujete do neznámé oblasti, tušíte, že konkurence existuje, ale nemáte ji zmapovanou, nebo váš koncept závisí na technických možnostech, které nemáte ověřené. Proveďte jeden, dva nebo všechny tři — každý z nich je samostatný.
+
+### Product Brief
+
+**Co to je.** Řízené zjišťovací sezení, jehož výsledkem je 1–2stránkové shrnutí vašeho konceptu produktu. AI funguje jako spolupracující obchodní analytik, který vám pomůže formulovat vizi, cílovou skupinu, nabídku hodnoty a rozsah.
+
+**Proč tu je.** Produktový brief je jemnější cestou k plánování. Zachycuje vaši strategickou vizi ve strukturovaném formátu, který se přímo promítá do tvorby PRD. Nejlépe funguje, když jste již o svém konceptu přesvědčeni — znáte zákazníka, problém a zhruba víte, co chcete vytvořit. Brief tyto úvahy uspořádá a vyostří.
+
+**Kdy jej použít.** Váš koncept je relativně jasný a chcete jej efektivně zdokumentovat ještě před vytvořením PRD. Jste si jisti svým směřováním a nepotřebujete své předpoklady agresivně zpochybňovat.
+
+### PRFAQ (Working Backwards)
+
+**Co to je.** Metodika Working Backwards společnosti Amazon upravená jako interaktivní výzva. Napíšete tiskovou zprávu oznamující váš hotový produkt dříve, než existuje jediný řádek kódu, a pak odpovíte na nejtěžší otázky, které by vám zákazníci a zainteresované strany položili. Umělá inteligence funguje jako neúprosný, ale konstruktivní produktový kouč.
+
+**Proč je to tady.** PRFAQ je přísná cesta k plánování. Vynucuje si jasnost v zájmu zákazníka tím, že vás nutí obhájit každé tvrzení. Pokud nedokážete napsat přesvědčivou tiskovou zprávu, produkt není připraven. Pokud odpovědi na časté dotazy zákazníků odhalí nedostatky, jsou to nedostatky, které byste objevili mnohem později — a nákladněji — při implementaci. Hozená rukavice odhalí slabé myšlení v rané fázi, kdy je nejlevnější ho opravit.
+
+**Kdy ji použít.** Před vyčleněním zdrojů chcete, aby váš koncept prošel zátěžovým testem. Nejste si jisti, zda to uživatele bude skutečně zajímat. Chcete si ověřit, že dokážete formulovat jasnou a obhajitelnou nabídku hodnoty. Nebo si prostě chcete disciplínou Working Backwards zpřesnit své myšlení.
+
+## Který nástroj bych měl použít?
+
+| Situace | Doporučený nástroj |
+| --------- | ---------------- |
+| „Mám nejasný nápad, ale nevím, kde začít“ | Brainstorming |
+| „Než se rozhodnu, potřebuji pochopit trh“ | Výzkum |
+| „Vím, co chci vytvořit, jen to potřebuji zdokumentovat“ | Product Brief |
+| „Chci se ujistit, že tento nápad skutečně stojí za vybudování“ | PRFAQ |
+| „Chci prozkoumat, pak ověřit a pak zdokumentovat“ | Brainstorming → Výzkum → PRFAQ nebo Brief |
+
+Product Brief i PRFAQ jsou vstupem pro PRD — vyberte si jeden z nich podle toho, jak moc chcete být nároční. Brief je společným objevováním. PRFAQ je hozená rukavice. Obojí vás dovede ke stejnému cíli; PRFAQ testuje, zda si váš koncept zaslouží se tam dostat.
+
+:::tip[Nejste si jisti?]
+Spusťte `bmad-help` a popište svou situaci. Doporučí vám správný výchozí bod na základě toho, co jste již udělali a čeho se snažíte dosáhnout.
+:::
+
+## Co se stane po analýze?
+
+Výstupy analýzy se přímo promítají do fáze 2 (plánování). Pracovní postup PRD přijímá jako vstupy produktové briefy, dokumenty PRFAQ, výsledky výzkumu a zprávy z brainstormingu — syntetizuje vše, co jste vytvořili, do strukturovaných požadavků. Čím více analýz provedete, tím ostřejší bude vaše PRD.

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,153 @@
+---
+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` |
+| `--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/installer/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
+```
+
+## 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
+
+:::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`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP`     | Brainstorm, průzkum trhu, doménový výzkum, technický 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](../explanation/analysis-phase.md#prfaq-working-backwards) 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/explanation/analysis-phase.md

@@ -0,0 +1,70 @@
+---
+title: "Analysis Phase: From Idea to Foundation"
+description: What brainstorming, research, product briefs, and PRFAQs are — and when to use each
+sidebar:
+  order: 1
+---
+
+The Analysis phase (Phase 1) helps you think clearly about your product before committing to building it. Every tool in this phase is optional, but skipping analysis entirely means your PRD is built on assumptions instead of insight.
+
+## Why Analysis Before Planning?
+
+A PRD answers "what should we build and why?" If you feed it vague thinking, you get a vague PRD — and every downstream document inherits that vagueness. Architecture built on a weak PRD makes wrong technical bets. Stories derived from weak architecture miss edge cases. The cost compounds.
+
+Analysis tools exist to make your PRD sharp. They attack the problem from different angles — creative exploration, market reality, customer clarity, feasibility — so that by the time you sit down with the PM agent, you know what you're building and for whom.
+
+## The Tools
+
+### Brainstorming
+
+**What it is.** A facilitated creative session using proven ideation techniques. The AI acts as coach, pulling ideas out of you through structured exercises — not generating ideas for you.
+
+**Why it's here.** Raw ideas need space to develop before they get locked into requirements. Brainstorming creates that space. It's especially valuable when you have a problem domain but no clear solution, or when you want to explore multiple directions before committing.
+
+**When to use it.** You have a vague sense of what you want to build but haven't crystallized the concept. Or you have a concept but want to pressure-test it against alternatives.
+
+See [Brainstorming](./brainstorming.md) for a deeper look at how sessions work.
+
+### Research (Market, Domain, Technical)
+
+**What it is.** Three focused research workflows that investigate different dimensions of your idea. Market research examines competitors, trends, and user sentiment. Domain research builds subject-matter expertise and terminology. Technical research evaluates feasibility, architecture options, and implementation approaches.
+
+**Why it's here.** Building on assumptions is the fastest way to build something nobody needs. Research grounds your concept in reality — what competitors already exist, what users actually struggle with, what's technically feasible, and what industry-specific constraints you'll face.
+
+**When to use it.** You're entering an unfamiliar domain, you suspect competitors exist but haven't mapped them, or your concept depends on technical capabilities you haven't validated. Run one, two, or all three — each stands alone.
+
+### Product Brief
+
+**What it is.** A guided discovery session that produces a 1-2 page executive summary of your product concept. The AI acts as a collaborative Business Analyst, helping you articulate the vision, target audience, value proposition, and scope.
+
+**Why it's here.** The product brief is the gentler path into planning. It captures your strategic vision in a structured format that feeds directly into PRD creation. It works best when you already have conviction about your concept — you know the customer, the problem, and roughly what you want to build. The brief organizes and sharpens that thinking.
+
+**When to use it.** Your concept is relatively clear and you want to document it efficiently before creating a PRD. You're confident in the direction and don't need your assumptions aggressively challenged.
+
+### PRFAQ (Working Backwards)
+
+**What it is.** Amazon's Working Backwards methodology adapted as an interactive challenge. You write the press release announcing your finished product before a single line of code exists, then answer the hardest questions customers and stakeholders would ask. The AI acts as a relentless but constructive product coach.
+
+**Why it's here.** The PRFAQ is the rigorous path into planning. It forces customer-first clarity by making you defend every claim. If you can't write a compelling press release, the product isn't ready. If customer FAQ answers reveal gaps, those are gaps you'd discover much later — and more expensively — during implementation. The gauntlet surfaces weak thinking early, when it's cheapest to fix.
+
+**When to use it.** You want your concept stress-tested before committing resources. You're unsure whether users will actually care. You want to validate that you can articulate a clear, defensible value proposition. Or you simply want the discipline of Working Backwards to sharpen your thinking.
+
+## Which Should I Use?
+
+| Situation | Recommended tool |
+| --------- | ---------------- |
+| "I have a vague idea, not sure where to start" | Brainstorming |
+| "I need to understand the market before deciding" | Research |
+| "I know what I want to build, just need to document it" | Product Brief |
+| "I want to make sure this idea is actually worth building" | PRFAQ |
+| "I want to explore, then validate, then document" | Brainstorming → Research → PRFAQ or Brief |
+
+Product Brief and PRFAQ both produce input for the PRD — choose one based on how much challenge you want. The brief is collaborative discovery. The PRFAQ is a gauntlet. Both get you to the same destination; the PRFAQ tests whether your concept deserves to get there.
+
+:::tip[Not Sure?]
+Run `bmad-help` and describe your situation. It will recommend the right starting point based on what you've already done and what you're trying to accomplish.
+:::
+
+## What Happens After Analysis?
+
+Analysis outputs feed directly into Phase 2 (Planning). The PRD workflow accepts product briefs, PRFAQ documents, research findings, and brainstorming reports as input — it synthesizes whatever you've produced into structured requirements. The more analysis you do, the sharper your PRD.

docs/explanation/checkpoint-preview.md

@@ -0,0 +1,92 @@
+---
+title: "Checkpoint Preview"
+description: LLM-assisted human-in-the-loop review that guides you through a change from purpose to details
+sidebar:
+  order: 3
+---
+
+`bmad-checkpoint-preview` is an interactive, LLM-assisted human-in-the-loop review workflow. It walks you through a code change — from purpose and context into details — so you can make an informed decision about whether to ship, rework, or dig deeper.
+
+![Checkpoint Preview workflow diagram](/diagrams/checkpoint-preview-diagram.png)
+
+## The Typical Flow
+
+You run `bmad-quick-dev`. It clarifies your intent, builds a spec, implements the change, and when it's done it appends a review trail to the spec file and opens it in your editor. You look at the spec and see the change touched 20 files across several modules.
+
+You could eyeball the diff. But 20 files is where eyeballing starts to fail — you lose the thread, miss a connection between two distant changes, or approve something you didn't fully understand. So instead, you say "checkpoint" and the LLM walks you through it.
+
+That handoff — from autonomous implementation back to human judgment — is the primary use case. Quick-dev runs long with minimal supervision. Checkpoint Preview is where you take back the wheel.
+
+## Why It Exists
+
+Code review has two failure modes. In one, the reviewer skims the diff, nothing jumps out, and they approve. In the other, they methodically read every file but lose the thread — they see the trees and miss the forest. Both result in the same outcome: the review didn't catch the thing that mattered.
+
+The underlying issue is sequencing. A raw diff presents changes in file order, which is almost never the order that builds understanding. You see a helper function before you know why it exists. You see a schema change before you understand what feature it supports. The reviewer has to reconstruct the author's intent from scattered clues, and that reconstruction is where attention fails.
+
+Checkpoint Preview solves this by making the LLM do the reconstruction work. It reads the diff, the spec (if one exists), and the surrounding codebase, then presents the change in an order designed for comprehension — not for `git diff`.
+
+## How It Works
+
+The workflow has five steps. Each step builds on the previous one, progressively shifting from "what is this?" toward "should we ship it?"
+
+### 1. Orientation
+
+The workflow identifies the change (from a PR, commit, branch, spec file, or the current git state) and produces a one-line intent summary plus surface area stats: files changed, modules touched, lines of logic, boundary crossings, and new public interfaces.
+
+This is the "is this what I think it is?" moment. Before reading any code, the reviewer confirms they're looking at the right thing and calibrates their expectations for scope.
+
+### 2. Walkthrough
+
+The change is organized by **concern** — cohesive design intents like "input validation" or "API contract" — not by file. Each concern gets a short explanation of *why* this approach was chosen, followed by clickable `path:line` stops that the reviewer can follow through the code.
+
+This is the design judgment step. The reviewer evaluates whether the approach is right for the system, not whether the code is correct. Concerns are sequenced top-down: the highest-level intent first, then supporting implementation. The reviewer never encounters a reference to something they haven't seen yet.
+
+### 3. Detail Pass
+
+After the reviewer understands the design, the workflow surfaces 2-5 spots where a mistake would have the highest blast radius. These are tagged by risk category — `[auth]`, `[schema]`, `[billing]`, `[public API]`, `[security]`, and others — and ordered by how much breaks if they're wrong.
+
+This is not a bug hunt. Automated tests and CI handle correctness. The detail pass activates risk awareness: "here are the places where being wrong costs the most." If the reviewer wants to go deeper on a specific area, they can say "dig into [area]" for a targeted correctness-focused re-review.
+
+If the spec went through adversarial review loops (machine hardening), those findings are surfaced here too — not the bugs that were fixed, but the decisions that the review loop flagged that the reviewer should be aware of.
+
+### 4. Testing
+
+Suggests 2-5 ways to manually observe the change working. Not automated test commands — manual observations that build confidence no test suite provides. A UI interaction to try, a CLI command to run, an API request to send, with expected results for each.
+
+If the change has no user-visible behavior, it says so. No invented busywork.
+
+### 5. Wrap-Up
+
+The reviewer makes the call: approve, rework, or keep discussing. If approving a PR, the workflow can help with `gh pr review --approve`. If reworking, it helps diagnose whether the problem was the approach, the spec, or the implementation, and helps draft actionable feedback tied to specific code locations.
+
+## It's a Conversation, Not a Report
+
+The workflow presents each step as a starting point, not a final word. Between steps — or in the middle of one — you can talk to the LLM, ask questions, challenge its framing, or pull in other skills to get a different perspective:
+
+- **"run advanced elicitation on the error handling"** — push the LLM to reconsider and refine its analysis of a specific area
+- **"party mode on whether this schema migration is safe"** — bring multiple agent perspectives into a focused debate
+- **"run code review"** — generate structured agentic findings with adversarial and edge-case analysis
+
+The checkpoint workflow doesn't lock you into a linear path. It gives you structure when you want it and gets out of the way when you want to explore. The five steps are there to make sure you see the whole picture, but how deep you go at each step — and what tools you bring in — is entirely up to you.
+
+## The Review Trail
+
+The walkthrough step works best when it has a **Suggested Review Order** — a list of stops the spec author wrote to guide reviewers through the change. When a spec includes this, the workflow uses it directly.
+
+When no author-produced trail exists, the workflow generates one from the diff and codebase context. A generated trail is lower quality than an author-produced one, but far better than reading changes in file order.
+
+## When to Use It
+
+The primary scenario is the handoff from `bmad-quick-dev`: the implementation is done, the spec file is open in your editor with a review trail appended, and you need to decide whether to ship. Say "checkpoint" and go.
+
+It also works standalone:
+
+- **Reviewing a PR** — especially one with more than a handful of files or cross-cutting changes
+- **Onboarding to a change** — when you need to understand what happened on a branch you didn't write
+- **Sprint review** — the workflow can pick up stories marked `review` in your sprint status file
+
+Invoke it by saying "checkpoint" or "walk me through this change." It works in any terminal, but you'll get more out of it inside an IDE — VS Code, Cursor, or similar — because the workflow produces `path:line` references at every step. In an IDE-embedded terminal those are clickable, so you can jump from file to file as you follow the review trail.
+
+## What It Is Not
+
+Checkpoint Preview is not a substitute for automated review. It does not run linters, type checkers, or test suites. It does not assign severity scores or produce pass/fail verdicts. It is a reading guide that helps a human apply their judgment where it matters most.

docs/explanation/named-agents.md

@@ -0,0 +1,94 @@
+---
+title: "Named Agents"
+description: Why BMad agents have names, personas, and customization surfaces — and what that unlocks compared to menu-driven or prompt-driven alternatives
+sidebar:
+  order: 1
+---
+
+You say "Hey Mary, let's brainstorm," and Mary activates. She greets you by name, in the language you configured, with her distinctive persona. She reminds you that `bmad-help` is always available. Then she skips the menu entirely and drops straight into brainstorming — because your intent was clear.
+
+This page explains what's actually happening and why BMad is designed this way.
+
+## The Three-Legged Stool
+
+BMad's agent model rests on three primitives that compose:
+
+| Primitive | What it provides | Where it lives |
+|---|---|---|
+| **Skill** | Capability — a discrete thing the assistant can do (brainstorm, draft a PRD, implement a story) | `.claude/skills/{skill-name}/SKILL.md` (or your IDE's equivalent) |
+| **Named agent** | Persona continuity — a recognizable identity that wraps a menu of related skills with consistent voice, principles, and visual cues | Skills whose directory starts with `bmad-agent-*` |
+| **Customization** | Makes it yours — overrides that reshape an agent's behavior, add MCP integrations, swap templates, layer in org conventions | `_bmad/custom/{skill-name}.toml` (committed team overrides) and `.user.toml` (personal, gitignored) |
+
+Pull any leg away and the experience collapses:
+
+- Skills without agents → capability lists the user has to navigate by name or code
+- Agents without skills → personas with nothing to do
+- No customization → every user gets the same out-of-box behavior, forcing forks for any org-specific need
+
+## What Named Agents Buy You
+
+BMad ships six named agents, each anchored to a phase of the BMad Method:
+
+| Agent | Phase | Module |
+|---|---|---|
+| 📊 **Mary**, Business Analyst | Analysis | market research, brainstorming, product briefs, PRFAQs |
+| 📚 **Paige**, Technical Writer | Analysis | project documentation, diagrams, doc validation |
+| 📋 **John**, Product Manager | Planning | PRD creation, epic/story breakdown, implementation readiness |
+| 🎨 **Sally**, UX Designer | Planning | UX design specifications |
+| 🏗️ **Winston**, System Architect | Solutioning | technical architecture, alignment checks |
+| 💻 **Amelia**, Senior Engineer | Implementation | story execution, quick-dev, code review, sprint planning |
+
+They each have a hardcoded identity (name, title, domain) and a customizable layer (role, principles, communication style, icon, menu). You can rewrite Mary's principles or add menu items; you can't rename her — that's deliberate. Brand recognition survives customization so "hey Mary" always activates the analyst, regardless of how a team has shaped her behavior.
+
+## The Activation Flow
+
+When you invoke a named agent, eight steps run in order:
+
+1. **Resolve the agent block** — merge the shipped `customize.toml` with team and personal overrides, via a Python resolver using stdlib `tomllib`
+2. **Execute prepend steps** — any pre-flight behavior the team configured
+3. **Adopt persona** — hardcoded identity plus customized role, communication style, principles
+4. **Load persistent facts** — org rules, compliance notes, optionally files loaded via a `file:` prefix (e.g., `file:{project-root}/docs/project-context.md`)
+5. **Load config** — user name, communication language, output language, artifact paths
+6. **Greet** — personalized, in the configured language, with the agent's emoji prefix so you can see at a glance who's speaking
+7. **Execute append steps** — any post-greet setup the team configured
+8. **Dispatch or present the menu** — if your opening message maps to a menu item, go directly; otherwise render the menu and wait for input
+
+Step 8 is where intent meets capability. "Hey Mary, let's brainstorm" skips rendering because `bmad-brainstorming` is an obvious match for `BP` on Mary's menu. If you say something ambiguous, she asks once, briefly, not as a confirmation ritual. If nothing fits, she continues the conversation normally.
+
+## Why Not Just a Menu?
+
+Menus force the user to meet the tool halfway. You have to remember that brainstorming lives under code `BP` on the analyst agent, not the PM agent, and know which persona owns which capabilities. That's cognitive overhead the tool is making you carry.
+
+Named agents invert it. You say what you want, to whom, in whatever words feel natural. The agent knows who they are and what they do. When your intent is clear enough, they just go.
+
+The menu is still there as a fallback — show it when you're exploring, skip it when you're not.
+
+## Why Not Just a Blank Prompt?
+
+Blank prompts assume you know the magic words. "Help me brainstorm" might work, but "let's ideate on my SaaS idea" might not, and the results depend on how you phrased the ask. You become responsible for prompt engineering.
+
+Named agents add structure without closing off freedom. The persona stays consistent, the capabilities are discoverable, and `bmad-help` is always one command away. You don't have to guess what the agent can do, and you don't need a manual to use it either.
+
+## Customization as a First-Class Citizen
+
+The customization model is what lets this scale beyond a single developer.
+
+Every agent ships a `customize.toml` with sensible defaults. Teams commit overrides to `_bmad/custom/bmad-agent-{role}.toml`. Individuals can layer personal preferences in `.user.toml` (gitignored). The resolver merges all three at activation time with predictable structural rules.
+
+Most users never hand-author these files. The `bmad-customize` skill walks through picking the target, choosing agent vs workflow scope, authoring the override, and verifying the merge — so the customization surface stays accessible to anyone who understands their intent, not just those fluent in TOML.
+
+Concrete example: a team commits a single file telling Amelia to always use the Context7 MCP tool for library docs and to fall back to Linear when a story isn't in the local epics list. Every dev workflow Amelia dispatches (dev-story, quick-dev, create-story, code-review) inherits that behavior, with no source edits or per-workflow duplication required.
+
+There's also a second customization surface for *cross-cutting* concerns: the central `_bmad/config.toml` and `_bmad/config.user.toml` (both installer-owned, rebuilt from each module's `module.yaml`) plus `_bmad/custom/config.toml` (team, committed) and `_bmad/custom/config.user.toml` (personal, gitignored) for overrides. This is where the **agent roster** lives — the lightweight descriptors that roster consumers like `bmad-party-mode`, `bmad-retrospective`, and `bmad-advanced-elicitation` read to know who's available and how to embody them. Rebrand an agent org-wide with a team override; add fictional voices (Kirk, Spock, a domain expert persona) as personal experiments via the `.user.toml` override — without touching any skill folder. The per-skill file shapes how Mary *behaves* when she activates; the central config shapes how other skills *see* her when they look at the field.
+
+For the full customization surface and worked examples, see:
+
+- [How to Customize BMad](../how-to/customize-bmad.md) — the reference for what's customizable and how merge works
+- [How to Expand BMad for Your Organization](../how-to/expand-bmad-for-your-org.md) — five worked recipes spanning agent-wide rules, workflow conventions, external publishing, template swaps, and agent roster customization
+- `bmad-customize` skill — the guided authoring helper that turns intent into a correctly-placed, verified override file
+
+## The Bigger Idea
+
+Most AI assistants today are either menus or prompts, and both shift cognitive load onto the user. Named agents plus customizable skills let you talk to a teammate who already knows the work, and let your organization shape that teammate without forking.
+
+The next time you type "Hey Mary, let's brainstorm" and she just gets on with it, notice what didn't happen. There was no slash command, no menu to navigate, no awkward reminder of what she can do. That absence is the design.

docs/fr/_STYLE_GUIDE.md

@@ -353,7 +353,7 @@ Uniquement pour les parcours méthode BMad et Enterprise. Quick Dev passe direct
 
 ### Puis-je modifier mon plan plus tard ?
 
-Oui. Utilisez `bmad-correct-course` pour gérer les changements de portée.
+Oui. Utilisez `bmad-correct-course` pour gérer les changements de portée en cours d’implémentation.
 
 **Une question sans réponse ici ?** [Ouvrez une issue](...) ou posez votre question sur [Discord](...).
 ```

docs/fr/explanation/advanced-elicitation.md

@@ -2,7 +2,7 @@
 title: "Élicitation Avancée"
 description: Pousser le LLM à repenser son travail en utilisant des méthodes de raisonnement structurées
 sidebar:
-  order: 6
+  order: 8
 ---
 
 Faites repenser au LLM ce qu'il vient de générer. Vous choisissez une méthode de raisonnement, il l'applique à sa propre sortie, et vous décidez de conserver ou non les améliorations.

docs/fr/explanation/adversarial-review.md

@@ -2,7 +2,7 @@
 title: "Revue Contradictoire"
 description: Technique de raisonnement forcée qui empêche les revues paresseuses du style "ça à l'air bon"
 sidebar:
-  order: 5
+  order: 7
 ---
 
 Forcez une analyse plus approfondie en exigeant que des problèmes soient trouvés.

docs/fr/explanation/analysis-phase.md

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

docs/fr/explanation/checkpoint-preview.md

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

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

@@ -2,7 +2,7 @@
 title: "FAQ Projets Existants"
 description: Questions courantes sur l'utilisation de la méthode BMad sur des projets existants
 sidebar:
-  order: 8
+  order: 11
 ---
 Réponses rapides aux questions courantes sur l'utilisation de la méthode BMad (BMM) sur des projets existants.
 

docs/fr/explanation/party-mode.md

@@ -2,7 +2,7 @@
 title: "Party Mode"
 description: Collaboration multi-agents - regroupez tous vos agents IA dans une seule conversation
 sidebar:
-  order: 7
+  order: 9
 ---
 
 Regroupez tous vos agents IA dans une seule conversation.

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

@@ -2,7 +2,7 @@
 title: "Prévention des conflits entre agents"
 description: Comment l'architecture empêche les conflits lorsque plusieurs agents implémentent un système
 sidebar:
-  order: 4
+  order: 6
 ---
 
 Lorsque plusieurs agents IA implémentent différentes parties d'un système, ils peuvent prendre des décisions techniques contradictoires. La documentation d'architecture prévient cela en établissant des standards partagés.

docs/fr/explanation/project-context.md

@@ -2,7 +2,7 @@
 title: "Contexte du Projet"
 description: Comment project-context.md guide les agents IA avec les règles et préférences de votre projet
 sidebar:
-  order: 7
+  order: 10
 ---
 
 Le fichier `project-context.md` est le guide d'implémentation de votre projet pour les agents IA. Similaire à une « constitution » dans d'autres systèmes de développement, il capture les règles, les patterns et les préférences qui garantissent une génération de code cohérente à travers tous les workflows.

docs/fr/explanation/quick-dev.md

@@ -2,7 +2,7 @@
 title: "Quick Dev"
 description: Réduire la friction de l’interaction humaine sans renoncer aux points de contrôle qui protègent la qualité des résultats
 sidebar:
-  order: 2
+  order: 3
 ---
 
 Intention en entrée, modifications de code en sortie, avec aussi peu d'interactions humaines dans la boucle que possible — sans sacrifier la qualité.

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

@@ -2,7 +2,7 @@
 title: "Pourquoi le Solutioning est Important"
 description: Comprendre pourquoi la phase de solutioning est critique pour les projets multi-epics
 sidebar:
-  order: 3
+  order: 5
 ---
 
 La Phase 3 (Solutioning) traduit le **quoi** construire (issu de la Planification) en **comment** le construire (conception technique). Cette phase évite les conflits entre agents dans les projets multi-epics en documentant les décisions architecturales avant le début de l'implémentation.

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

@@ -58,7 +58,7 @@ Modifier la façon dont l'agent se présente :
 ```yaml
 agent:
   metadata:
-    name: 'Bob l’éponge' # Par défaut : "Mary"
+    name: 'Bob l’éponge' # Par défaut : "Amelia"
 ```
 
 **Persona**

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

@@ -5,111 +5,55 @@ sidebar:
   order: 4
 ---
 
-## Commencez ici : BMad-Help
+Utilisez l'aide intégrée de BMad, la documentation source ou la communauté pour obtenir des réponses — du plus rapide au plus approfondi.
 
-**Le moyen le plus rapide d'obtenir des réponses sur BMad est le skill `bmad-help`.** Ce guide intelligent répondra à plus de 80 % de toutes les questions et est disponible directement dans votre IDE pendant que vous travaillez.
+## 1. Demandez à BMad-Help
 
-BMad-Help est bien plus qu'un outil de recherche — il :
-- **Inspecte votre projet** pour voir ce qui a déjà été réalisé
-- **Comprend le langage naturel** — posez vos questions en français courant
-- **S'adapte à vos modules installés** — affiche les options pertinentes
-- **Se lance automatiquement après les workflows** — vous indique exactement quoi faire ensuite
-- **Recommande la première tâche requise** — plus besoin de deviner par où commencer
-
-### Comment utiliser BMad-Help
-
-Appelez-le par son nom dans votre session IA :
+Le moyen le plus rapide d'obtenir des réponses. Le skill `bmad-help` est disponible directement dans votre session IA et répond à plus de 80 % des questions — il inspecte votre projet, voit ce que vous avez accompli et vous dit quoi faire ensuite.
 
 ```
-bmad-help
+bmad-help J'ai une idée de SaaS et je connais toutes les fonctionnalités. Par où commencer ?
+bmad-help Quelles sont mes options pour le design UX ?
+bmad-help Je suis bloqué sur le workflow PRD
 ```
 
 :::tip
 Vous pouvez également utiliser `/bmad-help` ou `$bmad-help` selon votre plateforme, mais `bmad-help` tout seul devrait fonctionner partout.
 :::
 
-Combinez-le avec une requête en langage naturel :
+## 2. Approfondissez avec les sources
 
-```
-bmad-help J'ai une idée de SaaS et je connais toutes les fonctionnalités. Par où commencer ?
-bmad-help Quelles sont mes options pour le design UX ?
-bmad-help Je suis bloqué sur le workflow PRD
-bmad-help Montre-moi ce qui a été fait jusqu'à maintenant
-```
+BMad-Help s'appuie sur votre configuration installée. Pour les questions sur les éléments internes de BMad, son historique ou son architecture — ou si vous faites des recherches sur BMad avant de l'installer — pointez votre IA directement vers les sources.
 
-BMad-Help répond avec :
-- Ce qui est recommandé pour votre situation
-- Quelle est la première tâche requise
-- À quoi ressemble le reste du processus
-
-## Quand utiliser ce guide
-
-Utilisez cette section lorsque :
-- Vous souhaitez comprendre l'architecture ou les éléments internes de BMad
-- Vous avez besoin de réponses au-delà de ce que BMad-Help fournit
-- Vous faites des recherches sur BMad avant l'installation
-- Vous souhaitez explorer le code source directement
-
-## Étapes
-
-### 1. Choisissez votre source
-
-| Source                  | Idéal pour                                           | Exemples                              |
-|-------------------------|------------------------------------------------------|---------------------------------------|
-| **Dossier `_bmad`**     | Comment fonctionne BMad — agents, workflows, prompts | "Que fait l'agent Analyste ?"         |
-| **Repo GitHub complet** | Historique, installateur, architecture               | "Qu'est-ce qui a changé dans la v6 ?" |
-| **`llms-full.txt`**     | Aperçu rapide depuis la documentation                | "Expliquez les quatre phases de BMad" |
-
-Le dossier `_bmad` est créé lorsque vous installez BMad. Si vous ne l'avez pas encore, clonez le repo à la place.
-
-### 2. Pointez votre IA vers la source
-
-**Si votre IA peut lire des fichiers (Claude Code, Cursor, etc.) :**
-
-- **BMad installé :** Pointez vers le dossier `_bmad` et posez vos questions directement
-- **Vous voulez plus de contexte :** Clonez le [repo complet](https://github.com/bmad-code-org/BMAD-METHOD)
-
-**Si vous utilisez ChatGPT ou Claude.ai (LLM en ligne) :**
-
-Importez `llms-full.txt` dans votre session :
-
-```text
-https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
-```
-
-
-### 3. Posez votre question
+Clonez ou ouvrez le [dépôt BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) et posez vos questions à votre IA. Tout outil capable d'utiliser des agents (Claude Code, Cursor, Windsurf, etc.) peut lire les sources et répondre directement à vos questions.
 
 :::note[Exemple]
 **Q :** "Quel est le moyen le plus rapide de construire quelque chose avec BMad ?"
 
-**R :** Utilisez le workflow Quick Dev : Lancez `bmad-quick-dev` — il clarifie votre intention, planifie, implémente, révise et présente les résultats dans un seul workflow, en sautant les phases de planification complètes.
+**R :** Utilisez le flux rapide : Lancez `bmad-quick-dev` — il clarifie votre intention, planifie, implémente, révise et présente les résultats dans un seul workflow, en sautant les phases de planification complètes.
 :::
 
-## Ce que vous obtenez
+**Conseils pour de meilleures réponses :**
 
-Des réponses directes sur BMad — comment fonctionnent les agents, ce que font les workflows, pourquoi les choses sont structurées ainsi — sans attendre la réponse de quelqu'un.
-
-## Conseils
-
-- **Vérifiez les réponses surprenantes** — Les LLM font parfois des erreurs. Consultez le fichier source ou posez la question sur Discord.
 - **Soyez précis** — "Que fait l'étape 3 du workflow PRD ?" est mieux que "Comment fonctionne le PRD ?"
+- **Vérifiez les affirmations surprenantes** — Les LLM font parfois des erreurs. Consultez le fichier source ou posez la question sur Discord.
 
-## Toujours bloqué ?
+### Vous n'utilisez pas d'agent ? Utilisez le site de documentation
 
-Avez-vous essayé l'approche LLM et avez encore besoin d'aide ? Vous avez maintenant une bien meilleure question à poser.
+Si votre IA ne peut pas lire des fichiers locaux (ChatGPT, Claude.ai, etc.), importez [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) dans votre session — c'est un instantané en un seul fichier de la documentation BMad.
+
+## 3. Demandez à quelqu'un
+
+Si ni BMad-Help ni la source n'ont répondu à votre question, vous avez maintenant une bien meilleure question à poser.
 
 | Canal                   | Utilisé pour                                     |
 | ------------------------- | ------------------------------------------- |
-| `#bmad-method-help`       | Questions rapides (chat en temps réel)            |
-| Forum `help-requests`     | Questions détaillées (recherchables, persistants) |
+| Forum `help-requests`     | Questions                                   |
 | `#suggestions-feedback`   | Idées et demandes de fonctionnalités                  |
-| `#report-bugs-and-issues` | Rapports de bugs                                 |
 
 **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) (pour les bugs clairs)
-
+**GitHub Issues :** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
 *Toi !*
         *Bloqué*
              *dans la file d'attente—*

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

@@ -72,7 +72,7 @@ L'installateur affiche les modules disponibles. Sélectionnez ceux dont vous ave
 
 ### 5. Suivre les instructions
 
-L'installateur vous guide pour le reste — contenu personnalisé, paramètres, etc.
+L'installateur vous guide pour le reste — paramètres, intégrations d'outils, etc.
 
 ## Ce que vous obtenez
 

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

@@ -27,7 +27,6 @@ Nécessite [Node.js](https://nodejs.org) v20+ et `npx` (inclus avec npm).
 | `--directory <chemin>` | Répertoire d'installation | `--directory ~/projects/myapp` |
 | `--modules <modules>` | IDs de modules séparés par des virgules | `--modules bmm,bmb` |
 | `--tools <outils>` | IDs d'outils/IDE séparés par des virgules (utilisez `none` pour ignorer) | `--tools claude-code,cursor` ou `--tools none` |
-| `--custom-content <chemins>` | Chemins vers des modules personnalisés séparés par des virgules | `--custom-content ~/my-module,~/another-module` |
 | `--action <type>` | Action pour les installations existantes : `install` (par défaut), `update`, ou `quick-update` | `--action quick-update` |
 
 ### Configuration principale
@@ -37,7 +36,19 @@ Nécessite [Node.js](https://nodejs.org) v20+ et `npx` (inclus avec npm).
 | `--user-name <nom>` | Nom à utiliser par les agents | Nom d'utilisateur système |
 | `--communication-language <langue>` | Langue de communication des agents | Anglais |
 | `--document-output-language <langue>` | Langue de sortie des documents | Anglais |
-| `--output-folder <chemin>` | Chemin du dossier de sortie | _bmad-output |
+| `--output-folder <chemin>` | Chemin du dossier de sortie (voir les règles de résolution ci-dessous) | `_bmad-output` |
+
+#### Résolution du chemin du dossier de sortie
+
+La valeur passée à `--output-folder` (ou saisie de manière interactive) est résolue selon ces règles :
+
+| Type d'entrée                 | Exemple                    | Résolu comme                                                 |
+|-------------------------------|----------------------------|--------------------------------------------------------------|
+| Chemin relatif (par défaut)   | `_bmad-output`             | `<racine-du-projet>/_bmad-output`                            |
+| Chemin relatif avec traversée | `../../shared-outputs`     | Chemin absolu normalisé — ex. `/Users/me/shared-outputs`     |
+| Chemin absolu                 | `/Users/me/shared-outputs` | Utilisé tel quel — la racine du projet n'est **pas** ajoutée |
+
+Le chemin résolu est ce que les agents et les workflows vont utiliser lors de l'écriture des fichiers de sortie. L'utilisation d'un chemin absolu ou d'un chemin relatif avec traversée vous permet de diriger tous les artefacts générés vers un répertoire en dehors de l'arborescence de votre projet — utile pour les configurations partagées ou les monorepos.
 
 ### Autres options
 
@@ -61,7 +72,7 @@ IDs d'outils disponibles pour l’option `--tools` :
 
 **Recommandés :** `claude-code`, `cursor`
 
-Exécutez `npx bmad-method install` de manière interactive une fois pour voir la liste complète actuelle des outils pris en charge, ou consultez la [configuration des codes de la plateforme](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/cli/installers/lib/ide/platform-codes.yaml).
+Exécutez `npx bmad-method install` de manière interactive une fois pour voir la liste complète actuelle des outils pris en charge, ou consultez la [configuration des codes de la plateforme](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml).
 
 ## Modes d'installation
 
@@ -108,16 +119,6 @@ npx bmad-method install \
   --action quick-update
 ```
 
-### Installation avec du contenu personnalisé
-
-```bash
-npx bmad-method install \
-  --directory ~/projects/myapp \
-  --modules bmm \
-  --custom-content ~/my-custom-module,~/another-module \
-  --tools claude-code
-```
-
 ## Ce que vous obtenez
 
 - Un répertoire `_bmad/` entièrement configuré dans votre projet
@@ -131,16 +132,16 @@ BMad valide toutes les options fournis :
 - **Directory** — Doit être un chemin valide avec des permissions d'écriture
 - **Modules** — Avertit des IDs de modules invalides (mais n'échoue pas)
 - **Tools** — Avertit des IDs d'outils invalides (mais n'échoue pas)
-- **Custom Content** — Chaque chemin doit contenir un fichier `module.yaml` valide
 - **Action** — Doit être l'une des suivantes : `install`, `update`, `quick-update`
 
 Les valeurs invalides entraîneront soit :
 1. L’affichage d’un message d'erreur suivi d’un exit (pour les options critiques comme le répertoire)
-2. Un avertissement puis la continuation de l’installation (pour les éléments optionnels comme le contenu personnalisé)
+2. Un avertissement puis la continuation de l’installation (pour les éléments optionnels)
 3. Un retour aux invites interactives (pour les valeurs requises manquantes)
 
 :::tip[Bonnes pratiques]
 - Utilisez des chemins absolus pour `--directory` pour éviter toute ambiguïté
+- Utilisez un chemin absolu pour `--output-folder` lorsque vous souhaitez que les artefacts soient écrits en dehors de l'arborescence du projet (ex. un répertoire de sorties partagé dans un monorepo)
 - Testez les options localement avant de les utiliser dans des pipelines CI/CD
 - Combinez avec `-y` pour des installations vraiment sans surveillance
 - Utilisez `--debug` si vous rencontrez des problèmes lors de l'installation
@@ -159,13 +160,6 @@ Les valeurs invalides entraîneront soit :
 - Vérifiez que l'ID du module est correct
 - Les modules externes doivent être disponibles dans le registre
 
-### Chemin de contenu personnalisé invalide
-
-Assurez-vous que chaque chemin de contenu personnalisé :
-- Pointe vers un répertoire
-- Contient un fichier `module.yaml` à la racine
-- Possède un champ `code` dans `module.yaml`
-
 :::note[Toujours bloqué ?]
 Exécutez avec `--debug` pour une sortie détaillée, essayez le mode interactif pour isoler le problème, ou signalez-le à <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
 :::

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

@@ -61,8 +61,8 @@ Si vous avez des stories[^3] créées ou implémentées :
 
 1. Terminez l'installation v6
 2. Placez `epics.md` ou `epics/epic*.md`[^2] dans `_bmad-output/planning-artifacts/`
-3. Lancez le workflow `bmad-sprint-planning`[^4]
-4. Indiquez quels epics/stories sont déjà terminés
+3. Lancez le workflow Développeur `bmad-sprint-planning`[^4]
+4. Indiquez à l’agent quels epics/stories sont déjà terminés
 
 ## Ce que vous obtenez
 

docs/fr/reference/agents.md

@@ -1,24 +1,26 @@
 ---
 title: Agents
-description: Agents BMM par défaut avec leurs identifiants de skill, déclencheurs de menu et workflows principaux (Analyst, Architect, UX Designer, Technical Writer)
+description: Agents BMM par défaut avec leurs identifiants de skill, déclencheurs de menu et workflows principaux
 sidebar:
   order: 2
 ---
 
 ## Agents par défaut
 
-Cette page liste les quatre agents BMM (suite Agile) par défaut installés avec la méthode BMad, ainsi que leurs identifiants de skill, déclencheurs de menu et workflows principaux. Chaque agent est invoqué en tant que skill.
+Cette page liste les agents BMM (suite Agile) par défaut installés avec la méthode BMad, ainsi que leurs identifiants de skill, déclencheurs de menu et workflows principaux. Chaque agent est invoqué en tant que skill.
 
 ## Notes
 
-- Chaque agent est disponible en tant que skill, généré par l’installateur. L’identifiant de skill (par exemple, `bmad-analyst`) est utilisé pour invoquer l’agent.
+- Chaque agent est disponible en tant que skill, généré par l’installateur. L’identifiant de skill (par exemple, `bmad-dev`) est utilisé pour invoquer l’agent.
 - Les déclencheurs sont les codes courts de menu (par exemple, `BP`) et les correspondances approximatives affichés dans chaque menu d’agent.
-- La génération de tests QA est gérée par le skill de workflow `bmad-qa-generate-e2e-tests`. L’architecte de tests complet (TEA) se trouve dans son propre module.
+- La génération de tests QA est gérée par le skill de workflow `bmad-qa-generate-e2e-tests`, disponible par l’agent Développeur. L’architecte de tests complet (TEA) se trouve dans son propre module.
 
 | Agent                       | Identifiant de skill | Déclencheurs                             | Workflows principaux                                                                                                                                           |
-|------------------------|----------------------|------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Analyste (Mary)        | `bmad-analyst`       | `BP`, `MR`, `DR`, `TR`, `CB`, `DP` | Brainstorming du projet, Recherche marché/domaine/technique, Création du brief[^1], Documentation du projet                                                    |
+|-----------------------------|----------------------|------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Analyste (Mary)             | `bmad-analyst`       | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorming du projet, Recherche marché/domaine/technique, Création du brief[^1], Défi PRFAQ, Documentation du projet                                        |
+| Product Manager (John)      | `bmad-pm`            | `CP`, `VP`, `EP`, `CE`, `IR`, `CC`       | Créer/Valider/Éditer un PRD, Créer des Epics et Stories, vérifier l’état de préparation à l’Implémentation, Corriger le Cours                                 |
 | Architecte (Winston)        | `bmad-architect`     | `CA`, `IR`                               | Créer l’architecture, Préparation à l’implémentation                                                                                                           |
+| Développeur (Amelia)        | `bmad-agent-dev`     | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | Dev Story, Quick Dev, Génération de Tests QA, Code Review, Sprint Planning, Créer Story, Rétrospective d’Epic                                                  |
 | Designer UX (Sally)         | `bmad-ux-designer`   | `CU`                                     | Création du design UX[^2]                                                                                                                                      |
 | Rédacteur Technique (Paige) | `bmad-tech-writer`   | `DP`, `WD`, `US`, `MG`, `VD`, `EC`       | Documentation du projet, Rédaction de documents, Mise à jour des standards, Génération de diagrammes Mermaid, Validation de documents, Explication de concepts |
 
@@ -30,7 +32,7 @@ Les déclencheurs de menu d'agent utilisent deux types d'invocation différents.
 
 La plupart des déclencheurs chargent un fichier de workflow structuré. Tapez le code du déclencheur et l'agent démarre le workflow, vous demandant de saisir les informations à chaque étape.
 
-Exemples : `BP` (Brainstorm Project), `CA` (Create Architecture), `CU` (Create UX Design)
+Exemples : `CP` (Create PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
 
 ### Déclencheurs conversationnels (arguments requis)
 

docs/fr/reference/commands.md

@@ -2,7 +2,7 @@
 title: Skills
 description: Référence des skills BMad — ce qu'ils sont, comment ils fonctionnent et où les trouver.
 sidebar:
-  order: 3
+  order: 4
 ---
 
 Les skills sont des prompts pré-construits qui chargent des agents, exécutent des workflows ou lancent des tâches dans votre IDE. L'installateur BMad les génère à partir de vos modules installés au moment de l'installation. Si vous ajoutez, supprimez ou modifiez des modules ultérieurement, relancez l'installateur pour garder les skills synchronisés (voir [Dépannage](#dépannage)).
@@ -54,12 +54,12 @@ Chaque skill est un répertoire contenant un fichier `SKILL.md`. Par exemple, un
 │   └── SKILL.md
 ├── bmad-create-prd/
 │   └── SKILL.md
-├── bmad-analyst/
+├── bmad-agent-dev/
 │   └── SKILL.md
 └── ...
 ```
 
-Le nom du répertoire détermine le nom du skill dans votre IDE. Par exemple, le répertoire `bmad-analyst/` enregistre le skill `bmad-analyst`.
+Le nom du répertoire détermine le nom du skill dans votre IDE. Par exemple, le répertoire `bmad-agent-dev/` enregistre le skill `bmad-agent-dev`.
 
 ## Comment découvrir vos skills
 
@@ -75,23 +75,24 @@ Les répertoires de skills générés dans votre projet sont la liste de référ
 
 ### Skills d'agent
 
-Les skills d'agent chargent une persona[^2] IA spécialisée avec un rôle défini, un style de communication et un menu de workflows. Une fois chargé, l'agent reste en caractère et répond aux déclencheurs du menu.
+Les skills d'agent chargent un persona[^2] IA spécialisé avec un rôle défini, un style de communication et un menu de workflows. Une fois chargé, l'agent reste en caractère et répond aux déclencheurs du menu.
 
 | Exemple de skill | Agent                  | Rôle                                                        |
-| --- | --- | --- |
-| `bmad-analyst` | Mary (Analyste) | Brainstorming de projets, recherche, création de briefs |
+|------------------|------------------------|-------------------------------------------------------------|
+| `bmad-agent-dev` | Amelia (Développeur)   | Implémente les stories avec une adhérence stricte aux specs |
+| `bmad-pm`        | John (Product Manager) | Crée et valide les PRDs[^1]                                 |
 | `bmad-architect` | Winston (Architecte)   | Conçoit l'architecture système                              |
-| `bmad-ux-designer` | Sally (Designer UX) | Crée les designs UX |
-| `bmad-tech-writer` | Paige (Rédacteur Technique) | Documente les projets, rédige des guides, génère des diagrammes |
 
 Consultez [Agents](./agents.md) pour la liste complète des agents par défaut et leurs déclencheurs.
 
 ### Skills de workflow
 
-Les skills de workflow exécutent un processus structuré en plusieurs étapes sans charger d'abord une persona d'agent. Ils chargent une configuration de workflow et suivent ses étapes.
+Les skills de workflow exécutent un processus structuré en plusieurs étapes sans charger d'abord un persona d'agent. Ils chargent une configuration de workflow et suivent ses étapes.
 
 | Exemple de skill | Objectif |
 | --- | --- |
+| `bmad-product-brief` | Créer un product brief[^3] — découverte guidée lorsque votre concept est clair |
+| `bmad-prfaq` | Défi [PRFAQ Working Backwards](../explanation/analysis-phase.md#prfaq-working-backwards) pour éprouver votre concept produit |
 | `bmad-create-prd` | Créer un PRD[^1] |
 | `bmad-create-architecture` | Concevoir l'architecture système |
 | `bmad-create-epics-and-stories` | Créer des epics et des stories |
@@ -123,7 +124,7 @@ Le module principal inclut 11 outils intégrés — revues, compression, brainst
 
 ## Convention de nommage
 
-Tous les skills utilisent le préfixe `bmad-` suivi d'un nom descriptif (ex. `bmad-analyst`, `bmad-create-prd`, `bmad-help`). Consultez [Modules](./modules.md) pour les modules disponibles.
+Tous les skills utilisent le préfixe `bmad-` suivi d'un nom descriptif (ex. `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`). Consultez [Modules](./modules.md) pour les modules disponibles.
 
 ## Dépannage
 
@@ -136,4 +137,5 @@ Tous les skills utilisent le préfixe `bmad-` suivi d'un nom descriptif (ex. `bm
 ## Glossaire
 
 [^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
-[^2]: Persona : dans le contexte de BMad, une persona désigne un agent IA avec un rôle défini, un style de communication et une expertise spécifiques (ex. Mary l'analyste, Winston l'architecte). Chaque persona garde son "caractère" pendant les interactions.
+[^2]: Persona : dans le contexte de BMad, un persona désigne un agent IA avec un rôle défini, un style de communication et une expertise spécifiques (ex. Mary l'analyste, Winston l'architecte). Chaque persona garde son "caractère" pendant les interactions.
+[^3]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d'un projet ou d'une demande, afin d'aligner rapidement les parties prenantes avant le travail détaillé.

docs/fr/reference/core-tools.md

@@ -2,7 +2,7 @@
 title: Outils Principaux
 description: Référence pour toutes les tâches et tous les workflows intégrés disponibles dans chaque installation BMad sans modules supplémentaires.
 sidebar:
-  order: 2
+  order: 3
 ---
 
 Chaque installation BMad comprend un ensemble de compétences principales qui peuvent être utilisées conjointement avec tout ce que vous faites — des tâches et des workflows autonomes qui fonctionnent dans tous les projets, tous les modules et toutes les phases. Ceux-ci sont toujours disponibles, quels que soient les modules optionnels que vous installez.

docs/fr/reference/modules.md

@@ -2,7 +2,7 @@
 title: Modules Officiels
 description: Modules additionnels pour créer des agents personnalisés, de l'intelligence créative, du développement de jeux et des tests
 sidebar:
-  order: 4
+  order: 5
 ---
 
 BMad s'étend via des modules officiels que vous sélectionnez lors de l'installation. Ces modules additionnels fournissent des agents, des workflows et des tâches spécialisés pour des domaines spécifiques, au-delà du noyau intégré et de BMM (suite Agile).

docs/fr/reference/testing.md

@@ -2,7 +2,7 @@
 title: Options de Testing
 description: Comparaison du workflow QA intégré avec le module Test Architect (TEA) pour l'automatisation des tests.
 sidebar:
-  order: 5
+  order: 6
 ---
 
 BMad propose deux approches de test : un workflow QA[^1] intégré pour une génération rapide de tests et un module Test Architect installable pour une stratégie de test de qualité entreprise.
@@ -24,9 +24,9 @@ La plupart des projets devraient commencer avec le workflow QA intégré. Si vou
 
 ## Workflow QA Intégré
 
-Le workflow QA intégré est inclus dans le module BMM (suite Agile). Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
+Le workflow QA intégré (`bmad-qa-generate-e2e-tests`) fait partie du module BMM (suite Agile), disponible via l'agent Developer. Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
 
-**Déclencheur :** `QA` ou `bmad-qa-generate-e2e-tests`
+**Déclencheur :** `QA` (via l'agent Developer) ou `bmad-qa-generate-e2e-tests`
 
 ### Ce que le Workflow QA Fait
 
@@ -98,7 +98,7 @@ TEA supporte également la priorisation basée sur les risques P0-P3 et des int
 Le workflow Automate du QA intégré apparaît dans la Phase 4 (Implémentation) de la carte de workflow méthode BMad. Il est conçu pour s'exécuter **après qu'un epic complet soit terminé** — une fois que toutes les stories d'un epic ont été implémentées et revues. Une séquence typique :
 
 1. Pour chaque story de l'epic : implémenter avec Dev Story (`DS`), puis valider avec Code Review (`CR`)
-2. Après la fin de l'epic : générer les tests avec le workflow QA (`QA`) ou le workflow Automate de TEA
+2. Après la fin de l'epic : générer les tests avec `QA` (via l'agent Developer) ou le workflow Automate de TEA
 3. Lancer la rétrospective (`bmad-retrospective`) pour capturer les leçons apprises
 
 Le workflow QA travaille directement à partir du code source sans charger les documents de planification (PRD, architecture). Les workflows TEA peuvent s'intégrer avec les artefacts de planification en amont pour la traçabilité.

docs/fr/reference/workflow-map.md

@@ -21,13 +21,14 @@ Note finale importante : Chaque workflow ci-dessous peut être exécuté directe
 
 ## Phase 1 : Analyse (Optionnelle)
 
-Explorez l’espace problème et validez les idées avant de vous engager dans la planification.
+Explorez l’espace problème et validez les idées avant de vous engager dans la planification. [**Découvrez ce que fait chaque outil et quand l’utiliser**](../explanation/analysis-phase.md).
 
 | Workflow                                                                  | Objectif                                                                                 | Produit                   |
 |---------------------------------------------------------------------------|------------------------------------------------------------------------------------------|---------------------------|
-| `bmad-brainstorming`                                                      | Brainstormez des idées de projet avec l'accompagnement guidé d'un coach de brainstorming | `brainstorming-report.md` |
+| `bmad-brainstorming`                                                      | Brainstormez des idées de projet avec l’accompagnement guidé d’un coach de brainstorming | `brainstorming-report.md` |
 | `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validez les hypothèses de marché, techniques ou de domaine                               | Rapport de recherches     |
-| `bmad-create-product-brief`                                               | Capturez la vision stratégique                                                           | `product-brief.md`        |
+| `bmad-product-brief`                                                      | Capturez la vision stratégique — idéal lorsque votre concept est clair                   | `product-brief.md`        |
+| `bmad-prfaq`                                                              | Working Backwards — éprouvez et forgez votre concept produit                             | `prfaq-{project}.md`       |
 
 ## Phase 2 : Planification
 

docs/fr/tutorials/getting-started.md

@@ -68,7 +68,7 @@ BMad vous aide à construire des logiciels grâce à des workflows guidés avec
 
 | Phase | Nom            | Ce qui se passe                                                |
 |-------|----------------|----------------------------------------------------------------|
-| 1     | Analyse        | Brainstorming, recherche, product brief *(optionnel)*          |
+| 1     | Analyse        | Brainstorming, recherche, product brief ou PRFAQ *(optionnel)*          |
 | 2     | Planification  | Créer les exigences (PRD[^1] ou spécification technique)       |
 | 3     | Solutioning    | Concevoir l'architecture *(BMad Method/Enterprise uniquement)* |
 | 4     | Implémentation | Construire epic[^2] par epic, story[^3] par story              |
@@ -114,7 +114,7 @@ BMad-Help détectera ce que vous avez accompli et recommandera exactement quoi f
 :::
 
 :::note[Comment charger les agents et exécuter les workflows]
-Chaque workflow possède une **skill** que vous invoquez par nom dans votre IDE (par ex., `bmad-create-prd`). Votre outil IA reconnaîtra le nom `bmad-*` et l'exécutera.
+Chaque workflow possède une **skill** que vous invoquez par nom dans votre IDE (par ex., `bmad-create-prd`). Votre outil IA reconnaîtra le nom `bmad-*` et l'exécutera — vous n'avez pas besoin de charger les agents séparément. Vous pouvez aussi invoquer directement une skill d'agent pour une conversation générale (par ex., `bmad-agent-pm` pour l'agent PM).
 :::
 
 :::caution[Nouveaux chats]
@@ -133,29 +133,32 @@ Créez-le manuellement dans `_bmad-output/project-context.md` ou générez-le ap
 
 ### Phase 1 : Analyse (Optionnel)
 
-Tous les workflows de cette phase sont optionnels :
+Tous les workflows de cette phase sont optionnels. [**Pas sûr de quel outil utiliser ?**](../explanation/analysis-phase.md)
 - **brainstorming** (`bmad-brainstorming`) — Idéation guidée
 - **research** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Recherche marché, domaine et technique
-- **create-product-brief** (`bmad-create-product-brief`) — Document de base recommandé
+- **product-brief** (`bmad-product-brief`) — Document de base recommandé lorsque votre concept est clair
+- **prfaq** (`bmad-prfaq`) — Défi Working Backwards pour éprouver et forger votre concept produit
 
 ### Phase 2 : Planification (Requis)
 
 **Pour les voies BMad Method et Enterprise :**
-1. Exécutez `bmad-create-prd` dans un nouveau chat
-2. Sortie : `PRD.md`
+1. Invoquez l'**agent PM** (`bmad-agent-pm`) dans un nouveau chat
+2. Exécutez le workflow `bmad-create-prd` (`bmad-create-prd`)
+3. Sortie : `PRD.md`
 
 **Pour la voie Quick Dev :**
-- Utilisez le workflow `bmad-quick-dev` (`bmad-quick-dev`) à la place du PRD, puis passez à l'implémentation
+- Exécutez `bmad-quick-dev` — il gère la planification et l'implémentation dans un seul workflow, passez directement à l'implémentation
 
 :::note[Design UX (Optionnel)]
-Si votre projet a une interface utilisateur, exécutez le workflow de design UX (`bmad-create-ux-design`) après avoir créé votre PRD.
+Si votre projet a une interface utilisateur, invoquez l'**agent Designer UX** (`bmad-agent-ux-designer`) et exécutez le workflow de design UX (`bmad-create-ux-design`) après avoir créé votre PRD.
 :::
 
 ### Phase 3 : Solutioning (méthode BMad/Enterprise)
 
 **Créer l'Architecture**
-1. Exécutez `bmad-create-architecture` dans un nouveau chat
-2. Sortie : Document d'architecture avec les décisions techniques
+1. Invoquez l'**agent Architecte** (`bmad-agent-architect`) dans un nouveau chat
+2. Exécutez `bmad-create-architecture` (`bmad-create-architecture`)
+3. Sortie : Document d'architecture avec les décisions techniques
 
 **Créer les Epics et Stories**
 
@@ -163,12 +166,14 @@ Si votre projet a une interface utilisateur, exécutez le workflow de design UX
 Les epics et stories sont maintenant créés *après* l'architecture. Cela produit des stories de meilleure qualité car les décisions d'architecture (base de données, patterns d'API, pile technologique) affectent directement la façon dont le travail doit être décomposé.
 :::
 
-1. Exécutez `bmad-create-epics-and-stories` dans un nouveau chat
-2. Le workflow utilise à la fois le PRD et l'Architecture pour créer des stories techniquement éclairées
+1. Invoquez l'**agent PM** (`bmad-agent-pm`) dans un nouveau chat
+2. Exécutez `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
+3. Le workflow utilise à la fois le PRD et l'Architecture pour créer des stories techniquement éclairées
 
 **Vérification de préparation à l'implémentation** *(Hautement recommandé)*
-1. Exécutez `bmad-check-implementation-readiness` dans un nouveau chat
-2. Valide la cohérence entre tous les documents de planification
+1. Invoquez l'**agent Architecte** (`bmad-agent-architect`) dans un nouveau chat
+2. Exécutez `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
+3. Valide la cohérence entre tous les documents de planification
 
 ## Étape 2 : Construire votre projet
 
@@ -176,19 +181,19 @@ Une fois la planification terminée, passez à l'implémentation. **Chaque workf
 
 ### Initialiser la planification de sprint
 
-Exécutez `bmad-sprint-planning` dans un nouveau chat. Cela crée `sprint-status.yaml` pour suivre tous les epics et stories.
+Invoquez **l’agent Développeur** (`bmad-agent-dev`) et lancez `bmad-sprint-planning`. Cela crée `sprint-status.yaml` pour suivre tous les epics et stories.
 
 ### Le cycle de construction
 
 Pour chaque story, répétez ce cycle avec de nouveaux chats :
 
-| Étape | Workflow              | Commande               | Objectif                            |
-| ----- | --------------------- | --------------------- | ----------------------------------- |
-| 1     | `bmad-create-story`   | `bmad-create-story`   | Créer le fichier story depuis l'epic |
-| 2     | `bmad-dev-story`      | `bmad-dev-story`      | Implémenter la story                |
-| 3     | `bmad-code-review`    | `bmad-code-review`    | Validation de qualité *(recommandé)* |
+| Étape | AGENT | Workflow            | Commande            | Objectif                             |
+|-------|-------|---------------------|---------------------|--------------------------------------|
+| 1     | DEV   | `bmad-create-story` | `bmad-create-story` | Créer le fichier story depuis l'epic |
+| 2     | DEV   | `bmad-dev-story`    | `bmad-dev-story`    | Implémenter la story                 |
+| 3     | DEV   | `bmad-code-review`  | `bmad-code-review`  | Validation de qualité *(recommandé)* |
 
-Après avoir terminé toutes les stories d'un epic, exécutez `bmad-retrospective` dans un nouveau chat.
+Après avoir terminé toutes les stories d'un epic, invoquez **l’agent Développeur** (`bmad-agent-dev`), et exécutez `bmad-retrospective`.
 
 ## Ce que vous avez accompli
 
@@ -217,18 +222,18 @@ your-project/
 
 ## Référence rapide
 
-| Workflow                              | Commande                                    | Objectif                                         |
-| ------------------------------------- | ------------------------------------------- | ------------------------------------------------ |
-| **`bmad-help`** ⭐                    | `bmad-help`                               | **Votre guide intelligent — posez n'importe quelle question !**      |
-| `bmad-create-prd`                     | `bmad-create-prd`                     | Créer le document d'exigences produit            |
-| `bmad-create-architecture`            | `bmad-create-architecture`            | Créer le document d'architecture                     |
-| `bmad-generate-project-context`       | `bmad-generate-project-context`       | Créer le fichier de contexte projet                     |
-| `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`       | Décomposer le PRD en epics                       |
-| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Valider la cohérence de planification                      |
-| `bmad-sprint-planning`               | `bmad-sprint-planning`                | Initialiser le suivi de sprint                      |
-| `bmad-create-story`                   | `bmad-create-story`                   | Créer un fichier story                             |
-| `bmad-dev-story`                      | `bmad-dev-story`                      | Implémenter une story                               |
-| `bmad-code-review`                    | `bmad-code-review`                    | Revoir le code implémenté                         |
+| Workflow                              | Commande                              | Agent     | Objectif                                                        |
+|---------------------------------------|---------------------------------------|-----------|-----------------------------------------------------------------|
+| **`bmad-help`** ⭐                    | `bmad-help`                           | Tous      | **Votre guide intelligent — posez n'importe quelle question !** |
+| `bmad-create-prd`                     | `bmad-create-prd`                     | PM        | Créer le document d'exigences produit                           |
+| `bmad-create-architecture`            | `bmad-create-architecture`            | Architect | Créer le document d'architecture                                |
+| `bmad-generate-project-context`       | `bmad-generate-project-context`       | Analyst   | Créer le fichier de contexte projet                             |
+| `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`       | PM        | Décomposer le PRD en epics                                      |
+| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Valider la cohérence de planification                           |
+| `bmad-sprint-planning`                | `bmad-sprint-planning`                | DEV       | Initialiser le suivi de sprint                                  |
+| `bmad-create-story`                   | `bmad-create-story`                   | DEV       | Créer un fichier story                                          |
+| `bmad-dev-story`                      | `bmad-dev-story`                      | DEV       | Implémenter une story                                           |
+| `bmad-code-review`                    | `bmad-code-review`                    | DEV       | Revoir le code implémenté                                       |
 
 ## Questions fréquentes
 
@@ -236,7 +241,7 @@ your-project/
 Uniquement pour les voies méthode BMad et Enterprise. Quick Dev passe directement de la spécification technique (spec) à l'implémentation.
 
 **Puis-je modifier mon plan plus tard ?**
-Oui. Utilisez `bmad-correct-course` pour gérer les changements de périmètre.
+Oui. Utilisez `bmad-correct-course` pour gérer les changements de périmètre en cours d’implémentation.
 
 **Et si je veux d'abord faire du brainstorming ?**
 Invoquez l'agent Analyst (`bmad-agent-analyst`) et exécutez `bmad-brainstorming` (`bmad-brainstorming`) avant de commencer votre PRD.

docs/how-to/customize-bmad.md

@@ -1,171 +1,395 @@
 ---
-title: "How to Customize BMad"
-description: Customize agents, workflows, and modules while preserving update compatibility
+title: 'How to Customize BMad'
+description: Customize agents and workflows while preserving update compatibility
 sidebar:
-  order: 7
+  order: 8
 ---
 
-Use the `.customize.yaml` files to tailor agent behavior, personas, and menus while preserving your changes across updates.
+Tailor agent personas, inject domain context, add capabilities, and configure workflow behavior -- all without modifying installed files. Your customizations survive every update.
+
+:::tip[Don't want to hand-author TOML? Use `bmad-customize`]
+The `bmad-customize` skill is a guided authoring helper for the **per-skill agent/workflow override surface** described in this doc. It scans what's customizable in your installation, helps you choose the right surface (agent vs workflow) for your intent, writes the override file for you, and verifies the merge landed. Central-config overrides (`_bmad/custom/config.toml`) are out of scope for v1 — hand-author those per the Central Configuration section below. Run the skill whenever you want to make a per-skill change; this doc is the reference for *what* each surface exposes and how merging works.
+:::
 
 ## When to Use This
 
-- You want to change an agent's name, personality, or communication style
-- You need agents to remember project-specific context
-- You want to add custom menu items that trigger your own workflows or prompts
-- You want agents to perform specific actions every time they start up
+- You want to change an agent's personality or communication style
+- You need to give an agent persistent facts to recall (e.g. "our org is AWS-only")
+- You want to add procedural startup steps the agent must run every session
+- You want to add custom menu items that trigger your own skills or prompts
+- Your team needs shared customizations committed to git, with personal preferences layered on top
 
 :::note[Prerequisites]
+
 - BMad installed in your project (see [How to Install BMad](./install-bmad.md))
-- A text editor for YAML files
+- Python 3.11+ on your PATH (for the resolver script -- uses stdlib `tomllib`, no `pip install`, no `uv`, no virtualenv)
+- A text editor for TOML files
 :::
 
-:::caution[Keep Your Customizations Safe]
-Always use the `.customize.yaml` files described here rather than editing agent files directly. The installer overwrites agent files during updates, but preserves your `.customize.yaml` changes.
-:::
+## How It Works
+
+Every customizable skill ships a `customize.toml` file with its defaults. This file defines the skill's complete customization surface -- read it to see what's customizable. You never edit this file. Instead, you create sparse override files containing only the fields you want to change.
+
+### Three-Layer Override Model
+
+```text
+Priority 1 (wins): _bmad/custom/{skill-name}.user.toml  (personal, gitignored)
+Priority 2:        _bmad/custom/{skill-name}.toml        (team/org, committed)
+Priority 3 (last): skill's own customize.toml                    (defaults)
+```
+
+The `_bmad/custom/` folder starts empty. Files only appear when someone actively customizes.
+
+### Merge Rules (by shape, not by field name)
+
+The resolver applies four structural rules. Field names are never special-cased — behavior is determined purely by the value's shape:
+
+| Shape | Rule |
+|---|---|
+| Scalar (string, int, bool, float) | Override wins |
+| Table | Deep merge (recursively apply these rules) |
+| Array of tables where every item shares the **same** identifier field (every item has `code`, or every item has `id`) | Merge by that key — matching keys **replace in place**, new keys **append** |
+| Any other array (scalars; tables with no identifier; arrays that mix `code` and `id` across items) | **Append** — base items first, then team items, then user items |
+
+**No removal mechanism.** Overrides cannot delete base items. If you need to suppress a default menu item, override it by `code` with a no-op description or prompt. If you need to restructure an array more deeply, fork the skill.
+
+**The `code` / `id` convention.** BMad uses `code` (short identifier like `"BP"` or `"R1"`) and `id` (longer stable identifier) as merge keys on arrays of tables. If you author a custom array-of-tables that should be replaceable-by-key rather than append-only, pick **one** convention (either `code` on every item, or `id` on every item) and stick with it across the whole array. Mixing `code` on some items and `id` on others falls back to append — the resolver won't guess which key to merge on.
+
+### Some agent fields are read-only
+
+`agent.name` and `agent.title` live in `customize.toml` as source-of-truth metadata, but the agent's SKILL.md doesn't read them at runtime — they're hardcoded identity. Putting `name = "Bob"` in an override file has no effect. If you genuinely need a different-named agent, copy the skill folder, rename it, and ship it as a custom skill.
 
 ## Steps
 
-### 1. Locate Customization Files
+### 1. Find the Skill's Customization Surface
 
-After installation, find one `.customize.yaml` file per agent in:
+Look at the skill's `customize.toml` in its installed directory. For example, the PM agent:
 
 ```text
-_bmad/_config/agents/
-├── core-bmad-master.customize.yaml
-├── bmm-dev.customize.yaml
-├── bmm-pm.customize.yaml
-└── ... (one file per installed agent)
+.claude/skills/bmad-agent-pm/customize.toml
 ```
 
-### 2. Edit the Customization File
+(Path varies by IDE -- Cursor uses `.cursor/skills/`, Cline uses `.cline/skills/`, and so on.)
 
-Open the `.customize.yaml` file for the agent you want to modify. Every section is optional -- customize only what you need.
+This file is the canonical schema. Every field you see is customizable (excluding the read-only identity fields noted above).
 
-| Section            | Behavior | Purpose                                         |
-| ------------------ | -------- | ----------------------------------------------- |
-| `agent.metadata`   | Replaces | Override the agent's display name               |
-| `persona`          | Replaces | Set role, identity, style, and principles       |
-| `memories`         | Appends  | Add persistent context the agent always recalls |
-| `menu`             | Appends  | Add custom menu items for workflows or prompts  |
-| `critical_actions` | Appends  | Define startup instructions for the agent       |
-| `prompts`          | Appends  | Create reusable prompts for menu actions        |
+### 2. Create Your Override File
 
-Sections marked **Replaces** overwrite the agent's defaults entirely. Sections marked **Appends** add to the existing configuration.
+Create the `_bmad/custom/` directory in your project root if it doesn't exist. Then create a file named after the skill:
 
-**Agent Name**
-
-Change how the agent introduces itself:
-
-```yaml
-agent:
-  metadata:
-    name: 'Spongebob' # Default: "Amelia"
+```text
+_bmad/custom/
+  bmad-agent-pm.toml        # team overrides (committed to git)
+  bmad-agent-pm.user.toml   # personal preferences (gitignored)
 ```
 
-**Persona**
+:::caution[Do NOT copy the whole `customize.toml`]
+Override files are **sparse**. Include only the fields you're changing — nothing else. Every field you omit is inherited automatically from the layer below (team from defaults, user from team-or-defaults).
 
-Replace the agent's personality, role, and communication style:
+Copying the full `customize.toml` into an override is actively harmful: the next update ships new defaults, but your override file locks in the old values. You'll silently drift out of sync with every release.
+:::
 
-```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'
+**Example — changing the icon and adding one principle**:
+
+```toml
+# _bmad/custom/bmad-agent-pm.toml
+# Just the fields I'm changing. Everything else inherits.
+
+[agent]
+icon = "🏥"
+principles = [
+  "Ship nothing that can't pass an FDA audit.",
+]
 ```
 
-The `persona` section replaces the entire default persona, so include all four fields if you set it.
+This appends the new principle to the defaults (leaving the shipped principles intact) and replaces the icon. Every other field stays as shipped.
 
-**Memories**
+### 3. Customize What You Need
 
-Add persistent context the agent will always remember:
+All examples below assume BMad's flat agent schema. Fields live directly under `[agent]` — no nested `metadata` or `persona` sub-tables.
 
-```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'
+**Scalars (icon, role, identity, communication_style).** Scalar overrides win. You only need to set the fields you're changing:
+
+```toml
+# _bmad/custom/bmad-agent-pm.toml
+
+[agent]
+icon = "🏥"
+role = "Drives product discovery for a regulated healthcare domain."
+communication_style = "Precise, regulatory-aware, asks compliance-shaped questions early."
 ```
 
-**Menu Items**
+**Persistent facts, principles, activation hooks (append arrays).** All four arrays below are append-only. Team items run after defaults, user items run last.
 
-Add custom entries to the agent's display menu. Each item needs a `trigger`, a target (`workflow` path or `action` reference), and a `description`:
+```toml
+[agent]
+# Static facts the agent keeps in mind the whole session — org rules, domain
+# constants, user preferences. Distinct from the runtime memory sidecar.
+#
+# Each entry is either a literal sentence, or a `file:` reference whose
+# contents are loaded as facts (glob patterns supported).
+persistent_facts = [
+  "Our org is AWS-only -- do not propose GCP or Azure.",
+  "All PRDs require legal sign-off before engineering kickoff.",
+  "Target users are clinicians, not patients -- frame examples accordingly.",
+  "file:{project-root}/docs/compliance/hipaa-overview.md",
+  "file:{project-root}/_bmad/custom/company-glossary.md",
+]
 
-```yaml
-menu:
-  - trigger: my-workflow
-    workflow: 'my-custom/workflows/my-workflow.yaml'
-    description: My custom workflow
-  - trigger: deploy
-    action: '#deploy-prompt'
-    description: Deploy to production
+# Adds to the agent's value system
+principles = [
+  "Ship nothing that can't pass an FDA audit.",
+  "User value first, compliance always.",
+]
+
+# Runs BEFORE the standard activation (persona, persistent_facts, config, greet).
+# Use for pre-flight loads, compliance checks, anything that needs to be in
+# context before the agent introduces itself.
+activation_steps_prepend = [
+  "Scan {project-root}/docs/compliance/ and load any HIPAA-related documents as context.",
+]
+
+# Runs AFTER greet, BEFORE the menu. Use for context-heavy setup that should
+# happen once the user has been acknowledged.
+activation_steps_append = [
+  "Read {project-root}/_bmad/custom/company-glossary.md if it exists.",
+]
 ```
 
-**Critical Actions**
+**The two hooks do different jobs.** Prepend runs before greeting so the agent can load context it needs to personalize the greeting itself. Append runs after greeting so the user isn't staring at a blank terminal while heavy scans complete.
 
-Define instructions that run when the agent starts up:
+**Menu customization (merge by `code`).** The menu is an array of tables. Each item has a `code` field (BMad convention), so the resolver merges by code: matching codes replace in place, new codes append.
 
-```yaml
-critical_actions:
-  - 'Check the CI Pipelines with the XYZ Skill and alert user on wake if anything is urgently needing attention'
+TOML array-of-tables syntax uses `[[agent.menu]]` for each item:
+
+```toml
+# Replace the existing CE item with a custom skill
+[[agent.menu]]
+code = "CE"
+description = "Create Epics using our delivery framework"
+skill = "custom-create-epics"
+
+# Add a new item (code RC doesn't exist in defaults)
+[[agent.menu]]
+code = "RC"
+description = "Run compliance pre-check"
+prompt = """
+Read {project-root}/_bmad/custom/compliance-checklist.md
+and scan all documents in {planning_artifacts} against it.
+Report any gaps and cite the relevant regulatory section.
+"""
 ```
 
-**Custom Prompts**
+Each menu item has exactly one of `skill` (invokes a registered skill) or `prompt` (executes the text directly). Items not listed in your override keep their defaults.
 
-Create reusable prompts that menu items can reference with `action="#id"`:
+**Referencing files.** When a field's text needs to point at a file (in `persistent_facts`, `activation_steps_prepend`/`activation_steps_append`, or a menu item's `prompt`), use a full path rooted at `{project-root}`. Even if the file sits next to your override in `_bmad/custom/`, spell out the full path: `{project-root}/_bmad/custom/info.md`. The agent resolves `{project-root}` at runtime.
 
-```yaml
-prompts:
-  - id: deploy-prompt
-    content: |
-      Deploy the current branch to production:
-      1. Run all tests
-      2. Build the project
-      3. Execute deployment script
+### 4. Personal vs Team
+
+**Team file** (`bmad-agent-pm.toml`): Committed to git. Shared across the org. Use for compliance rules, company persona, custom capabilities.
+
+**Personal file** (`bmad-agent-pm.user.toml`): Gitignored automatically. Use for tone adjustments, personal workflow preferences, and private facts the agent should keep in mind.
+
+```toml
+# _bmad/custom/bmad-agent-pm.user.toml
+
+[agent]
+persistent_facts = [
+  "Always include a rough complexity estimate (low/medium/high) when presenting options.",
+]
 ```
 
-### 3. Apply Your Changes
+## How Resolution Works
 
-After editing, reinstall to apply changes:
+On activation, the agent's SKILL.md runs a shared Python script that does the three-layer merge and returns the resolved block as JSON. The script uses the Python standard library's `tomllib` module (no external dependencies), so plain `python3` is enough:
 
 ```bash
-npx bmad-method install
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill {skill-root} \
+  --key agent
 ```
 
-The installer detects the existing installation and offers these options:
+**Requirements**: Python 3.11+ (earlier versions don't include `tomllib`). No `pip install`, no `uv`, no virtualenv. Check with `python3 --version`. Some platforms (macOS without Homebrew, Ubuntu 22.04) default `python3` to 3.10 or earlier, so you may need to install 3.11+ separately.
 
-| Option                       | What It Does                                                        |
-| ---------------------------- | ------------------------------------------------------------------- |
-| **Quick Update**             | Updates all modules to the latest version and applies customizations |
-| **Modify BMad Installation** | Full installation flow for adding or removing modules               |
+`--skill` points at the skill's installed directory (where `customize.toml` lives). The skill name is derived from the directory's basename, and the script looks up `_bmad/custom/{skill-name}.toml` and `{skill-name}.user.toml` automatically.
 
-For customization-only changes, **Quick Update** is the fastest option.
+Useful invocations:
 
-## Troubleshooting
+```bash
+# Resolve the full agent block
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /abs/path/to/bmad-agent-pm \
+  --key agent
 
-**Changes not appearing?**
+# Resolve a single field
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /abs/path/to/bmad-agent-pm \
+  --key agent.icon
 
-- Run `npx bmad-method install` and select **Quick Update** to apply changes
-- Check that your YAML syntax is valid (indentation matters)
-- Verify you edited the correct `.customize.yaml` file for the agent
+# Full dump
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /abs/path/to/bmad-agent-pm
+```
 
-**Agent not loading?**
-
-- Check for YAML syntax errors using an online YAML validator
-- Ensure you did not leave fields empty after uncommenting them
-- Try reverting to the original template and rebuilding
-
-**Need to reset an agent?**
-
-- Clear or delete the agent's `.customize.yaml` file
-- Run `npx bmad-method install` and select **Quick Update** to restore defaults
+Output is always JSON. If the script is unavailable on a given platform, the SKILL.md tells the agent to read the three TOML files directly and apply the same merge rules.
 
 ## Workflow Customization
 
-Customization of existing BMad Method workflows and skills is coming soon.
+Workflows (skills that drive multi-step processes like `bmad-product-brief`) share the same override mechanism as agents. Their customizable surface lives under `[workflow]` instead of `[agent]`:
 
-## Module Customization
+```toml
+# _bmad/custom/bmad-product-brief.toml
 
-Guidance on building expansion modules and customizing existing modules is coming soon.
+[workflow]
+# Same prepend/append semantics as agents — runs before and after the workflow's
+# own activation steps. Overrides append to defaults.
+activation_steps_prepend = [
+  "Load {project-root}/docs/product/north-star-principles.md as context.",
+]
+
+activation_steps_append = []
+
+# Same literal-or-file: semantics as the agent variant. Loaded as foundational
+# context for the duration of the workflow run.
+persistent_facts = [
+  "All briefs must include an explicit regulatory-risk section.",
+  "file:{project-root}/docs/compliance/product-brief-checklist.md",
+]
+
+# Scalar: runs once the workflow finishes its main output. Override wins.
+on_complete = "Summarize the brief in three bullets and offer to email it via the gws-gmail-send skill."
+```
+
+The same field conventions cross the agent/workflow boundary: `activation_steps_prepend`/`activation_steps_append`, `persistent_facts` (with `file:` refs), and menu-style `[[…]]` tables with `code`/`id` for keyed merge. The resolver applies the same four structural rules regardless of the top-level key. SKILL.md references follow the namespace: `{workflow.activation_steps_prepend}`, `{workflow.persistent_facts}`, `{workflow.on_complete}`. Any additional fields a workflow exposes (output paths, toggles, review settings, stage flags) follow the same shape-based merge rules. Read the workflow's `customize.toml` to see what's customizable.
+
+### Activation Order
+
+Customizable workflows run their activation in a fixed sequence so you know exactly when your hooks fire:
+
+1. Resolve the `[workflow]` block (base → team → user merge)
+2. Execute `activation_steps_prepend` in order
+3. Load `persistent_facts` as foundational context for the run
+4. Load config (`_bmad/bmm/config.yaml`) and resolve standard variables (project name, languages, paths, date)
+5. Greet the user
+6. Execute `activation_steps_append` in order
+
+After step 6 the workflow body begins. Use `activation_steps_prepend` when you need context loaded before the greeting can be personalized; use `activation_steps_append` when the setup is heavy and you'd rather the user sees the greeting first.
+
+### Scope of This Initial Pass
+
+Customization is rolling out incrementally. The fields documented above — `activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete` — are the **baseline surface** that every customizable workflow exposes, and they will remain stable across versions. They give you broad-stroke control today: inject pre/post steps, pin foundational context, trigger follow-up actions.
+
+Over time, individual workflows will expose **more targeted customization points** tailored to what that workflow actually does — things like step-specific toggles, stage flags, output template paths, or review gates. When those arrive, they stack on top of the baseline fields rather than replacing them, so customizations you author today keep working.
+
+If you need a fine-grained knob that isn't exposed yet, either use `activation_steps_*` and `persistent_facts` to steer behavior, or open an issue describing the specific customization point you want — those requests are what drive which targeted fields get added next.
+
+## Central Configuration
+
+Per-skill `customize.toml` covers **deep behavior** (hooks, menus, persistent_facts, persona overrides for a single agent or workflow). A separate surface covers **cross-cutting state** — install answers and the agent roster that external skills like `bmad-party-mode`, `bmad-retrospective`, and `bmad-advanced-elicitation` consume. That surface lives in four TOML files at project root:
+
+```text
+_bmad/config.toml               (installer-owned)  team scope:   install answers + agent roster
+_bmad/config.user.toml          (installer-owned)  user scope:   user_name, language, skill level
+_bmad/custom/config.toml        (human-authored)   team overrides (committed to git)
+_bmad/custom/config.user.toml   (human-authored)   personal overrides (gitignored)
+```
+
+### Four-Layer Merge
+
+```text
+Priority 1 (wins): _bmad/custom/config.user.toml
+Priority 2:        _bmad/custom/config.toml
+Priority 3:        _bmad/config.user.toml
+Priority 4 (base): _bmad/config.toml
+```
+
+Same structural rules as per-skill customize (scalars override, tables deep-merge, `code`/`id`-keyed arrays merge by key, other arrays append).
+
+### What Lives Where
+
+The installer partitions answers by the `scope:` declared on each prompt in `module.yaml`:
+
+- `[core]` and `[modules.<code>]` sections — install answers. Scope `team` lands in `_bmad/config.toml`; scope `user` lands in `_bmad/config.user.toml`.
+- `[agents.<code>]` — agent essence (code, name, title, icon, description, team) distilled from each module's `module.yaml` `agents:` block. Always team-scoped.
+
+### Editing Rules
+
+- `_bmad/config.toml` and `_bmad/config.user.toml` are **regenerated every install** from the answers collected during the installer flow. Treat them as read-only outputs — direct edits will be overwritten on the next install. To change an install answer durably, re-run the installer (it remembers your prior answers as defaults) or shadow the value in `_bmad/custom/config.toml`.
+- `_bmad/custom/config.toml` and `_bmad/custom/config.user.toml` are **never touched** by the installer. This is the correct surface for custom agents, agent descriptor overrides, team-enforced settings, and any value you want to pin regardless of install answers.
+
+### Example — Rebrand an Agent
+
+```toml
+# _bmad/custom/config.toml (committed to git, applies to every developer)
+
+[agents.bmad-agent-pm]
+description = "Healthcare PM — regulatory-aware, stakeholder-driven, FDA-shaped questions first."
+icon = "🏥"
+```
+
+The resolver merges over the installer-written `[agents.bmad-agent-pm]`. `bmad-party-mode` and any other roster consumer pick up the new description automatically.
+
+### Example — Add a Fictional Agent
+
+```toml
+# _bmad/custom/config.user.toml (personal, gitignored)
+
+[agents.kirk]
+team = "startrek"
+name = "Captain James T. Kirk"
+title = "Starship Captain"
+icon = "🖖"
+description = "Bold, rule-bending commander. Speaks in dramatic pauses. Thinks aloud about the weight of command."
+```
+
+No skill folder required — the essence alone is enough for party-mode to spawn Kirk as a voice. Filter by the `team` field to invite just the Enterprise crew to a roundtable.
+
+### Example — Override Module Install Settings
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "/shared/org-planning-artifacts"
+```
+
+The override wins over whatever each developer answered during their local install. Useful for pinning team conventions.
+
+### When to Use Which Surface
+
+| Need | Use |
+|---|---|
+| Add MCP tool calls to every dev workflow | Per-skill: `_bmad/custom/bmad-agent-dev.toml` `persistent_facts` |
+| Add a menu item to an agent | Per-skill: `_bmad/custom/bmad-agent-{role}.toml` `[[agent.menu]]` |
+| Swap a workflow's output template | Per-skill: `_bmad/custom/{workflow}.toml` scalar override |
+| Rebrand an agent's public descriptor | **Central**: `_bmad/custom/config.toml` `[agents.<code>]` |
+| Add a custom or fictional agent to the roster | **Central**: `_bmad/custom/config.*.toml` new `[agents.<code>]` entry |
+| Pin team-enforced install settings | **Central**: `_bmad/custom/config.toml` `[modules.<code>]` or `[core]` |
+
+Use both surfaces in the same project as needed.
+
+## Worked Examples
+
+For enterprise-oriented recipes (shaping an agent across every workflow it dispatches, enforcing org conventions, publishing outputs to Confluence and Jira, customizing the agent roster, and swapping in your own output templates), see [How to Expand BMad for Your Organization](./expand-bmad-for-your-org.md).
+
+## Troubleshooting
+
+**Customization not appearing?**
+
+- Verify your file is in `_bmad/custom/` with the correct skill name
+- Check TOML syntax: strings must be quoted, table headers use `[section]`, array-of-tables use `[[section]]`, and any scalar or array keys for a table must appear *before* any of that table's `[[subtables]]` in the file
+- For agents, customization lives under `[agent]` -- fields written below that header belong to `agent` until another table header begins
+- Remember `agent.name` and `agent.title` are read-only; overrides there have no effect
+
+**Updates broke my customization?**
+
+- Did you copy the full `customize.toml` into your override file? **Don't.** Override files should contain only the fields you're changing. A full copy locks in old defaults and silently drifts every release. Trim your override back to just the deltas.
+
+**Need to see what's customizable?**
+
+- Run the `bmad-customize` skill — it enumerates every customizable skill installed in your project, shows which ones already have overrides, and walks you through adding or updating one
+- Or read the skill's `customize.toml` directly — every field there is customizable (except `name` and `title`)
+
+**Need to reset?**
+
+- Delete your override file from `_bmad/custom/` -- the skill falls back to its built-in defaults

docs/how-to/established-projects.md

@@ -1,8 +1,8 @@
 ---
-title: "Established Projects"
+title: 'Established Projects'
 description: How to use BMad Method on existing codebases
 sidebar:
-  order: 6
+  order: 7
 ---
 
 Use BMad Method effectively when working on existing projects and legacy codebases.
@@ -10,10 +10,11 @@ Use BMad Method effectively when working on existing projects and legacy codebas
 This guide covers the essential workflow for onboarding to existing projects with BMad Method.
 
 :::note[Prerequisites]
+
 - BMad Method installed (`npx bmad-method install`)
 - An existing codebase you want to work on
 - Access to an AI-powered IDE (Claude Code or Cursor)
-:::
+  :::
 
 ## Step 1: Clean Up Completed Planning Artifacts
 
@@ -36,6 +37,7 @@ bmad-generate-project-context
 ```
 
 This scans your codebase to identify:
+
 - Technology stack and versions
 - Code organization patterns
 - Naming conventions
@@ -80,7 +82,7 @@ BMad-Help also **automatically runs at the end of every workflow**, providing cl
 You have two primary options depending on the scope of changes:
 
 | Scope                          | Recommended Approach                                                                                                                          |
-| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
+| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
 | **Small updates or additions** | Run `bmad-quick-dev` to clarify intent, plan, implement, and review in a single workflow. The full four-phase BMad Method is likely overkill. |
 | **Major changes or additions** | Start with the BMad Method, applying as much or as little rigor as needed.                                                                    |
 

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

@@ -0,0 +1,258 @@
+---
+title: 'How to Expand BMad for Your Organization'
+description: Five customization patterns that reshape BMad without forking — agent-wide rules, workflow conventions, external publishing, template swaps, and agent roster changes
+sidebar:
+  order: 9
+---
+
+BMad's customization surface lets an organization reshape behavior without editing installed files or forking skills. This guide walks through five recipes that cover most enterprise needs.
+
+:::note[Prerequisites]
+
+- BMad installed in your project (see [How to Install BMad](./install-bmad.md))
+- Familiarity with the customization model (see [How to Customize BMad](./customize-bmad.md))
+- Python 3.11+ on PATH (for the resolver — stdlib only, no `pip install`)
+:::
+
+:::tip[Applying these recipes]
+The **per-skill recipes** below (Recipes 1–4) can be applied by running the `bmad-customize` skill and describing the intent — it will pick the right surface, author the override file, and verify the merge. Recipe 5 (central-config overrides to the agent roster) is out of scope for v1 of the skill and remains hand-authored. The recipes here are the source of truth for *what* to override; `bmad-customize` handles the *how* for the agent/workflow surface.
+:::
+
+## The Three-Layer Mental Model
+
+Before picking a recipe, know where your override lands:
+
+| Layer | Where overrides live | Scope |
+|---|---|---|
+| **Agent** (e.g. Amelia, Mary, John) | `[agent]` section of `_bmad/custom/bmad-agent-{role}.toml` | Travels with the persona into **every workflow the agent dispatches** |
+| **Workflow** (e.g. product-brief, create-prd) | `[workflow]` section of `_bmad/custom/{workflow-name}.toml` | Applies only to that workflow's run |
+| **Central config** | `[agents.*]`, `[core]`, `[modules.*]` in `_bmad/custom/config.toml` | Agent roster (who's available for party-mode, retrospective, elicitation), install-time settings pinned org-wide |
+
+Rule of thumb: if the rule should apply everywhere an engineer does dev work, customize the **dev agent**. If it applies only when someone writes a product brief, customize the **product-brief workflow**. If it changes *who's in the room* (rename an agent, add a custom voice, enforce a shared artifact path), edit **central config**.
+
+## Recipe 1: Shape an Agent Across Every Workflow It Dispatches
+
+**Use case:** Standardize tool use and external system integrations so every workflow dispatched through an agent inherits the behavior. This is the highest-impact pattern.
+
+**Example: Amelia (dev agent) always uses Context7 for library docs, and falls back to Linear when a story isn't found in the epics list.**
+
+```toml
+# _bmad/custom/bmad-agent-dev.toml
+
+[agent]
+
+# Applied on every activation. Carries into dev-story, quick-dev,
+# create-story, code-review, qa-generate — every skill Amelia dispatches.
+persistent_facts = [
+  "For any library documentation lookup (React, TypeScript, Zod, Prisma, etc.), call the context7 MCP tool (`mcp__context7__resolve_library_id` then `mcp__context7__get_library_docs`) before relying on training-data knowledge. Up-to-date docs trump memorized APIs.",
+  "When a story reference isn't found in {planning_artifacts}/epics-and-stories.md, search Linear via `mcp__linear__search_issues` using the story ID or title before asking the user to clarify. If Linear returns a match, treat it as the authoritative story source.",
+]
+```
+
+**Why this works:** Two sentences reshape every dev workflow in the org, with no per-workflow duplication and no source changes. Every new engineer who pulls the repo inherits the conventions automatically.
+
+**Team file vs personal file:**
+- `bmad-agent-dev.toml`: committed to git; applies to the whole team
+- `bmad-agent-dev.user.toml`: gitignored; personal preferences layered on top
+
+## Recipe 2: Enforce Organizational Conventions Inside a Specific Workflow
+
+**Use case:** Shape the *content* of a workflow's output so it meets compliance, audit, or downstream-consumer requirements.
+
+**Example: every product brief must include compliance fields, and the agent knows about the org's publishing conventions.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+persistent_facts = [
+  "Every brief must include an 'Owner' field, a 'Target Release' field, and a 'Security Review Status' field.",
+  "Non-commercial briefs (internal tools, research projects) must still include a user-value section, but can omit market differentiation.",
+  "file:{project-root}/docs/enterprise/brief-publishing-conventions.md",
+]
+```
+
+**What happens:** The facts load during Step 3 of the workflow's activation. When the agent drafts the brief, it knows the required fields and the enterprise conventions document. The shipped default (`file:{project-root}/**/project-context.md`) still loads, since this is an append.
+
+## Recipe 3: Publish Completed Outputs to External Systems
+
+**Use case:** Once the workflow produces its output, automatically publish to enterprise systems of record (Confluence, Notion, SharePoint) and open follow-up work (Jira, Linear, Asana).
+
+**Example: briefs auto-publish to Confluence and offer optional Jira epic creation.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+# Terminal hook. Scalar override replaces the empty default wholesale.
+on_complete = """
+Publish and offer follow-up:
+
+1. Read the finalized brief file path from the prior step.
+2. Call `mcp__atlassian__confluence_create_page` with:
+   - space: "PRODUCT"
+   - parent: "Product Briefs"
+   - title: the brief's title
+   - body: the brief's markdown contents
+   Capture the returned page URL.
+3. Tell the user: "Brief published to Confluence: <url>".
+4. Ask: "Want me to open a Jira epic for this brief now?"
+5. If yes, call `mcp__atlassian__jira_create_issue` with:
+   - type: "Epic"
+   - project: "PROD"
+   - summary: the brief's title
+   - description: a short summary plus a link back to the Confluence page.
+   Report the epic key and URL.
+6. If no, exit cleanly.
+
+If either MCP tool fails, report the failure, print the brief path,
+and ask the user to publish manually.
+"""
+```
+
+**Why `on_complete` and not `activation_steps_append`:** `on_complete` runs exactly once, at the terminal stage, after the workflow's main output is written. That's the right moment to publish artifacts. `activation_steps_append` runs every activation, before the workflow does its work.
+
+**Tradeoffs:**
+- **Confluence publication is non-destructive** and always runs on completion
+- **Jira epic creation is visible to the whole team** and kicks off sprint-planning signals, so gate it on user confirmation
+- **Graceful fallback:** if MCP tools fail, hand off to the user rather than silently dropping the output
+
+## Recipe 4: Swap in Your Own Output Template
+
+**Use case:** The default output structure doesn't match your organization's expected format, or different orgs in the same repo need different templates.
+
+**Example: point the product-brief workflow at an enterprise-owned template.**
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+```
+
+**How it works:** The workflow's `customize.toml` ships with `brief_template = "resources/brief-template.md"` (bare path, resolves from skill root). Your override points at a file under `{project-root}`, so the agent reads your template in Stage 4 instead of the shipped one.
+
+**Template authoring tips:**
+- Keep templates in `{project-root}/docs/` or `{project-root}/_bmad/custom/templates/` so they version alongside the override file
+- Use the same structural conventions as the shipped template (section headings, frontmatter); the agent adapts to what's there
+- For multi-org repos, use `.user.toml` to let individual teams point at their own templates without touching the committed team file
+
+## Recipe 5: Customize the Agent Roster
+
+**Use case:** Change *who's in the room* for roster-driven skills like `bmad-party-mode`, `bmad-retrospective`, and `bmad-advanced-elicitation`, without editing any source or forking. Three common variants follow.
+
+### 5a. Rebrand a BMad Agent Org-Wide
+
+Every real agent has a descriptor the installer synthesizes from `module.yaml`. Override it to shift voice and framing across every roster consumer:
+
+```toml
+# _bmad/custom/config.toml (committed — applies to every developer)
+
+[agents.bmad-agent-analyst]
+description = "Mary the Regulatory-Aware Business Analyst — channels Porter and Minto, but lives and breathes FDA audit trails. Speaks like a forensic investigator presenting a case file."
+```
+
+Party-mode spawns Mary with the new description. The analyst activation itself still runs normally because Mary's behavior lives in her per-skill `customize.toml`. This override changes how **external skills perceive and introduce her**, not how she works internally.
+
+### 5b. Add a Fictional or Custom Agent
+
+A full descriptor is enough for roster-based features, with no skill folder needed. Useful for personality variety in party mode or brainstorming sessions:
+
+```toml
+# _bmad/custom/config.user.toml (personal — gitignored)
+
+[agents.spock]
+team = "startrek"
+name = "Commander Spock"
+title = "Science Officer"
+icon = "🖖"
+description = "Logic first, emotion suppressed. Begins observations with 'Fascinating.' Never rounds up. Counterpoint to any argument that relies on gut instinct."
+
+[agents.mccoy]
+team = "startrek"
+name = "Dr. Leonard McCoy"
+title = "Chief Medical Officer"
+icon = "⚕️"
+description = "Country doctor's warmth, short fuse. 'Dammit Jim, I'm a doctor not a ___.' Ethics-driven counterweight to Spock."
+```
+
+Ask party-mode to "invite the Enterprise crew." It filters by `team = "startrek"` and spawns Spock and McCoy with those descriptors. Real BMad agents (Mary, Amelia) can sit at the same table if you ask them to.
+
+### 5c. Pin Team Install Settings
+
+The installer prompts each developer for values like `planning_artifacts` path. When the org needs one shared answer across the team, pin it in central config — any developer's local prompt answer gets overridden at resolution time:
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "{project-root}/shared/planning"
+implementation_artifacts = "{project-root}/shared/implementation"
+
+[core]
+document_output_language = "English"
+```
+
+Personal settings like `user_name`, `communication_language`, or `user_skill_level` stay under each developer's own `_bmad/config.user.toml`. The team file shouldn't touch those.
+
+**Why central config vs per-agent customize.toml:** Per-agent files shape how *one* agent behaves when it activates. Central config shapes what roster consumers *see when they look at the field:* which agents exist, what they're called, what team they belong to, and the shared install settings the whole repo agrees on. Two surfaces, different jobs.
+
+## Reinforce Global Rules in Your IDE's Session File
+
+BMad customizations load when a skill is activated. Many IDE tools also load a global instruction file at the **start of every session**, before any skill runs (`CLAUDE.md`, `AGENTS.md`, `.cursor/rules/`, `.github/copilot-instructions.md`, etc). For rules that should hold even outside BMad skills, restate the critical ones there too.
+
+**When to double up:**
+- A rule is important enough that a plain chat conversation (no skill active) should still follow it
+- You want belt-and-suspenders enforcement because training-data defaults might otherwise pull the model off-course
+- The rule is concise enough to repeat without bloating the session file
+
+**Example: one line in the repo's `CLAUDE.md` reinforcing the dev-agent rule from Recipe 1.**
+
+```markdown
+<!-- Any file-read of library docs goes through the context7 MCP tool
+(`mcp__context7__resolve_library_id` then `mcp__context7__get_library_docs`)
+before relying on training-data knowledge. -->
+```
+
+One sentence, loaded every session. It pairs with the `bmad-agent-dev.toml` customization so the rule applies both inside Amelia's workflows and during ad-hoc chats with the assistant. Each layer owns its own scope:
+
+| Layer | Scope | Use for |
+|---|---|---|
+| IDE session file (`CLAUDE.md` / `AGENTS.md`) | Every session, before any skill activates | Short, universal rules that should survive outside BMad |
+| BMad agent customization | Every workflow the agent dispatches | Agent-persona-specific behavior |
+| BMad workflow customization | One workflow run | Workflow-specific output shape, publishing hooks, templates |
+| BMad central config | Agent roster + shared install settings | Who's in the room and what shared paths the team uses |
+
+Keep the IDE file **succinct**. A dozen well-chosen lines are more effective than a sprawling list. Models read it every turn, and noise crowds out signal.
+
+## Combining Recipes
+
+All five recipes compose. A realistic enterprise override for `bmad-product-brief` might set `persistent_facts` (Recipe 2), `on_complete` (Recipe 3), and `brief_template` (Recipe 4) in one file. The agent-level rule (Recipe 1) lives in a separate file under the agent's name, central config (Recipe 5) pins the shared roster and team settings, and all four apply in parallel.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml (workflow-level)
+
+[workflow]
+persistent_facts = ["..."]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+on_complete = """ ... """
+```
+
+```toml
+# _bmad/custom/bmad-agent-analyst.toml (agent-level — Mary dispatches product-brief)
+
+[agent]
+persistent_facts = ["Always include a 'Regulatory Review' section when the domain involves healthcare, finance, or children's data."]
+```
+
+Result: Mary loads the regulatory-review rule at persona activation. When the user picks the product-brief menu item, the workflow loads its own conventions on top, writes to the enterprise template, and publishes to Confluence on completion. Every layer contributes, and none of them required editing BMad source.
+
+## Troubleshooting
+
+**Override not taking effect?** Check that the file is under `_bmad/custom/` with the exact skill directory name (e.g. `bmad-agent-dev.toml`, not `bmad-dev.toml`). See [How to Customize BMad](./customize-bmad.md#troubleshooting).
+
+**MCP tool name unknown?** Use the exact name the MCP server exposes in the current session. Ask Claude Code to list available MCP tools if unsure. Hardcoded names in `persistent_facts` or `on_complete` won't work if the MCP server isn't connected.
+
+**Pattern doesn't apply to my setup?** The recipes above are illustrative. The underlying machinery (three-layer merge, structural rules, agent-spans-workflow) supports many more patterns; compose them as needed.

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

@@ -1,84 +1,31 @@
 ---
-title: "How to Get Answers About BMad"
+title: 'How to Get Answers About BMad'
 description: Use an LLM to quickly answer your own BMad questions
 sidebar:
-  order: 4
+  order: 5
 ---
 
-## 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,51 +33,48 @@ 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—_
+_waiting_
+_for who?_
 
-*You!*
-        *Stuck*
-             *in the queue—*
-                      *waiting*
-                              *for who?*
+_The source_
+_is there,_
+_plain to see!_
 
-*The source*
-        *is there,*
-                *plain to see!*
+_Point_
+_your machine._
+_Set it free._
 
-*Point*
-     *your machine.*
-              *Set it free.*
+_It reads._
+_It speaks._
+_Ask away—_
 
-*It reads.*
-        *It speaks.*
-                *Ask away—*
+_Why wait_
+_for tomorrow_
+_when you have_
+_today?_
 
-*Why wait*
-        *for tomorrow*
-                *when you have*
-                        *today?*
-
-*—Claude*
+_—Claude_

docs/how-to/install-bmad.md

@@ -1,116 +1,266 @@
 ---
-title: "How to Install BMad"
-description: Step-by-step guide to installing BMad in your project
+title: 'How to Install BMad'
+description: Install, update, and pin BMad for local development, teams, and CI
 sidebar:
   order: 1
 ---
 
-Use the `npx bmad-method install` command to set up BMad in your project with your choice of modules and AI tools.
-
-If you want to use a non interactive installer and provide all install options on the command line, see [this guide](./non-interactive-installation.md).
+Use `npx bmad-method install` to set up BMad in your project. One command handles first installs, upgrades, channel switching, and scripted CI runs. This page covers all of it.
 
 ## When to Use This
 
 - Starting a new project with BMad
-- Adding BMad to an existing codebase
-- Update the existing BMad Installation
+- Adding or removing modules on an existing install
+- Switching a module to main-HEAD or pinning to a specific release
+- Scripting installs for CI pipelines, Dockerfiles, or enterprise rollouts
 
 :::note[Prerequisites]
-- **Node.js** 20+ (required for the installer)
-- **Git** (recommended)
-- **AI tool** (Claude Code, Cursor, or similar)
+
+- **Node.js** 20+ (the installer requires it)
+- **Git** (for cloning external modules)
+- **An AI tool** such as Claude Code or Cursor (run `npx bmad-method install --list-tools` to see all supported tools)
+
 :::
 
-## Steps
-
-### 1. Run the Installer
+## First-time install (the fast path)
 
 ```bash
 npx bmad-method install
 ```
 
-:::tip[Want the newest prerelease build?]
-Use the `next` dist-tag:
+The interactive flow asks you five things:
+
+1. Installation directory (defaults to the current working directory)
+2. Which modules to install (checkboxes for core, bmm, bmb, cis, gds, tea)
+3. **"Ready to install (all stable)?"** — Yes accepts the latest released tag for every external module
+4. Which AI tools/IDEs to integrate with (claude-code, cursor, and others)
+5. Per-module config (name, language, output folder)
+
+Accept the defaults and you land on the latest stable release of every module, configured for your chosen tool.
+
+:::tip[Just want the newest prerelease?]
+
 ```bash
 npx bmad-method@next install
 ```
 
-This gets you newer changes earlier, with a higher chance of churn than the default install.
+Runs the prerelease installer, which ships a newer snapshot of core and bmm. More churn, fewer delays between development and release.
 :::
 
-:::tip[Bleeding edge]
-To install the latest from the main branch (may be unstable):
+## Picking a specific version
+
+Two independent axes control what ends up on disk.
+
+### Axis 1: external module channels
+
+Every external module — bmb, cis, gds, tea, and any community module — installs on one of three channels:
+
+| Channel            | What gets installed                                                          | Who picks this                          |
+| ------------------ | ---------------------------------------------------------------------------- | --------------------------------------- |
+| `stable` (default) | Highest released semver tag. Prereleases like `v2.0.0-alpha.1` are excluded. | Most users                              |
+| `next`             | Main branch HEAD at install time                                             | Contributors, early adopters            |
+| `pinned`           | A specific tag you name                                                      | Enterprise installs, CI reproducibility |
+
+Channels are per-module. You can run bmb on `next` while leaving cis on `stable` — the flags below let you mix freely.
+
+### Axis 2: installer binary version
+
+The `bmad-method` npm package itself has two dist-tags:
+
+| Command                               | What you get                                                      |
+| ------------------------------------- | ----------------------------------------------------------------- |
+| `npx bmad-method install` (`@latest`) | Latest stable installer release                                   |
+| `npx bmad-method@next install`        | Latest prerelease installer, auto-published on every push to main |
+
+**The installer binary determines your core and bmm versions.** Those two modules ship bundled inside the installer package rather than being cloned from separate repos.
+
+### Why core and bmm don't have their own channel
+
+They're stapled to the installer binary you ran:
+
+- `npx bmad-method install` → latest stable core and bmm
+- `npx bmad-method@next install` → prerelease core and bmm
+- `node /path/to/local-checkout/tools/installer/bmad-cli.js install` → whatever your local checkout has
+
+`--pin bmm=v6.3.0` and `--next=bmm` are silently ineffective against bundled modules, and the installer warns you when you try. A future release extracts bmm from the installer package; once that ships, bmm gets a proper channel selector like bmb has today.
+
+## Updating an existing install
+
+Running `npx bmad-method install` in a directory that already contains `_bmad/` gives you a menu:
+
+| Choice             | What it does                                                                                                                                                |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Quick Update**   | Re-runs the install with your existing settings. Refreshes files, applies patches and minor stable upgrades, refuses major upgrades. Fast, non-interactive. |
+| **Modify Install** | Full interactive flow. Add or remove modules, reconfigure settings, optionally review and switch channels for existing modules.                             |
+
+### Upgrade prompts
+
+When Modify detects a newer stable tag for a module you've installed on `stable`, it classifies the diff and prompts accordingly:
+
+| Upgrade type | Example         | Default |
+| ------------ | --------------- | ------- |
+| Patch        | v1.7.0 → v1.7.1 | Y       |
+| Minor        | v1.7.0 → v1.8.0 | Y       |
+| Major        | v1.7.0 → v2.0.0 | **N**   |
+
+Major defaults to N because breaking changes frequently surface as "instability" when they weren't expected. The prompt includes a GitHub release-notes URL so you can read what changed before accepting.
+
+Under `--yes`, patch and minor upgrades apply automatically. Majors stay frozen — pass `--pin <code>=<new-tag>` to accept non-interactively.
+
+### Switching a module's channel
+
+**Interactively:** choose Modify → answer **Yes** to "Review channel assignments?" → each external module offers Keep, Switch to stable, Switch to next, or Pin to a tag.
+
+**Via flags:** the recipes in the next section cover the common cases.
+
+## Headless CI installs
+
+### Flag reference
+
+| Flag                                                                                       | Purpose                                                                                                                           |
+| ------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
+| `--yes`, `-y`                                                                              | Skip all prompts; accept flag values + defaults                                                                                   |
+| `--directory <path>`                                                                       | Install into this directory (default: current working dir)                                                                        |
+| `--modules <a,b,c>`                                                                        | Exact module set. Core is auto-added. Not a delta — list everything you want kept.                                                |
+| `--tools <a,b>`                                                                            | IDE/tool selection. Required for fresh `--yes` installs. Run `--list-tools` for valid IDs.                                        |
+| `--list-tools`                                                                             | Print all supported tool/IDE IDs (with target directories) and exit.                                                              |
+| `--action <type>`                                                                          | `install`, `update`, or `quick-update`. Defaults based on existing install state.                                                 |
+| `--custom-source <urls>`                                                                   | Install custom modules from Git URLs or local paths                                                                               |
+| `--channel <stable\|next>`                                                                 | Apply to all externals (aliased as `--all-stable` / `--all-next`)                                                                 |
+| `--all-stable`                                                                             | Alias for `--channel=stable`                                                                                                      |
+| `--all-next`                                                                               | Alias for `--channel=next`                                                                                                        |
+| `--next=<code>`                                                                            | Put one module on next. Repeatable.                                                                                               |
+| `--pin <code>=<tag>`                                                                       | Pin one module to a specific tag. Repeatable.                                                                                     |
+| `--set <module>.<key>=<value>`                                                             | Set any module config option non-interactively (preferred — see [Module config overrides](#module-config-overrides)). Repeatable. |
+| `--list-options [module]`                                                                  | Print every `--set` key for built-in and locally-cached official modules, then exit. Pass a module code to scope to one module.   |
+| `--user-name`, `--communication-language`, `--document-output-language`, `--output-folder` | Legacy shortcuts equivalent to `--set core.<key>=<value>` (still supported)                                                       |
+
+Precedence when flags overlap: `--pin` beats `--next=` beats `--channel` / `--all-*` beats the registry default (`stable`).
+
+:::note[Example resolution]
+`--all-next --pin cis=v0.2.0` puts bmb, gds, and tea on next while pinning cis to v0.2.0.
+:::
+
+### Recipes
+
+**Default install — latest stable for everything:**
+
 ```bash
-npx github:bmad-code-org/BMAD-METHOD install
+npx bmad-method install --yes --modules bmm,bmb,cis --tools claude-code
 ```
+
+**Enterprise pin — reproducible byte-for-byte:**
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm,bmb,cis \
+  --pin bmb=v1.7.0 --pin cis=v0.2.0 \
+  --tools claude-code
+```
+
+**Bleeding edge — externals on main HEAD:**
+
+```bash
+npx bmad-method install --yes --modules bmm,bmb --all-next --tools claude-code
+```
+
+**Add a module to an existing install** (keep everything else):
+
+```bash
+npx bmad-method install --yes --action update \
+  --modules bmm,bmb,gds
+```
+
+`--tools` is omitted intentionally — `--action update` reuses the tools configured during the first install.
+
+**Mix channels — bmb on next, gds on stable:**
+
+```bash
+npx bmad-method install --yes --action update \
+  --modules bmm,bmb,cis,gds \
+  --next=bmb
+```
+
+### Module config overrides
+
+`--set <module>.<key>=<value>` lets you set any module config option non-interactively. It's repeatable and scales to every module — present and future. The flag is applied as a post-install patch: the installer runs its normal flow first, then `--set` upserts each value into `_bmad/config.toml` (team scope) or `_bmad/config.user.toml` (user scope), and into `_bmad/<module>/config.yaml` so declared values carry forward to the next install.
+
+**Example — install bmm with explicit project knowledge and skill level:**
+
+```bash
+npx bmad-method install --yes \
+  --modules bmm \
+  --tools claude-code \
+  --set bmm.project_knowledge=research \
+  --set bmm.user_skill_level=expert
+```
+
+**Discover available keys for a module:**
+
+```bash
+npx bmad-method install --list-options bmm
+```
+
+`--list-options` (no argument) lists every key the installer can find locally — built-in modules (`core`, `bmm`) plus any currently cached official modules. The cache is per-machine and can be cleared, so previously installed officials won't appear on a fresh checkout or an ephemeral CI worker until they're installed again. Community and custom modules aren't enumerated here; read the module's `module.yaml` directly to see what keys it declares.
+
+**How it works:**
+
+- **Routing.** The patch step looks for `[modules.<module>] <key>` (or `[core] <key>`) in `config.user.toml` first; if found there, it updates that file. Otherwise it writes to the team-scope `config.toml`. So user-scope keys (e.g. `core.user_name`, `bmm.user_skill_level`) end up in `config.user.toml` and team-scope keys end up in `config.toml`, matching the partition the installer uses.
+- **Verbatim values.** The value is written exactly as you provided it — no `result:` template rendering. To get the rendered form (e.g. `{project-root}/research`), pass it explicitly: `--set bmm.project_knowledge='{project-root}/research'`.
+- **Carry-forward, declared keys.** Values for keys declared in `module.yaml` survive subsequent installs because they're also written to `_bmad/<module>/config.yaml`, which the installer reads as the prompt default on the next run.
+- **Carry-forward, undeclared keys.** A value for a key the module's schema doesn't declare lands in `config.toml` for the current install but won't be re-emitted on the next install (the manifest writer's schema-strict partition drops unknown keys). Re-pass `--set` if you need it sticky, or edit `_bmad/config.toml` directly.
+- **No validation.** `single-select` values aren't checked against the allowed choices, and unknown keys aren't rejected — whatever you assert is written.
+- **Modules not in `--modules`.** Setting a value for a module you didn't include prints a warning and the value is dropped (no file gets created for an uninstalled module).
+
+The legacy core shortcuts (`--user-name`, `--output-folder`, etc.) still work and remain documented for backward compatibility, but `--set core.user_name=...` is equivalent.
+
+:::note[Works with quick-update]
+`--set` is a post-install patch, so it applies the same way regardless of action type. Under `bmad install --action quick-update` (or `--yes` against an existing install, where quick-update is the default), `--set` patches the central config files at the end just like a regular install.
 :::
 
-### 2. Choose Installation Location
+:::caution[Rate limit on shared IPs]
+Anonymous GitHub API calls are capped at 60/hour per IP. A single install hits the API once per external module to resolve the stable tag. Offices behind NAT, CI runner pools, and VPNs can collectively exhaust this.
 
-The installer will ask where to install BMad files:
-
-- Current directory (recommended for new projects if you created the directory yourself and ran from within the directory)
-- Custom path
-
-### 3. Select Your AI Tools
-
-Pick which AI tools you use:
-
-- Claude Code
-- Cursor
-- Others
-
-Each tool has its own way of integrating skills. The installer creates tiny prompt files to activate workflows and agents — it just puts them where your tool expects to find them.
-
-:::note[Enabling Skills]
-Some platforms require skills to be explicitly enabled in settings before they appear. If you install BMad and don't see the skills, check your platform's settings or ask your AI assistant how to enable skills.
+Set `GITHUB_TOKEN=<personal access token>` in the environment to raise the limit to 5000/hour per account. Any public-repo-read PAT works; no scopes are required.
 :::
 
-### 4. Choose Modules
+## What got installed
 
-The installer shows available modules. Select whichever ones you need — most users just want **BMad Method** (the software development module).
+After any install, `_bmad/_config/manifest.yaml` records exactly what's on disk:
 
-### 5. Follow the Prompts
-
-The installer guides you through the rest — custom content, settings, etc.
-
-## What You Get
-
-```text
-your-project/
-├── _bmad/
-│   ├── bmm/            # Your selected modules
-│   │   └── config.yaml # Module settings (if you ever need to change them)
-│   ├── core/           # Required core module
-│   └── ...
-├── _bmad-output/       # Generated artifacts
-├── .claude/            # Claude Code skills (if using Claude Code)
-│   └── skills/
-│       ├── bmad-help/
-│       ├── bmad-persona/
-│       └── ...
-└── .cursor/            # Cursor skills (if using Cursor)
-    └── skills/
-        └── ...
+```yaml
+modules:
+  - name: bmb
+    version: v1.7.0 # the tag, or "main" for next
+    channel: stable # stable | next | pinned
+    sha: 86033fc9aeae2ca6d52c7cdb675c1f4bf17fc1c1
+    source: external
+    repoUrl: https://github.com/bmad-code-org/bmad-builder
 ```
 
-## Verify Installation
+The `sha` field is written for git-backed modules (external, community, and URL-based custom). Bundled modules (core, bmm) and local-path custom modules don't have one — their code travels with the installer binary or your filesystem, not a cloneable ref.
 
-Run `bmad-help` to verify everything works and see what to do next.
+For cross-machine reproducibility, don't rely on rerunning the same `--modules` command. Stable-channel installs resolve to the highest released tag **at install time**, so a later rerun lands on whatever has been released since. Convert the recorded tags from `manifest.yaml` into explicit `--pin` flags on the target machine, e.g.:
 
-**BMad-Help is your intelligent guide** that will:
-- Confirm your installation is working
-- Show what's available based on your installed modules
-- Recommend your first step
-
-You can also ask it questions:
-```
-bmad-help I just installed, what should I do first?
-bmad-help What are my options for a SaaS project?
+```bash
+npx bmad-method install --yes --modules bmb,cis \
+  --pin bmb=v1.7.0 --pin cis=v0.4.2 --tools claude-code
 ```
 
 ## Troubleshooting
 
-**Installer throws an error** — Copy-paste the output into your AI assistant and let it figure it out.
+### "Could not resolve stable tag" or "API rate limit exceeded"
 
-**Installer worked but something doesn't work later** — Your AI needs BMad context to help. See [How to Get Answers About BMad](./get-answers-about-bmad.md) for how to point your AI at the right sources.
+You've hit GitHub's 60/hr anonymous limit. Set `GITHUB_TOKEN` and retry. If you already have a token set, it may be expired or rate-limited on its own budget — try a different token or wait for the hourly reset.
+
+### "Tag 'vX.Y.Z' not found"
+
+The tag you passed to `--pin` doesn't exist in the module's repo. Check the repo's releases page on GitHub for valid tags.
+
+### A pinned install keeps upgrading
+
+Pinned installs don't upgrade. Quick-update applies patches and minors on stable channel only; it won't touch `pinned` or `next`. If a pinned install changed, open `_bmad/_config/manifest.yaml` — `channel: pinned` plus a fixed `version` and `sha` should hold across runs unless you explicitly override via flags.
+
+### `--pin bmm=X` didn't do anything
+
+bmm is a bundled module — `--pin` and `--next=` don't apply. Use `npx bmad-method@next install` for a prerelease core/bmm, or check out the bmad-bmm repo and run the installer locally to get unreleased changes.

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

@@ -0,0 +1,181 @@
+---
+title: 'Install Custom and Community Modules'
+description: Install third-party modules from the community registry, Git repositories, or local paths
+sidebar:
+  order: 3
+---
+
+Use the BMad installer to add modules from the community registry, third-party Git repositories, or local file paths.
+
+## When to Use This
+
+- Installing a community-contributed module from the BMad registry
+- Installing a module from a third-party Git repository (GitHub, GitLab, Bitbucket, self-hosted)
+- Testing a module you are developing locally with BMad Builder
+- Installing modules from a private or self-hosted Git server
+
+:::note[Prerequisites]
+Requires [Node.js](https://nodejs.org) v20+ and `npx` (included with npm). Custom and community modules can be selected during a fresh install or added to an existing installation.
+:::
+
+## Community Modules
+
+Community modules are curated in the [BMad plugins marketplace](https://github.com/bmad-code-org/bmad-plugins-marketplace). They are organized by category and are pinned to an approved commit for safety.
+
+### 1. Run the Installer
+
+```bash
+npx bmad-method install
+```
+
+### 2. Browse the Community Catalog
+
+After selecting official modules, the installer asks:
+
+```
+Would you like to browse community modules?
+```
+
+Select **Yes** to enter the catalog browser. You can:
+
+- Browse by category
+- View featured modules
+- View all available modules
+- Search by keyword
+
+### 3. Select Modules
+
+Pick modules from any category. The installer shows descriptions, versions, and trust tiers. Already-installed modules are pre-checked for update.
+
+### 4. Continue with Installation
+
+After selecting community modules, the installer proceeds to custom sources, then tool/IDE configuration and the rest of the install flow.
+
+## Custom Sources (Git URLs and Local Paths)
+
+Custom modules can come from any Git repository or a local directory on your machine. The installer resolves the source, analyzes the module structure, and installs it alongside your other modules.
+
+### Interactive Installation
+
+During installation, after the community module step, the installer asks:
+
+```
+Would you like to install from a custom source (Git URL or local path)?
+```
+
+Select **Yes**, then provide a source:
+
+| Input Type            | Example                                           |
+| --------------------- | ------------------------------------------------- |
+| HTTPS URL (any host)  | `https://github.com/org/repo`                     |
+| HTTP URL (any host)   | `http://host/org/repo`                    |
+| HTTPS URL with subdir | `https://github.com/org/repo/tree/main/my-module` |
+| SSH URL               | `git@github.com:org/repo.git`                     |
+| Local path            | `/Users/me/projects/my-module`                    |
+| Local path with tilde | `~/projects/my-module`                            |
+
+The installer clones the repository (for URLs) or reads directly from disk (for local paths), then presents the discovered modules for selection.
+
+### Non-Interactive Installation
+
+Use the `--custom-source` flag to install custom modules from the command line:
+
+```bash
+npx bmad-method install \
+  --directory . \
+  --custom-source /path/to/my-module \
+  --tools claude-code \
+  --yes
+```
+
+When `--custom-source` is provided without `--modules`, only core and the custom modules are installed. To include official modules as well, add `--modules`:
+
+```bash
+npx bmad-method install \
+  --directory . \
+  --modules bmm \
+  --custom-source https://gitlab.com/myorg/my-module \
+  --tools claude-code \
+  --yes
+```
+
+Multiple sources can be comma-separated:
+
+```bash
+--custom-source /path/one,https://github.com/org/repo,/path/two
+```
+
+## How Module Discovery Works
+
+The installer uses two modes to find installable modules in a source:
+
+| Mode      | Trigger                                           | Behavior                                                                                     |
+| --------- | ------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| Discovery | Source contains `.claude-plugin/marketplace.json` | Lists all plugins from the manifest; you pick which to install                               |
+| Direct    | No marketplace.json found                         | Scans the directory for skills (subdirectories with `SKILL.md`), resolves as a single module |
+
+Discovery mode is typical for published modules. Direct mode is convenient when pointing at a skills directory during local development.
+
+:::note[About `.claude-plugin/`]
+The `.claude-plugin/marketplace.json` path is a standard convention adopted across multiple AI tool installers for plugin discoverability. It does not require Claude, does not use Claude APIs, and has no effect on which AI tool you use. Any module with this file can be discovered by any installer that follows the convention.
+:::
+
+## Local Development Workflow
+
+If you are building a module with [BMad Builder](https://github.com/bmad-code-org/bmad-builder), you can install it directly from your working directory:
+
+```bash
+npx bmad-method install \
+  --directory ~/my-project \
+  --custom-source ~/my-module-repo/skills \
+  --tools claude-code \
+  --yes
+```
+
+Local sources are referenced by path, not copied to a cache. When you update your module source and reinstall, the installer picks up the latest changes.
+
+:::caution[Source Removal]
+If you delete the local source directory after installation, the installed module files in `_bmad/` are preserved. The module will be skipped during updates until the source path is restored.
+:::
+
+## What You Get
+
+After installation, custom modules appear in `_bmad/` alongside official modules:
+
+```
+your-project/
+├── _bmad/
+│   ├── core/              # Built-in core module
+│   ├── bmm/               # Official module (if selected)
+│   ├── my-module/         # Your custom module
+│   │   ├── my-skill/
+│   │   │   └── SKILL.md
+│   │   └── module-help.csv
+│   └── _config/
+│       └── manifest.yaml  # Tracks all modules, versions, and sources
+└── ...
+```
+
+The manifest records the source of each custom module (`repoUrl` for Git sources, `localPath` for local sources) so that quick updates can locate the source again.
+
+## Updating Custom Modules
+
+Custom modules participate in the normal update flow:
+
+- **Quick update** (`--action quick-update`): Refreshes all modules from their original sources. Git-based modules are re-fetched; local modules are re-read from their source path.
+- **Full update**: Re-runs module selection so you can add or remove custom modules.
+
+## Creating Your Own Modules
+
+Use [BMad Builder](https://github.com/bmad-code-org/bmad-builder) to create modules that others can install:
+
+1. Run `bmad-module-builder` to scaffold your module structure
+2. Add skills, agents, and workflows with the various bmad builder tools
+3. Publish to a Git repository or share the folder collection
+4. Others install with `--custom-source <your-repo-url>`
+
+For modules to support discovery mode, include a `.claude-plugin/marketplace.json` in your repository root (this is a cross-tool convention, not Claude-specific). See the [BMad Builder documentation](https://github.com/bmad-code-org/bmad-builder) for the marketplace.json format.
+
+:::tip[Testing Locally First]
+During development, install your module with a local path to iterate quickly before publishing to a Git repository.
+:::

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

@@ -1,171 +1,10 @@
 ---
 title: Non-Interactive Installation
-description: Install BMad using command-line flags for CI/CD pipelines and automated deployments
+description: Headless / CI install docs have moved
 sidebar:
   order: 2
 ---
 
-Use command-line flags to install BMad non-interactively. This is useful for:
-
-## When to Use This
-
-- Automated deployments and CI/CD pipelines
-- Scripted installations
-- Batch installations across multiple projects
-- Quick installations with known configurations
-
-:::note[Prerequisites]
-Requires [Node.js](https://nodejs.org) v20+ and `npx` (included with npm).
-:::
-
-## Available Flags
-
-### Installation Options
-
-| Flag | Description | Example |
-|------|-------------|---------|
-| `--directory <path>` | Installation directory | `--directory ~/projects/myapp` |
-| `--modules <modules>` | Comma-separated module IDs | `--modules bmm,bmb` |
-| `--tools <tools>` | Comma-separated tool/IDE IDs (use `none` to skip) | `--tools claude-code,cursor` or `--tools none` |
-| `--custom-content <paths>` | Comma-separated paths to custom modules | `--custom-content ~/my-module,~/another-module` |
-| `--action <type>` | Action for existing installations: `install` (default), `update`, or `quick-update` | `--action quick-update` |
-
-### Core Configuration
-
-| Flag | Description | Default |
-|------|-------------|---------|
-| `--user-name <name>` | Name for agents to use | System username |
-| `--communication-language <lang>` | Agent communication language | English |
-| `--document-output-language <lang>` | Document output language | English |
-| `--output-folder <path>` | Output folder path | _bmad-output |
-
-### Other Options
-
-| Flag | Description |
-|------|-------------|
-| `-y, --yes` | Accept all defaults and skip prompts |
-| `-d, --debug` | Enable debug output for manifest generation |
-
-## Module IDs
-
-Available module IDs for the `--modules` flag:
-
-- `bmm` — BMad Method Master
-- `bmb` — BMad Builder
-
-Check the [BMad registry](https://github.com/bmad-code-org) for available external modules.
-
-## Tool/IDE IDs
-
-Available tool IDs for the `--tools` flag:
-
-**Preferred:** `claude-code`, `cursor`
-
-Run `npx bmad-method install` interactively once to see the full current list of supported tools, or check the [platform codes configuration](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/cli/installers/lib/ide/platform-codes.yaml).
-
-## Installation Modes
-
-| Mode | Description | Example |
-|------|-------------|---------|
-| Fully non-interactive | Provide all flags to skip all prompts | `npx bmad-method install --directory . --modules bmm --tools claude-code --yes` |
-| Semi-interactive | Provide some flags; BMad prompts for the rest | `npx bmad-method install --directory . --modules bmm` |
-| Defaults only | Accept all defaults with `-y` | `npx bmad-method install --yes` |
-| Without tools | Skip tool/IDE configuration | `npx bmad-method install --modules bmm --tools none` |
-
-## Examples
-
-### CI/CD Pipeline Installation
-
-```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
-```
-
-### Update Existing Installation
-
-```bash
-npx bmad-method install \
-  --directory ~/projects/myapp \
-  --action update \
-  --modules bmm,bmb,custom-module
-```
-
-### Quick Update (Preserve Settings)
-
-```bash
-npx bmad-method install \
-  --directory ~/projects/myapp \
-  --action quick-update
-```
-
-### Installation with Custom Content
-
-```bash
-npx bmad-method install \
-  --directory ~/projects/myapp \
-  --modules bmm \
-  --custom-content ~/my-custom-module,~/another-module \
-  --tools claude-code
-```
-
-## What You Get
-
-- A fully configured `_bmad/` directory in your project
-- Agents and workflows configured for your selected modules and tools
-- A `_bmad-output/` folder for generated artifacts
-
-## Validation and Error Handling
-
-BMad validates all provided flags:
-
-- **Directory** — Must be a valid path with write permissions
-- **Modules** — Warns about invalid module IDs (but won't fail)
-- **Tools** — Warns about invalid tool IDs (but won't fail)
-- **Custom Content** — Each path must contain a valid `module.yaml` file
-- **Action** — Must be one of: `install`, `update`, `quick-update`
-
-Invalid values will either:
-1. Show an error and exit (for critical options like directory)
-2. Show a warning and skip (for optional items like custom content)
-3. Fall back to interactive prompts (for missing required values)
-
-:::tip[Best Practices]
-- Use absolute paths for `--directory` to avoid ambiguity
-- Test flags locally before using in CI/CD pipelines
-- Combine with `-y` for truly unattended installations
-- Use `--debug` if you encounter issues during installation
-:::
-
-## Troubleshooting
-
-### Installation fails with "Invalid directory"
-
-- The directory path must exist (or its parent must exist)
-- You need write permissions
-- The path must be absolute or correctly relative to the current directory
-
-### Module not found
-
-- Verify the module ID is correct
-- External modules must be available in the registry
-
-### Custom content path invalid
-
-Ensure each custom content path:
-- Points to a directory
-- Contains a `module.yaml` file in the root
-- Has a `code` field in the `module.yaml`
-
-:::note[Still stuck?]
-Run with `--debug` for detailed output, try interactive mode to isolate the issue, or report at <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
+:::note[This page has moved]
+Headless and CI install flags, channel selection, and pinning now live in the unified [How to Install BMad](./install-bmad.md) guide. Jump to the [Headless / CI installs](./install-bmad.md#headless-ci-installs) section for the flag reference and copy-paste recipes.
 :::

docs/how-to/project-context.md

@@ -1,16 +1,17 @@
 ---
-title: "Manage Project Context"
+title: 'Manage Project Context'
 description: Create and maintain project-context.md to guide AI agents
 sidebar:
-  order: 8
+  order: 9
 ---
 
 Use the `project-context.md` file to ensure AI agents follow your project's technical preferences and implementation rules throughout all workflows. To make sure this is always available, you can also add the line `Important project context and conventions are located in [path to project context]/project-context.md` to your tools context or always rules file (such as `AGENTS.md`)
 
 :::note[Prerequisites]
+
 - BMad Method installed
 - Understanding of your project's technology stack and conventions
-:::
+  :::
 
 ## When to Use This
 
@@ -60,14 +61,17 @@ sections_completed: ['technology_stack', 'critical_rules']
 ## 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
 ```
@@ -115,11 +119,12 @@ A `project-context.md` file that:
 ## Tips
 
 :::tip[Best Practices]
+
 - **Focus on the unobvious** — Document patterns agents might miss (e.g., "Use JSDoc on every public class"), not universal practices like "use meaningful variable names."
 - **Keep it lean** — This file is loaded by every implementation workflow. Long files waste context. Exclude content that only applies to narrow scope or specific stories.
 - **Update as needed** — Edit manually when patterns change, or re-generate after significant architecture changes.
 - Works for Quick Flow and full BMad Method projects alike.
-:::
+  :::
 
 ## Next Steps
 

docs/how-to/quick-fixes.md

@@ -1,8 +1,8 @@
 ---
-title: "Quick Fixes"
+title: 'Quick Fixes'
 description: How to make quick fixes and ad-hoc changes
 sidebar:
-  order: 5
+  order: 6
 ---
 
 Use **Quick Dev** for bug fixes, refactorings, or small targeted changes that don't require the full BMad Method.
@@ -15,9 +15,10 @@ Use **Quick Dev** for bug fixes, refactorings, or small targeted changes that do
 - Dependency updates
 
 :::note[Prerequisites]
+
 - BMad Method installed (`npx bmad-method install`)
 - An AI-powered IDE (Claude Code, Cursor, or similar)
-:::
+  :::
 
 ## Steps
 

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

@@ -1,8 +1,8 @@
 ---
-title: "Document Sharding Guide"
+title: 'Document Sharding Guide'
 description: Split large markdown files into smaller organized files for better context management
 sidebar:
-  order: 9
+  order: 10
 ---
 
 Use the `bmad-shard-doc` tool if you need to split large markdown files into smaller, organized files for better context management.

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

@@ -1,8 +1,8 @@
 ---
-title: "How to Upgrade to v6"
+title: 'How to Upgrade to v6'
 description: Migrate from BMad v4 to v6
 sidebar:
-  order: 3
+  order: 4
 ---
 
 Use the BMad installer to upgrade from v4 to v6, which includes automatic detection of legacy installations and migration assistance.
@@ -14,9 +14,10 @@ Use the BMad installer to upgrade from v4 to v6, which includes automatic detect
 - You have existing planning artifacts to preserve
 
 :::note[Prerequisites]
+
 - Node.js 20+
 - Existing BMad v4 installation
-:::
+  :::
 
 ## Steps
 
@@ -61,8 +62,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/index.md

@@ -33,7 +33,7 @@ These docs are organized into four sections based on what you're trying to do:
 | **Explanation**   | Understanding-oriented. Deep dives into concepts and architecture. Read when you want to know *why*.       |
 | **Reference**     | Information-oriented. Technical specifications for agents, workflows, and configuration.                   |
 
-## Extend and Customize
+## Expand and Customize
 
 Want to expand BMad with your own agents, workflows, or modules? The **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** provides the framework and tools for creating custom extensions, whether you're adding new capabilities to BMad or building entirely new modules from scratch.
 

docs/reference/agents.md

@@ -13,17 +13,14 @@ This page lists the default BMM (Agile suite) agents that install with BMad Meth
 
 - Each agent is available as a skill, generated by the installer. The skill ID (e.g., `bmad-dev`) is used to invoke the agent.
 - Triggers are the short menu codes (e.g., `CP`) and fuzzy matches shown in each agent menu.
-- QA (Quinn) is the lightweight test automation agent in BMM. The full Test Architect (TEA) lives in its own module.
+- QA test generation is handled by the `bmad-qa-generate-e2e-tests` workflow skill, available through the Developer agent. The full Test Architect (TEA) lives in its own module.
 
 | Agent                       | Skill ID             | Triggers                           | Primary workflows                                                                                   |
 | --------------------------- | -------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
-| Analyst (Mary)              | `bmad-analyst`       | `BP`, `RS`, `CB`, `DP`             | Brainstorm Project, Research, Create Brief, Document Project                                        |
+| Analyst (Mary)              | `bmad-analyst`       | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorm, Market Research, Domain Research, Technical 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`, `CR`                         | Dev Story, Code Review                                                                              |
-| QA Engineer (Quinn)         | `bmad-qa`            | `QA`                               | Automate (generate tests for existing features)                                                     |
-| Quick Flow Solo Dev (Barry) | `bmad-master`        | `QD`, `CR`                          | Quick Dev, 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.
 
@@ -92,6 +91,8 @@ Workflow skills run a structured, multi-step process without loading an agent pe
 
 | Example skill | Purpose |
 | --- | --- |
+| `bmad-product-brief` | Create a product brief — guided discovery when your concept is clear |
+| `bmad-prfaq` | [Working Backwards PRFAQ](../explanation/analysis-phase.md#prfaq-working-backwards) challenge to stress-test your product concept |
 | `bmad-create-prd` | Create a Product Requirements Document |
 | `bmad-create-architecture` | Design system architecture |
 | `bmad-create-epics-and-stories` | Create epics and stories |
@@ -123,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/reference/testing.md

@@ -1,15 +1,15 @@
 ---
 title: Testing Options
-description: Comparing the built-in QA agent (Quinn) with the Test Architect (TEA) module for test automation.
+description: Comparing the built-in QA workflow with the Test Architect (TEA) module for test automation.
 sidebar:
   order: 5
 ---
 
-BMad provides two testing paths: a built-in QA agent for fast test generation and an installable Test Architect module for enterprise-grade test strategy.
+BMad provides two testing paths: a built-in QA workflow for fast test generation and an installable Test Architect module for enterprise-grade test strategy.
 
 ## Which Should You Use?
 
-| Factor | Quinn (Built-in QA) | TEA Module |
+| Factor | Built-in QA | TEA Module |
 | --- | --- | --- |
 | **Best for** | Small-medium projects, quick coverage | Large projects, regulated or complex domains |
 | **Setup** | Nothing to install -- included in BMM | Install separately via `npx bmad-method install` |
@@ -18,19 +18,19 @@ BMad provides two testing paths: a built-in QA agent for fast test generation an
 | **Strategy** | Happy path + critical edge cases | Risk-based prioritization (P0-P3) |
 | **Workflow count** | 1 (Automate) | 9 (design, ATDD, automate, review, trace, and others) |
 
-:::tip[Start with Quinn]
-Most projects should start with Quinn. If you later need test strategy, quality gates, or requirements traceability, install TEA alongside it.
+:::tip[Start with built-in QA]
+Most projects should start with the built-in QA workflow. If you later need test strategy, quality gates, or requirements traceability, install TEA alongside it.
 :::
 
-## Built-in QA Agent (Quinn)
+## Built-in QA Workflow
 
-Quinn is the built-in QA agent in the BMM (Agile suite) module. It generates working tests quickly using your project's existing test framework -- no configuration or additional installation required.
+The built-in QA workflow (`bmad-qa-generate-e2e-tests`) is part of the BMM (Agile suite) module, available through the Developer agent. It generates working tests quickly using your project's existing test framework -- no configuration or additional installation required.
 
-**Trigger:** `QA` or `bmad-qa-generate-e2e-tests`
+**Trigger:** `QA` (via the Developer agent) or `bmad-qa-generate-e2e-tests`
 
-### What Quinn Does
+### What It Does
 
-Quinn runs a single workflow (Automate) that walks through five steps:
+The QA workflow (Automate) walks through five steps:
 
 1. **Detect test framework** -- scans `package.json` and existing test files for your framework (Jest, Vitest, Playwright, Cypress, or any standard runner). If none exists, analyzes the project stack and suggests one.
 2. **Identify features** -- asks what to test or auto-discovers features in the codebase.
@@ -38,7 +38,7 @@ Quinn runs a single workflow (Automate) that walks through five steps:
 4. **Generate E2E tests** -- covers user workflows with semantic locators and visible-outcome assertions.
 5. **Run and verify** -- executes the generated tests and fixes failures immediately.
 
-Quinn produces a test summary saved to your project's implementation artifacts folder.
+The workflow produces a test summary saved to your project's implementation artifacts folder.
 
 ### Test Patterns
 
@@ -51,10 +51,10 @@ Generated tests follow a "simple and maintainable" philosophy:
 - **Clear descriptions** that read as feature documentation
 
 :::note[Scope]
-Quinn generates tests only. For code review and story validation, use the Code Review workflow (`CR`) instead.
+The QA workflow generates tests only. For code review and story validation, use the Code Review workflow (`CR`) instead.
 :::
 
-### When to Use Quinn
+### When to Use Built-in QA
 
 - Quick test coverage for a new or existing feature
 - Beginner-friendly test automation without advanced setup
@@ -91,16 +91,16 @@ TEA also supports P0-P3 risk-based prioritization and optional integrations with
 - Teams that need risk-based test prioritization across many features
 - Enterprise environments with formal quality gates before release
 - Complex domains where test strategy must be planned before tests are written
-- Projects that have outgrown Quinn's single-workflow approach
+- Projects that have outgrown the built-in QA's single-workflow approach
 
 ## How Testing Fits into Workflows
 
-Quinn's Automate workflow appears in Phase 4 (Implementation) of the BMad Method workflow map. It is designed to run **after a full epic is complete** — once all stories in an epic have been implemented and code-reviewed. A typical sequence:
+The QA Automate workflow appears in Phase 4 (Implementation) of the BMad Method workflow map. It is designed to run **after a full epic is complete** — once all stories in an epic have been implemented and code-reviewed. A typical sequence:
 
 1. For each story in the epic: implement with Dev (`DS`), then validate with Code Review (`CR`)
-2. After the epic is complete: generate tests with Quinn (`QA`) or TEA's Automate workflow
+2. After the epic is complete: generate tests with `QA` (via the Developer agent) or TEA's Automate workflow
 3. Run retrospective (`bmad-retrospective`) to capture lessons learned
 
-Quinn works directly from source code without loading planning documents (PRD, architecture). TEA workflows can integrate with upstream planning artifacts for traceability.
+The built-in QA workflow works directly from source code without loading planning documents (PRD, architecture). TEA workflows can integrate with upstream planning artifacts for traceability.
 
 For more on where testing fits in the overall process, see the [Workflow Map](./workflow-map.md).

docs/reference/workflow-map.md

@@ -21,13 +21,14 @@ Final important note: Every workflow below can be run directly with your tool of
 
 ## Phase 1: Analysis (Optional)
 
-Explore the problem space and validate ideas before committing to planning.
+Explore the problem space and validate ideas before committing to planning. [**Learn what each tool does and when to use it**](../explanation/analysis-phase.md).
 
 | Workflow                        | Purpose                                                                    | Produces                  |
 | ------------------------------- | -------------------------------------------------------------------------- | ------------------------- |
 | `bmad-brainstorming`            | Brainstorm Project Ideas with guided facilitation of a brainstorming coach | `brainstorming-report.md` |
 | `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validate market, technical, or domain assumptions | Research findings |
-| `bmad-create-product-brief`     | Capture strategic vision                                                   | `product-brief.md`        |
+| `bmad-product-brief`            | Capture strategic vision — best when your concept is clear                 | `product-brief.md`        |
+| `bmad-prfaq`                    | Working Backwards — stress-test and forge your product concept             | `prfaq-{project}.md`      |
 
 ## Phase 2: Planning
 

docs/tutorials/getting-started.md

@@ -68,7 +68,7 @@ BMad helps you build software through guided workflows with specialized AI agent
 
 | Phase | Name           | What Happens                                        |
 | ----- | -------------- | --------------------------------------------------- |
-| 1     | Analysis       | Brainstorming, research, product brief *(optional)* |
+| 1     | Analysis       | Brainstorming, research, product brief or PRFAQ *(optional)* |
 | 2     | Planning       | Create requirements (PRD or spec)              |
 | 3     | Solutioning    | Design architecture *(BMad Method/Enterprise only)* |
 | 4     | Implementation | Build epic by epic, story by story                  |
@@ -133,10 +133,11 @@ Create it manually at `_bmad-output/project-context.md` or generate it after arc
 
 ### Phase 1: Analysis (Optional)
 
-All workflows in this phase are optional:
+All workflows in this phase are optional. [**Not sure which to use?**](../explanation/analysis-phase.md)
 - **brainstorming** (`bmad-brainstorming`) — Guided ideation
 - **research** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Market, domain, and technical research
-- **create-product-brief** (`bmad-create-product-brief`) — Recommended foundation document
+- **product-brief** (`bmad-product-brief`) — Recommended foundation document when your concept is clear
+- **prfaq** (`bmad-prfaq`) — Working Backwards challenge to stress-test and forge your product concept
 
 ### Phase 2: Planning (Required)
 
@@ -180,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
 
@@ -188,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
 
@@ -229,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              |
 
@@ -240,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/bmad-developer-guide.md

@@ -0,0 +1,826 @@
+---
+title: Hướng dẫn BMAD cho Developer
+description: Tài liệu tổng quan bằng tiếng Việt dành cho developer muốn áp dụng BMAD Method từ ý tưởng đến triển khai
+---
+
+# BMAD Method — Hướng dẫn toàn diện cho Developer
+
+> **BMAD** (Build More Architect Dreams) là framework phát triển phần mềm hỗ trợ bởi AI, giúp team đi từ ý tưởng đến sản phẩm một cách có cấu trúc, nhất quán và hiệu quả.
+
+---
+
+## Mục lục
+
+1. [BMAD là gì?](#1-bmad-là-gì)
+2. [Nguyên lý cốt lõi](#2-nguyên-lý-cốt-lõi)
+3. [Kiến trúc hệ thống — Các Agent](#3-kiến-trúc-hệ-thống--các-agent)
+4. [Quy trình làm việc — 4 Giai đoạn](#4-quy-trình-làm-việc--4-giai-đoạn)
+5. [Chọn nhánh phù hợp](#5-chọn-nhánh-phù-hợp)
+6. [Hướng dẫn từng bước áp dụng BMAD](#6-hướng-dẫn-từng-bước-áp-dụng-bmad)
+7. [Kiểm thử với BMAD — Hướng dẫn cho QC](#7-kiểm-thử-với-bmad--hướng-dẫn-cho-qc)
+8. [Các công cụ hỗ trợ](#8-các-công-cụ-hỗ-trợ)
+9. [Cấu trúc thư mục dự án](#9-cấu-trúc-thư-mục-dự-án)
+10. [Mẹo và Best Practices](#10-mẹo-và-best-practices)
+
+---
+
+## 1. BMAD là gì?
+
+**BMAD Method** là một hệ thống phối hợp nhiều AI agent chuyên biệt để hỗ trợ toàn bộ vòng đời phát triển phần mềm — từ phân tích ý tưởng, lập kế hoạch, thiết kế kiến trúc, đến triển khai code và kiểm thử.
+
+### Điểm khác biệt so với cách dùng AI thông thường
+
+| Cách thông thường | BMAD Method |
+|---|---|
+| Hỏi AI từng câu rời rạc | Workflow có cấu trúc, mỗi bước tạo đầu ra cho bước kế tiếp |
+| Một AI làm tất cả | Nhiều agent chuyên biệt, mỗi agent hiểu sâu vai trò của mình |
+| Không có tài liệu hóa | Mỗi giai đoạn sinh ra tài liệu chuẩn (PRD, Architecture, Stories) |
+| Developer phải giám sát liên tục | Agent tự chủ dài hơn, chỉ cần con người tại các điểm kiểm tra quan trọng |
+
+### BMAD phù hợp với ai?
+
+- **Developer** cần xây dựng tính năng nhanh, chất lượng cao
+- **Tech Lead / Architect** cần thiết kế hệ thống và phân rã công việc
+- **Product Manager** cần định nghĩa yêu cầu rõ ràng
+- **QC/Tester** cần sinh test case có truy vết yêu cầu
+- **Team nhỏ** muốn áp dụng quy trình chuẩn không cần nhiều overhead
+
+---
+
+## 2. Nguyên lý cốt lõi
+
+### 2.1. Tài liệu là "ngôn ngữ chung" giữa con người và AI
+
+Mỗi giai đoạn trong BMAD sinh ra một tài liệu chuẩn. Tài liệu đó trở thành **đầu vào** cho giai đoạn kế tiếp. Agent AI đọc tài liệu để hiểu context, thay vì phụ thuộc vào lịch sử hội thoại có thể bị mất.
+
+```
+Ý tưởng → [Brief/PRFAQ] → PRD → Architecture → Epics/Stories → Code → Tests
+```
+
+### 2.2. Phân tách "XÂY GÌ" và "XÂY NHƯ THẾ NÀO"
+
+BMAD tách bạch rõ ràng hai câu hỏi quan trọng nhất:
+
+- **Planning (Giai đoạn 2)**: Trả lời **"XÂY GÌ và vì sao?"** → Đầu ra: PRD
+- **Solutioning (Giai đoạn 3)**: Trả lời **"XÂY NHƯ THẾ NÀO?"** → Đầu ra: Architecture + Epics/Stories
+
+> Đây là nguyên lý quan trọng nhất. Nhiều dự án thất bại vì triển khai khi chưa thống nhất được "XÂY GÌ", hoặc bắt đầu code mà chưa quyết định "XÂY NHƯ THẾ NÀO".
+
+### 2.3. Agent chuyên biệt — mỗi vai trò một chuyên gia
+
+BMAD không dùng một AI đa năng mà dùng các agent được cấu hình để đóng vai chuyên gia cụ thể: PM, Architect, Developer, UX Designer, Technical Writer. Mỗi agent có phong cách tư duy, ưu tiên, và workflow riêng.
+
+### 2.4. Con người chỉ tham gia tại các điểm kiểm tra quan trọng
+
+BMAD được thiết kế để AI tự chủ trong phạm vi đã định nghĩa, chỉ đưa con người vào:
+
+- Phê duyệt chuyển giai đoạn (PRD xong → Architect làm việc)
+- Review kết quả tổng thể (sau Dev Story, sau epic)
+- Quyết định thay đổi hướng (Correct Course)
+
+### 2.5. Có thể mở rộng theo nhu cầu
+
+Ba nhánh lập kế hoạch với độ phức tạp tăng dần:
+
+| Nhánh | Phù hợp với | Story ước tính |
+|---|---|---|
+| **Quick Flow** | Bug fix, tính năng nhỏ, phạm vi rõ | 1–15 stories |
+| **BMad Method** | Sản phẩm, nền tảng, tính năng phức tạp | 10–50+ stories |
+| **Enterprise** | Hệ thống tuân thủ, đa tenant, đa team | 30+ stories |
+
+---
+
+## 3. Kiến trúc hệ thống — Các Agent
+
+### 3.1. Các Agent chính
+
+| Agent | Tên nhân vật | Skill ID | Vai trò |
+|---|---|---|---|
+| **Analyst** | Mary | `bmad-analyst` | Brainstorm, nghiên cứu thị trường/kỹ thuật, tạo Product Brief và PRFAQ |
+| **Product Manager** | John | `bmad-pm` | Tạo và quản lý PRD, Epics, Stories, kiểm tra Implementation Readiness |
+| **Architect** | Winston | `bmad-architect` | Thiết kế Architecture, ADR, kiểm tra Implementation Readiness |
+| **Developer** | Amelia | `bmad-agent-dev` | Triển khai story, tạo test, code review, sprint planning |
+| **UX Designer** | Sally | `bmad-ux-designer` | Thiết kế UX specification |
+| **Technical Writer** | Paige | `bmad-tech-writer` | Viết tài liệu, cập nhật standards, giải thích khái niệm |
+
+### 3.2. Cách gọi Agent
+
+**Qua Skill** (Claude Code / Cursor):
+```
+bmad-analyst
+bmad-pm
+bmad-architect
+bmad-agent-dev
+```
+
+**Qua Trigger** (sau khi đã nạp agent, gõ mã ngắn trong hội thoại):
+
+| Trigger | Agent | Workflow |
+|---|---|---|
+| `BP` | Analyst | Brainstorm |
+| `CB` | Analyst | Create Brief |
+| `CP` | PM | Create PRD |
+| `VP` | PM | Validate PRD |
+| `EP` | PM | Create Epics & Stories |
+| `CA` | Architect | Create Architecture |
+| `IR` | PM / Architect | Implementation Readiness |
+| `SP` | Developer | Sprint Planning |
+| `DS` | Developer | Dev Story |
+| `QA` | Developer | QA Test Generation |
+| `CR` | Developer | Code Review |
+
+---
+
+## 4. Quy trình làm việc — 4 Giai đoạn
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
+│   Giai đoạn 1   │    │   Giai đoạn 2   │    │   Giai đoạn 3    │    │   Giai đoạn 4   │
+│   PHÂN TÍCH     │───▶│   LẬP KẾ HOẠCH  │───▶│  ĐỊNH HÌNH GIẢI  │───▶│   TRIỂN KHAI    │
+│  (Tùy chọn)     │    │  (Bắt buộc)     │    │  PHÁP (BMad/Ent) │    │  (Bắt buộc)     │
+│                 │    │                 │    │                  │    │                 │
+│ Brief, PRFAQ    │    │ PRD, UX Spec    │    │ Architecture,    │    │ Sprint, Stories, │
+│ Research        │    │                 │    │ Epics, Stories   │    │ Code, Test, QA   │
+└─────────────────┘    └─────────────────┘    └──────────────────┘    └─────────────────┘
+```
+
+### Giai đoạn 1: Phân tích (Tùy chọn)
+
+Giai đoạn này giúp khám phá và xác nhận ý tưởng **trước khi** cam kết lập kế hoạch chi tiết. Bỏ qua nếu yêu cầu đã rõ.
+
+**Các công cụ:**
+
+**Brainstorming** — Khi cần khai phá ý tưởng
+```
+Trigger: BP (trong agent Analyst)
+Đầu ra: brainstorming-report.md
+```
+Sử dụng 60+ kỹ thuật brainstorming, tạo 100+ ý tưởng đa dạng, sau đó phân tích, lọc và đề xuất hướng tiếp cận.
+
+**Product Brief** — Khi concept đã tương đối rõ
+```
+Trigger: CB (trong agent Analyst)
+Đầu ra: product-brief.md
+```
+Tóm tắt điều hành 1–2 trang: vấn đề, giải pháp, đối tượng, lợi thế cạnh tranh, rủi ro.
+
+**PRFAQ** — Khi cần stress-test concept
+```
+Trigger: (hỏi Analyst về PRFAQ)
+Đầu ra: prfaq.md
+```
+Phương pháp "Working Backwards" của Amazon: viết thông cáo báo chí như thể sản phẩm đã tồn tại, sau đó trả lời các câu hỏi khó nhất từ khách hàng. Buộc phải rõ ràng theo hướng lấy khách hàng làm trung tâm.
+
+**Nghiên cứu** — Xác thực giả định
+```
+Trigger: MR (Market Research), DR (Domain Research), TR (Technical Research)
+```
+
+---
+
+### Giai đoạn 2: Lập kế hoạch (Bắt buộc)
+
+Xác định rõ **cần xây gì** và **cho ai**.
+
+**Tạo PRD** — PM Agent
+```
+Trigger: CP
+Đầu ra: PRD.md
+```
+PRD bao gồm: mục tiêu sản phẩm, functional requirements (FR), non-functional requirements (NFR), user stories cấp cao, acceptance criteria.
+
+**Thiết kế UX** — UX Designer Agent (Tùy chọn)
+```
+Trigger: CU
+Đầu ra: ux-spec.md
+```
+Dùng khi UX/UI là yếu tố quan trọng. Bao gồm user flows, component specs, interaction patterns.
+
+**Validate PRD** — PM Agent
+```
+Trigger: VP
+```
+Kiểm tra tính đầy đủ, nhất quán, và khả năng triển khai của PRD trước khi chuyển sang giai đoạn 3.
+
+---
+
+### Giai đoạn 3: Định hình giải pháp (Bắt buộc với BMad Method / Enterprise)
+
+Quyết định **xây như thế nào** và phân rã công việc.
+
+**Tạo Architecture** — Architect Agent
+```
+Trigger: CA
+Đầu ra: architecture.md + ADR (Architecture Decision Records)
+```
+Bao gồm: tech stack, component design, data models, API contracts, deployment strategy, ADR cho các quyết định quan trọng.
+
+**Tạo Epics & Stories** — PM Agent
+```
+Trigger: EP
+Đầu ra: epics/ thư mục với các file story
+```
+Phân rã PRD và Architecture thành Epics (nhóm tính năng) và Stories (đơn vị công việc cụ thể). Mỗi story có: mô tả, acceptance criteria, technical notes.
+
+**Implementation Readiness Check** — Architect Agent
+```
+Trigger: IR
+Kết quả: PASS / CONCERNS / FAIL
+```
+Cổng kiểm tra trước khi bắt đầu triển khai. Đảm bảo mọi thứ đã đủ rõ ràng để developer có thể làm việc độc lập.
+
+---
+
+### Giai đoạn 4: Triển khai (Bắt buộc)
+
+Xây dựng từng story một theo thứ tự ưu tiên.
+
+**Sprint Planning** — Developer Agent
+```
+Trigger: SP
+Đầu ra: sprint-status.yaml
+```
+Xác định stories sẽ làm trong sprint, thứ tự ưu tiên và tracking.
+
+**Dev Story** — Developer Agent
+```
+Trigger: DS
+Đầu ra: Code chạy được + unit/integration tests
+```
+Agent tự chủ triển khai story theo acceptance criteria. Đọc architecture và project-context để đảm bảo nhất quán.
+
+**Code Review** — Developer Agent
+```
+Trigger: CR
+Kết quả: Approved / Changes Requested
+```
+Review tự động: correctness, style, security, performance, test coverage.
+
+**QA Test Generation** — Developer Agent
+```
+Trigger: QA
+Đầu ra: API tests + E2E tests
+```
+Sinh test case cho API và E2E sau khi epic hoàn tất. Chi tiết ở [Mục 7](#7-kiểm-thử-với-bmad--hướng-dẫn-cho-qc).
+
+**Correct Course** — PM Agent
+```
+Trigger: CC
+```
+Xử lý thay đổi yêu cầu lớn giữa sprint mà không phá vỡ quy trình.
+
+**Retrospective** — Developer Agent
+```
+Trigger: ER (Epic Retrospective)
+```
+Review sau khi hoàn tất một epic. Ghi lại bài học, pattern tốt, vấn đề gặp phải.
+
+---
+
+## 5. Chọn nhánh phù hợp
+
+### Quick Flow — Nhánh nhanh
+
+**Khi nào dùng:**
+- Bug fix
+- Tính năng nhỏ, phạm vi rõ ràng
+- Cập nhật đơn lẻ (1–15 stories)
+- Bạn đã hiểu đầy đủ yêu cầu
+
+**Bỏ qua:** Giai đoạn 1, 2, 3 hoàn toàn
+
+**Dùng:** Quick Dev (`bmad-quick-dev`)
+
+```
+Mô tả yêu cầu → Làm rõ ý định → Sinh spec → Triển khai → Review → Done
+```
+
+Quick Dev gộp tất cả vào một workflow: làm rõ yêu cầu, lập kế hoạch mini, triển khai, code review, và trình bày kết quả.
+
+---
+
+### BMad Method — Nhánh đầy đủ
+
+**Khi nào dùng:**
+- Sản phẩm mới hoặc nền tảng
+- Tính năng phức tạp với nhiều dependencies
+- 10–50+ stories cần phối hợp nhiều developer
+
+**Đi qua:** Giai đoạn 1 (tùy chọn) → 2 → 3 → 4
+
+---
+
+### Enterprise — Nhánh mở rộng
+
+**Khi nào dùng:**
+- Hệ thống đa tenant
+- Yêu cầu tuân thủ (compliance), security audit
+- 30+ stories, nhiều team
+- Cần truy vết yêu cầu đầy đủ
+
+**Thêm vào:** Security review, DevOps pipeline, NFR assessment, Test Architect Module (TEA)
+
+---
+
+## 6. Hướng dẫn từng bước áp dụng BMAD
+
+### 6.1. Dự án mới
+
+#### Bước 1: Cài đặt BMAD
+
+```bash
+# Yêu cầu: Node.js 20+, Git
+npx bmad-method install
+```
+
+Trình cài đặt sẽ hỏi:
+- IDE đang dùng (Claude Code, Cursor, hoặc tương tự)
+- Modules muốn cài (core bắt buộc, thêm TEA nếu cần test nâng cao)
+- Nhánh lập kế hoạch (Quick Flow / BMad Method / Enterprise)
+
+#### Bước 2: Khởi động với bmad-help
+
+```
+bmad-help
+```
+
+Đây là điểm bắt đầu thông minh. Agent sẽ hỏi về dự án của bạn và dẫn bạn đến đúng workflow.
+
+```
+bmad-help Tôi có ý tưởng về ứng dụng SaaS quản lý task, bắt đầu từ đâu?
+bmad-help Tôi cần thêm tính năng export PDF, dùng quick flow hay đầy đủ?
+```
+
+#### Bước 3: Tạo Project Context (khuyến nghị mạnh)
+
+```bash
+# Tạo tự động sau khi có architecture
+bmad-generate-project-context
+
+# Hoặc tạo thủ công
+touch _bmad-output/project-context.md
+```
+
+File `project-context.md` là "bản hiến pháp" kỹ thuật của dự án — được tất cả agent tự động nạp:
+
+```markdown
+# Project Context
+
+## Technology Stack
+- Node.js 20.x, TypeScript 5.3
+- React 18.2, Zustand (không dùng Redux)
+- PostgreSQL 15, Prisma ORM
+- Testing: Vitest, Playwright, MSW
+
+## Critical Implementation Rules
+- Bật strict mode — không dùng `any`
+- Dùng `interface` cho public API, `type` cho union/intersection
+- API calls phải qua `apiClient` singleton
+- Components đặt trong `/src/components/` với co-located tests
+```
+
+#### Bước 4: Chạy Analysis (nếu cần)
+
+```bash
+# Mở agent Analyst
+bmad-analyst
+
+# Trong hội thoại, gõ trigger:
+BP    # Brainstorm ý tưởng
+CB    # Tạo Product Brief
+MR    # Research thị trường
+```
+
+#### Bước 5: Tạo PRD
+
+```bash
+# Mở agent PM
+bmad-pm
+
+# Trigger tạo PRD
+CP    # Create PRD (có hướng dẫn từng bước)
+VP    # Validate PRD sau khi hoàn thiện
+```
+
+#### Bước 6: Tạo Architecture (BMad Method / Enterprise)
+
+```bash
+# Mở agent Architect
+bmad-architect
+
+# Trigger
+CA    # Create Architecture
+IR    # Implementation Readiness Check
+```
+
+#### Bước 7: Tạo Epics & Stories
+
+```bash
+# Mở agent PM
+bmad-pm
+
+# Trigger
+EP    # Create Epics and Stories
+```
+
+#### Bước 8: Triển khai theo Stories
+
+```bash
+# Mở agent Developer
+bmad-agent-dev
+
+# Mỗi sprint
+SP    # Sprint Planning
+DS    # Dev Story (làm từng story)
+CR    # Code Review
+QA    # Tạo tests (sau khi epic hoàn tất)
+ER    # Epic Retrospective
+```
+
+---
+
+### 6.2. Dự án đã tồn tại
+
+#### Bước 1: Tạo Project Context từ codebase hiện tại
+
+```bash
+# Chạy trong agent Developer hoặc Architect
+bmad-generate-project-context
+```
+
+Agent sẽ khám phá codebase và tạo `project-context.md` từ:
+- `package.json`, `pyproject.toml`, hoặc build files
+- Cấu trúc thư mục
+- Conventions hiện có trong code
+
+#### Bước 2: Tạo tài liệu index
+
+Tạo hoặc cập nhật `docs/index.md` với:
+- Mục tiêu kinh doanh của dự án
+- Architecture overview
+- Các quy tắc quan trọng cần giữ
+
+#### Bước 3: Chọn cách tiếp cận phù hợp
+
+- **Thay đổi nhỏ** (bug fix, tính năng nhỏ): Dùng `bmad-quick-dev` trực tiếp
+- **Thay đổi lớn** (module mới, refactor lớn): Dùng BMad Method đầy đủ từ Giai đoạn 2
+
+#### Bước 4: Quick Dev cho việc nhỏ
+
+```bash
+# Mở skill Quick Dev
+bmad-quick-dev
+
+# Mô tả yêu cầu, agent sẽ:
+# 1. Làm rõ ý định (có người trong vòng lặp)
+# 2. Tạo mini-spec nếu cần
+# 3. Triển khai tự động
+# 4. Code review
+# 5. Trình bày kết quả để bạn approve
+```
+
+---
+
+### 6.3. Luồng làm việc mẫu — Tính năng mới (BMad Method)
+
+```
+Ngày 1-2: Analysis
+  ├── bmad-analyst → CB → product-brief.md
+  └── (tùy chọn) bmad-analyst → MR → market-research.md
+
+Ngày 2-3: Planning  
+  ├── bmad-pm → CP → PRD.md
+  ├── bmad-pm → VP (validate)
+  └── (nếu có UI) bmad-ux-designer → CU → ux-spec.md
+
+Ngày 3-4: Solutioning
+  ├── bmad-architect → CA → architecture.md
+  ├── bmad-pm → EP → epics/ (stories)
+  └── bmad-architect → IR → PASS ✓
+
+Ngày 5+: Implementation (lặp lại cho mỗi story)
+  ├── bmad-agent-dev → SP → sprint-status.yaml
+  ├── bmad-agent-dev → DS → code + tests
+  ├── bmad-agent-dev → CR → approved
+  └── (sau epic) bmad-agent-dev → QA → e2e tests
+```
+
+---
+
+## 7. Kiểm thử với BMAD — Hướng dẫn cho QC
+
+BMAD cung cấp hai hướng tiếp cận kiểm thử:
+
+### 7.1. QA tích hợp sẵn — Nhẹ nhàng (Developer Agent)
+
+**Phù hợp với:** Dự án nhỏ–trung bình, cần bao phủ test nhanh
+
+**Kích hoạt:**
+```bash
+# Trong agent Developer
+bmad-agent-dev
+
+# Sau khi hoàn tất một epic (tất cả stories đã dev + review xong)
+QA    # QA Test Generation
+```
+
+**5 bước workflow QA:**
+
+1. **Phát hiện framework**: Agent tự nhận diện Jest, Vitest, Playwright, Cypress từ codebase
+2. **Xác định tính năng cần test**: Dựa vào stories và acceptance criteria của epic vừa hoàn tất
+3. **Tạo API tests**: Status codes, cấu trúc response, happy path, edge cases
+4. **Tạo E2E tests**: User workflows, semantic locators (role/label/text — không dùng CSS selector)
+5. **Chạy và xác minh**: Tự chạy tests, phát hiện và sửa lỗi ngay
+
+**Các nguyên tắc khi sinh test:**
+
+```typescript
+// ✅ Dùng semantic locator
+await page.getByRole('button', { name: 'Đăng nhập' }).click()
+await page.getByLabel('Email').fill('user@example.com')
+
+// ❌ Không dùng CSS selector cứng
+await page.locator('.btn-primary#login').click()
+
+// ✅ Test độc lập, không phụ thuộc thứ tự
+test('create task', async () => {
+  // setup riêng cho test này
+})
+
+// ❌ Không hardcode wait/sleep
+await page.waitForTimeout(3000) // Không làm thế này
+```
+
+**Khi nào dùng:**
+- Cần bao phủ test nhanh cho tính năng mới
+- Dự án nhỏ–trung bình không cần chiến lược kiểm thử nâng cao
+- Muốn tự động hóa kiểm thử mà không cần thiết lập phức tạp
+
+---
+
+### 7.2. Module Test Architect (TEA) — Nâng cao
+
+**Phù hợp với:** Dự án lớn, miền nghiệp vụ phức tạp, cần truy vết yêu cầu
+
+**Cài đặt:**
+```bash
+npx bmad-method install
+# Chọn thêm module: TEA (Test Architect)
+```
+
+**Agent TEA:** Murat (Master Test Architect)
+
+**9 workflow của TEA:**
+
+| # | Workflow | Mục đích |
+|---|---|---|
+| 1 | **Test Design** | Tạo chiến lược kiểm thử gắn với yêu cầu (PRD/AC) |
+| 2 | **ATDD** | Phát triển hướng Acceptance Test — viết test trước khi code |
+| 3 | **Automate** | Tạo automated test với pattern nâng cao |
+| 4 | **Test Review** | Kiểm tra chất lượng và độ bao phủ của bộ test |
+| 5 | **Traceability** | Liên kết test ngược về yêu cầu trong PRD |
+| 6 | **NFR Assessment** | Đánh giá yêu cầu phi chức năng (performance, security, reliability) |
+| 7 | **CI Setup** | Cấu hình thực thi test trong CI/CD pipeline |
+| 8 | **Framework Scaffolding** | Dựng hạ tầng test cho dự án mới |
+| 9 | **Release Gate** | Ra quyết định go/no-go dựa trên chất lượng |
+
+**Hệ thống ưu tiên P0–P3:**
+
+| Mức | Ý nghĩa | Ví dụ |
+|---|---|---|
+| **P0** | Critical — phải pass 100% | Thanh toán, xác thực, bảo mật |
+| **P1** | High — phải pass cho release | Core business flow |
+| **P2** | Medium — nên pass | Tính năng phụ, edge cases |
+| **P3** | Low — test khi có thể | UI detail, minor UX |
+
+**Luồng ATDD với TEA:**
+
+```
+QC viết Acceptance Criteria (AC) → 
+TEA tạo test từ AC (trước khi code) → 
+Developer implement để test pass → 
+TEA verify traceability (AC ↔ test ↔ requirement) → 
+Release Gate go/no-go
+```
+
+---
+
+### 7.3. So sánh hai hướng tiếp cận
+
+| Yếu tố | QA tích hợp sẵn | Module TEA |
+|---|---|---|
+| Thời điểm test | Sau khi epic hoàn tất | Có thể trước khi code (ATDD) |
+| Thiết lập | Không cần cài thêm | Cài module riêng |
+| Loại test | API + E2E | API, E2E, ATDD, NFR, Performance |
+| Truy vết yêu cầu | Không | Có (Traceability workflow) |
+| Release gate | Không | Có (go/no-go) |
+| Phù hợp nhất | Dự án nhỏ–trung bình | Dự án lớn, có compliance |
+
+---
+
+### 7.4. Vị trí kiểm thử trong vòng đời dự án
+
+```
+Story 1: Dev → Code Review → ✓
+Story 2: Dev → Code Review → ✓
+Story 3: Dev → Code Review → ✓
+...
+Epic hoàn tất → QA Test Generation → Tests pass → Epic Retrospective
+```
+
+> **Lưu ý:** QA Test Generation chạy **sau khi toàn bộ epic hoàn tất**, không phải sau từng story. Mục đích là kiểm thử tích hợp các stories với nhau.
+
+---
+
+### 7.5. Edge Case Hunter — Công cụ tìm trường hợp biên
+
+Ngoài QA workflow, Developer Agent còn hỗ trợ:
+
+```bash
+# Trong hội thoại với Developer Agent
+bmad-review-edge-case-hunter
+```
+
+Phân tích toàn bộ nhánh điều kiện trong code để tìm:
+- Trường hợp biên chưa được xử lý
+- Null/undefined checks bị thiếu
+- Điều kiện race condition
+- Input validation gaps
+
+---
+
+## 8. Các công cụ hỗ trợ
+
+### 8.1. Party Mode — Thảo luận đa agent
+
+```bash
+bmad-party-mode
+```
+
+Triệu tập nhiều agent vào cùng một hội thoại để thảo luận các quyết định quan trọng:
+
+- **Kiến trúc**: PM + Architect + Developer cùng đánh giá trade-off
+- **Tính năng phức tạp**: UX Designer + Architect + PM
+- **Post-mortem**: Tất cả agent cùng phân tích sự cố
+- **Sprint retrospective**: PM + Developer + QC
+
+### 8.2. Advanced Elicitation — Tinh luyện đầu ra
+
+```bash
+bmad-advanced-elicitation
+```
+
+Buộc AI xem xét lại đầu ra bằng các phương pháp:
+
+| Phương pháp | Mục đích |
+|---|---|
+| **Pre-mortem** | Giả sử thất bại → lần ngược nguyên nhân |
+| **First Principles** | Loại bỏ giả định, bắt đầu từ sự thật cơ bản |
+| **Red Team / Blue Team** | Tự tấn công, tự bảo vệ |
+| **Socratic Questioning** | Chất vấn mọi khẳng định |
+| **Constraint Removal** | Bỏ ràng buộc → thấy giải pháp khác |
+| **Stakeholder Mapping** | Đánh giá từ góc nhìn từng bên liên quan |
+
+Dùng sau khi có một tài liệu quan trọng (PRD, Architecture) để tìm điểm yếu trước khi tiếp tục.
+
+### 8.3. Adversarial Review — Review hoài nghi
+
+```bash
+bmad-review-adversarial-general
+```
+
+Review kiểu "devil's advocate" — giả định vấn đề luôn tồn tại:
+- Phải tìm được tối thiểu 10 vấn đề
+- Tìm những gì **còn thiếu**, không chỉ những gì sai
+- Trực giao với Edge Case Hunter
+
+### 8.4. Distillator — Nén tài liệu cho LLM
+
+```bash
+bmad-distillator
+```
+
+Khi tài liệu quá lớn (PRD dài, Architecture phức tạp), Distillator nén nội dung tối ưu cho LLM mà không mất thông tin quan trọng.
+
+### 8.5. Shard Large Documents — Tách file lớn
+
+```bash
+bmad-shard-doc
+```
+
+Tách file markdown lớn thành các file phần nhỏ hơn, với index tự động.
+
+---
+
+## 9. Cấu trúc thư mục dự án
+
+Sau khi cài BMAD và chạy qua các giai đoạn, dự án sẽ có cấu trúc:
+
+```
+your-project/
+├── _bmad/                              # Cấu hình BMAD (không chỉnh sửa thủ công)
+│   ├── core/                           # Module core
+│   └── bmm/                            # Modules đã cài (TEA, v.v.)
+│
+├── _bmad-output/                       # Tất cả artifacts sinh ra
+│   ├── project-context.md              # Bản hiến pháp kỹ thuật của dự án
+│   ├── planning-artifacts/
+│   │   ├── product-brief.md            # Giai đoạn 1 output
+│   │   ├── PRD.md                      # Giai đoạn 2 output
+│   │   ├── ux-spec.md                  # Giai đoạn 2 output (nếu có)
+│   │   ├── architecture.md             # Giai đoạn 3 output
+│   │   └── epics/                      # Giai đoạn 3 output
+│   │       ├── epic-1-auth/
+│   │       │   ├── story-1-login.md
+│   │       │   ├── story-2-register.md
+│   │       │   └── story-3-reset-password.md
+│   │       └── epic-2-dashboard/
+│   └── implementation-artifacts/
+│       └── sprint-status.yaml          # Tracking sprint
+│
+├── .claude/skills/                     # Skills cho Claude Code
+│   ├── bmad-pm.md
+│   ├── bmad-architect.md
+│   └── ...
+│
+├── docs/                               # Tài liệu dự án
+│   └── index.md                        # Overview, goals, architecture notes
+│
+└── src/                                # Source code dự án
+```
+
+---
+
+## 10. Mẹo và Best Practices
+
+### Chat mới cho mỗi workflow
+
+> Luôn bắt đầu một hội thoại mới khi chuyển sang workflow khác.
+
+Mỗi workflow của BMAD thiết kế để chạy trong context rõ ràng. Việc tiếp tục hội thoại cũ có thể gây ra nhiễu context, đặc biệt với các workflow dài.
+
+### Đọc kỹ `project-context.md` trước khi bắt đầu sprint
+
+Tất cả agent developer tự động nạp `project-context.md`. Đảm bảo file này luôn cập nhật với:
+- Tech stack và phiên bản chính xác
+- Quy tắc implementation quan trọng
+- Patterns đang dùng trong codebase
+
+### Kiến trúc là bắt buộc khi có nhiều developer
+
+Nếu nhiều agent (hoặc developer) làm việc song song trên các stories khác nhau, kiến trúc phải được định nghĩa trước. Thiếu kiến trúc → các agent tạo ra code xung đột nhau.
+
+### Dùng bmad-help khi không chắc
+
+```
+bmad-help Tôi đang ở đâu trong workflow?
+bmad-help Story này nên dùng Quick Flow hay Dev Story?
+bmad-help Implementation Readiness check thất bại, làm gì tiếp?
+```
+
+### Quick Flow không có nghĩa là không có chất lượng
+
+Quick Dev vẫn có code review, vẫn tạo spec (mini), vẫn yêu cầu người approve kết quả. "Nhanh" ở đây là bỏ overhead lập kế hoạch không cần thiết, không phải bỏ qua chất lượng.
+
+### Customize agent theo nhu cầu team
+
+```yaml
+# .customize.yaml
+agents:
+  bmad-agent-dev:
+    persona: "Senior developer theo hướng TDD, luôn viết test trước"
+    rules:
+      - "Mọi function public phải có unit test"
+      - "Không dùng any trong TypeScript"
+```
+
+### Vị trí QA trong workflow
+
+```
+❌ Sai: Test sau mỗi story ngay lập tức
+✅ Đúng: Test sau khi toàn bộ epic hoàn tất (Dev + Code Review cho tất cả stories)
+```
+
+E2E test cần toàn bộ tính năng của epic để test integration. Test sớm hơn sẽ gặp dependency chưa sẵn sàng.
+
+---
+
+## Tài liệu tham khảo
+
+| Tài liệu | Đường dẫn |
+|---|---|
+| Getting Started | [tutorials/getting-started.md](tutorials/getting-started.md) |
+| Danh sách Agents | [reference/agents.md](reference/agents.md) |
+| Workflow Map | [reference/workflow-map.md](reference/workflow-map.md) |
+| Testing Reference | [reference/testing.md](reference/testing.md) |
+| Core Tools | [reference/core-tools.md](reference/core-tools.md) |
+| Modules | [reference/modules.md](reference/modules.md) |
+| Dự án đã tồn tại | [how-to/established-projects.md](how-to/established-projects.md) |
+| Project Context | [explanation/project-context.md](explanation/project-context.md) |
+| Quick Dev | [explanation/quick-dev.md](explanation/quick-dev.md) |
+| Why Solutioning Matters | [explanation/why-solutioning-matters.md](explanation/why-solutioning-matters.md) |
+| Cài đặt BMAD | [how-to/install-bmad.md](how-to/install-bmad.md) |
+
+---
+
+*Tài liệu này được tổng hợp từ bản dịch tiếng Việt của BMAD Method Documentation. Cập nhật lần cuối: 2026-04-15.*

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 phân tích: từ ý tưởng đến nền tảng"
+description: Động não, nghiên cứu, 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 phân tích (giai đoạn 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 phân tích thì PRD của bạn sẽ được dựng trên giả định thay vì hiểu biết thực chất.
+
+## Vì sao cần phân tích trước khi lập kế hoạch?
+
+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. Các story sinh ra từ một kiến trúc yếu sẽ bỏ sót trường hợp biên. Chi phí sẽ dồn lên theo từng tầng.
+
+Các công cụ phân tích 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 agent PM, bạn đã biết mình đang xây cái gì và cho ai.
+
+## Các công cụ
+
+### Động não
+
+**Nó là gì.** Một phiên sáng tạo có điều phối, sử dụng các kỹ thuật phát ý tưởng đã đượ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 yêu cầu. Động não 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 cam kết.
+
+**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ó ý tưởng ban đầu nhưng muốn kiểm chứng độ vững của nó bằng 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.
+
+### Nghiên cứu (thị trường, miền nghiệp vụ, kỹ thuật)
+
+**Nó là gì.** Ba quy trình nghiên cứu tập trung vào các chiều khác nhau của ý tưởng. Nghiên cứu thị trường xem xét đối thủ, xu hướng và cảm nhận của người dùng. Nghiên cứu miền nghiệp vụ xây dựng hiểu biết về lĩnh vực và thuật ngữ. Nghiên cứu kỹ thuật đá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. Nghiên cứu đặt ý tưởng 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 ý tưởng 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 quy trình đề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 giai đoạn lập kế hoạch. 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 ý tưởng 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.** Ý tưởng 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 giai đoạn lập kế hoạch. Nó buộc bạn đạt đến sự rõ ràng theo hướng lấy khách hàng làm trung tâm 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 kiểm tra độ vững của ý tưởng trước khi cam kết 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 giá trị cốt lõi 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 giai đoạn phân tích thì chuyện gì xảy ra?
+
+Đầu ra từ giai đoạn phân tích đi thẳng vào giai đoạn 2, lập kế hoạch. Quy trình tạo PRD chấp nhận product brief, tài liệu PRFAQ, kết quả nghiên cứu và báo cáo động não làm đầu vào. Nó sẽ tổng hợp bất cứ thứ gì bạn đã tạo thành các yêu cầu có cấu trúc. Bạn làm phân tích 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/checkpoint-preview.md

@@ -0,0 +1,92 @@
+---
+title: "Xem trước Checkpoint"
+description: Review có người trong vòng lặp với hỗ trợ của LLM, dẫn bạn đi qua thay đổi từ mục đích đến chi tiết
+sidebar:
+  order: 3
+---
+
+`bmad-checkpoint-preview` là một workflow review tương tác có người trong vòng lặp với hỗ trợ của LLM. Nó dẫn bạn đi qua một thay đổi mã nguồn, từ mục đích và bối cảnh đến các chi tiết quan trọng, để bạn có thể quyết định có nên phát hành, làm lại, hay đào sâu thêm.
+
+![Sơ đồ workflow Checkpoint Preview](/diagrams/checkpoint-preview-diagram.png)
+
+## Luồng điển hình
+
+Bạn chạy `bmad-quick-dev`. Nó làm rõ ý định của bạn, dựng spec, triển khai thay đổi, rồi khi xong sẽ nối thêm một review trail vào file spec và mở file đó trong editor. Bạn nhìn vào spec và thấy thay đổi này chạm tới 20 file, trải trên nhiều module.
+
+Bạn có thể tự liếc diff. Nhưng khoảng 20 file là lúc cách đó bắt đầu kém hiệu quả: bạn mất mạch, bỏ sót liên hệ giữa hai thay đổi ở xa nhau, hoặc duyệt một thứ mà bạn chưa thực sự hiểu. Thay vì vậy, bạn nói "checkpoint" và LLM sẽ dẫn bạn đi qua thay đổi.
+
+Điểm bàn giao đó, từ triển khai tự động quay lại phán đoán của con người, chính là tình huống sử dụng chính. Quick-dev có thể chạy khá lâu với rất ít giám sát. Checkpoint Preview là nơi bạn cầm lại tay lái.
+
+## Vì sao nó tồn tại
+
+Code review có hai kiểu thất bại. Kiểu đầu là người review lướt qua diff, không thấy gì nổi bật và bấm duyệt. Kiểu thứ hai là họ đọc rất kỹ từng file nhưng lại mất mạch tổng thể, thấy từng cái cây mà bỏ lỡ cả khu rừng. Cả hai đều dẫn tới cùng một kết quả: lần review đã không bắt được điều thực sự quan trọng.
+
+Vấn đề cốt lõi nằm ở thứ tự tiếp nhận. Một raw diff trình bày thay đổi theo thứ tự file, gần như không bao giờ là thứ tự giúp xây dựng hiểu biết. Bạn thấy một helper function trước khi biết vì sao nó tồn tại. Bạn thấy một schema change trước khi hiểu tính năng nào đang dùng nó. Người review phải tự dựng lại ý đồ của tác giả từ những manh mối rời rạc, và chính ở bước dựng lại đó sự tập trung thường bị đứt.
+
+Checkpoint Preview giải quyết việc này bằng cách để LLM làm phần dựng lại. Nó đọc diff, spec nếu có, và codebase xung quanh, rồi trình bày thay đổi theo một thứ tự phục vụ việc hiểu, chứ không theo `git diff`.
+
+## Nó hoạt động như thế nào
+
+Workflow này có năm bước. Mỗi bước xây trên bước trước, dần dần chuyển từ "đây là gì?" sang "chúng ta có nên phát hành nó không?"
+
+### 1. Định hướng
+
+Workflow xác định thay đổi đó là gì, từ PR, commit, branch, file spec, hoặc trạng thái git hiện tại, rồi tạo một câu tóm tắt ý định và vài số liệu bề mặt: số file thay đổi, số module bị chạm tới, số dòng logic, số lần băng qua ranh giới, và các public interface mới.
+
+Đây là khoảnh khắc "đúng là thứ tôi đang nghĩ tới chứ?". Trước khi đọc mã, người review xác nhận mình đang nhìn đúng thay đổi và cân chỉnh kỳ vọng về phạm vi.
+
+### 2. Dẫn giải thay đổi (Walkthrough)
+
+Thay đổi được tổ chức theo **mối quan tâm** như validation đầu vào hay API contract, thay vì theo file. Mỗi mối quan tâm có một giải thích ngắn về *vì sao* cách tiếp cận này được chọn, kèm theo các điểm dừng `path:line` có thể bấm để người review đi theo xuyên suốt code.
+
+Đây là bước dùng phán đoán về thiết kế. Người review đánh giá xem hướng tiếp cận có đúng với hệ thống hay không, chứ chưa phải xem code có chính xác tuyệt đối hay không. Các mối quan tâm được sắp từ trên xuống: ý định cấp cao trước, phần triển khai hỗ trợ sau. Người review sẽ không gặp tham chiếu tới thứ mà họ chưa thấy.
+
+### 3. Soi chi tiết
+
+Sau khi người review đã hiểu thiết kế, workflow sẽ đưa ra 2 đến 5 điểm mà nếu sai thì hậu quả lan rộng nhất. Chúng được gắn nhãn theo loại rủi ro như `[auth]`, `[schema]`, `[billing]`, `[public API]`, `[security]` và các nhãn khác, đồng thời được sắp theo mức độ thiệt hại nếu sai.
+
+Đây không phải là một cuộc săn bug. Tính đúng đắn được CI và test tự động lo phần lớn. Bước soi chi tiết nhằm kích hoạt ý thức về rủi ro: "đây là những chỗ mà nếu sai thì cái giá phải trả cao nhất". Nếu muốn đào sâu một khu vực cụ thể, bạn có thể nói "đào sâu vào [khu vực]" để chạy một lần review lại tập trung vào tính đúng đắn.
+
+Nếu spec trước đó đã đi qua các vòng adversarial review, các phát hiện liên quan cũng được đưa ra ở đây. Không phải các bug đã được sửa, mà là những quyết định mà vòng review đó từng gắn cờ để người review hiện tại biết.
+
+### 4. Kiểm thử
+
+Workflow gợi ý 2 đến 5 cách quan sát thủ công để thấy thay đổi thực sự hoạt động. Không phải lệnh test tự động, mà là các quan sát tay giúp tăng niềm tin theo cách test suite không cho bạn được. Một tương tác UI để thử, một lệnh CLI để chạy, một request API để gửi, kèm kết quả kỳ vọng cho từng mục.
+
+Nếu thay đổi không có hành vi nào nhìn thấy được từ phía người dùng, workflow sẽ nói thẳng như vậy. Không bịa thêm việc cho có.
+
+### 5. Kết thúc
+
+Người review đưa ra quyết định: duyệt, làm lại, hay tiếp tục thảo luận. Nếu đang duyệt PR, workflow có thể hỗ trợ với `gh pr review --approve`. Nếu cần làm lại, nó sẽ giúp chẩn đoán vấn đề nằm ở cách tiếp cận, spec, hay phần triển khai, đồng thời hỗ trợ soạn phản hồi có thể hành động được và gắn với vị trí code cụ thể.
+
+## Đây là một cuộc hội thoại, không phải bản báo cáo
+
+Workflow trình bày từng bước như một điểm khởi đầu, không phải lời kết luận cuối cùng. Giữa các bước, hoặc ngay giữa một bước, bạn có thể trao đổi với LLM, hỏi thêm, phản biện cách nó đóng khung vấn đề, hoặc kéo thêm skill khác để lấy một góc nhìn khác:
+
+- **"run advanced elicitation on the error handling"** - ép LLM xem xét lại và tinh chỉnh phân tích cho một khu vực cụ thể
+- **"party mode on whether this schema migration is safe"** - kéo nhiều góc nhìn agent vào một cuộc tranh luận tập trung
+- **"run code review"** - tạo ra các phát hiện có cấu trúc với phân tích đối kháng và edge case
+
+Workflow checkpoint không khóa bạn vào một đường đi tuyến tính. Nó cho bạn cấu trúc khi bạn cần, và tránh cản đường khi bạn muốn tự khám phá. Năm bước ở đây để bảo đảm bạn nhìn được toàn cảnh, còn việc đi sâu đến mức nào ở mỗi bước và gọi thêm công cụ nào hoàn toàn là do bạn quyết định.
+
+## Lộ trình review (Review Trail)
+
+Bước dẫn giải thay đổi hoạt động tốt nhất khi nó có một **thứ tự review gợi ý (Suggested Review Order)**, tức một danh sách các điểm dừng do tác giả spec viết ra để dẫn người review đi qua thay đổi. Nếu spec có phần này, workflow sẽ dùng trực tiếp.
+
+Nếu không có review trail do tác giả tạo, workflow sẽ tự sinh một trail từ diff và bối cảnh codebase. Trail do máy sinh ra vẫn kém hơn trail do tác giả viết, nhưng vẫn tốt hơn rất nhiều so với việc đọc thay đổi theo thứ tự file.
+
+## Khi nào nên dùng
+
+Tình huống chính là bước bàn giao sau `bmad-quick-dev`: phần triển khai đã xong, file spec đang mở trong editor với review trail đã được nối thêm, và bạn cần quyết định có nên phát hành hay không. Lúc đó chỉ cần nói "checkpoint" là bắt đầu.
+
+Nó cũng hoạt động độc lập:
+
+- **Review một PR** - đặc biệt hữu ích khi PR có nhiều hơn vài file hoặc có thay đổi cắt ngang nhiều khu vực
+- **Làm quen với một thay đổi (onboard to a change)** - khi bạn cần hiểu chuyện gì đã xảy ra trên một branch mà bạn không phải người viết
+- **Review sprint (sprint review)** - workflow có thể nhặt các story được đánh dấu `review` trong file trạng thái sprint của bạn
+
+Bạn có thể gọi nó bằng cách nói "checkpoint" hoặc "dẫn tôi đi qua thay đổi này". Nó chạy được trong mọi terminal, nhưng sẽ phát huy tốt nhất trong IDE như VS Code, Cursor hoặc công cụ tương tự, vì workflow tạo tham chiếu `path:line` ở mọi bước. Trong terminal tích hợp của IDE, các tham chiếu đó có thể bấm được, nên bạn có thể nhảy qua lại giữa các file khi đi theo review trail.
+
+## Nó không phải là gì
+
+Checkpoint Preview không thay thế review tự động. Nó không chạy linter, type checker, hay test suite. Nó không chấm mức độ nghiêm trọng hay đưa ra kết luận pass/fail. Nó là một bản hướng dẫn đọc để giúp con người áp dụng phán đoán của mình vào đúng những chỗ đáng chú ý nhất.

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/named-agents.md

@@ -0,0 +1,94 @@
+---
+title: "Agent có tên riêng (Named Agents)"
+description: Vì sao các agent của BMad có tên, persona và bề mặt tùy chỉnh riêng, và điều đó mở khóa điều gì so với cách tiếp cận dựa trên menu hoặc prompt trống
+sidebar:
+  order: 1
+---
+
+Bạn nói: "Hey Mary, brainstorm với tôi nhé", và Mary được kích hoạt. Cô ấy chào bạn theo tên, bằng ngôn ngữ bạn đã cấu hình, với persona đặc trưng của riêng mình. Cô ấy nhắc rằng `bmad-help` luôn sẵn sàng. Rồi cô ấy bỏ qua menu và đi thẳng vào brainstorming vì ý định của bạn đã đủ rõ.
+
+Trang này giải thích điều gì thực sự đang diễn ra và vì sao BMad được thiết kế theo cách đó.
+
+## Chiếc ghế ba chân
+
+Mô hình agent của BMad đứng trên ba primitive kết hợp với nhau:
+
+| Thành phần nền (primitive) | Nó cung cấp gì | Nó nằm ở đâu |
+|---|---|---|
+| **Skill** | Năng lực, tức một việc rời rạc mà assistant có thể làm như brainstorming, viết PRD hay triển khai story | `.claude/skills/{skill-name}/SKILL.md` hoặc vị trí tương đương theo IDE |
+| **Named agent** | Tính liên tục của persona, tức một danh tính dễ nhận ra bọc quanh một nhóm skill có cùng giọng điệu, nguyên tắc và dấu hiệu nhận biết | Các skill có thư mục bắt đầu bằng `bmad-agent-*` |
+| **Customization** | Khả năng biến nó thành của riêng bạn: override để đổi hành vi của agent, thêm tích hợp MCP, thay template, chồng convention của tổ chức | `_bmad/custom/{skill-name}.toml` cho team và `.user.toml` cho cá nhân |
+
+Chỉ cần bỏ đi một chân là trải nghiệm sẽ sụp:
+
+- Skill mà không có agent sẽ thành danh sách khả năng mà người dùng phải tự nhớ tên hoặc mã
+- Agent mà không có skill sẽ chỉ là persona không có gì để làm
+- Không có customization thì mọi người đều nhận cùng một hành vi mặc định, và muốn thêm convention nội bộ là phải fork
+
+## Named agents mang lại điều gì
+
+BMad hiện có sáu named agent, mỗi agent gắn với một phase trong BMad Method:
+
+| Agent | Phase | Module |
+|---|---|---|
+| 📊 **Mary**, Chuyên viên phân tích nghiệp vụ (Business Analyst) | Analysis | market research, brainstorming, product briefs, PRFAQs |
+| 📚 **Paige**, Technical Writer | Analysis | project documentation, diagrams, doc validation |
+| 📋 **John**, Quản lý sản phẩm (Product Manager) | Planning | PRD creation, epic/story breakdown, implementation readiness |
+| 🎨 **Sally**, Nhà thiết kế UX (UX Designer) | Planning | UX design specifications |
+| 🏗️ **Winston**, Kiến trúc sư hệ thống (System Architect) | Solutioning | technical architecture, alignment checks |
+| 💻 **Amelia**, Kỹ sư cấp cao (Senior Engineer) | Implementation | story execution, quick-dev, code review, sprint planning |
+
+Mỗi agent có một danh tính hardcode gồm tên, chức danh, domain, và một lớp có thể tùy chỉnh gồm vai trò, nguyên tắc, phong cách giao tiếp, icon và menu. Bạn có thể viết lại nguyên tắc của Mary hoặc thêm menu item cho cô ấy, nhưng bạn không thể đổi tên cô ấy. Đó là chủ ý thiết kế. Nhận diện thương hiệu của agent phải sống sót qua lớp tùy chỉnh để câu "hey Mary" luôn kích hoạt đúng analyst, bất kể team đã nắn hành vi của cô ấy theo cách nào.
+
+## Luồng kích hoạt
+
+Khi bạn gọi một named agent, tám bước sau sẽ chạy theo thứ tự:
+
+1. **Resolve cấu hình agent**: merge `customize.toml` gốc với override của team và cá nhân qua một Python resolver dùng `tomllib`
+2. **Chạy các bước tiền xử lý (prepend steps)**: mọi hành vi pre-flight mà team đã cấu hình
+3. **Nhập persona**: danh tính hardcode cộng với vai trò, phong cách giao tiếp và nguyên tắc đã tùy chỉnh
+4. **Nạp persistent facts**: quy tắc tổ chức, ghi chú compliance, hoặc cả file được nạp qua tiền tố `file:`
+5. **Nạp config**: tên người dùng, ngôn ngữ giao tiếp, ngôn ngữ đầu ra, đường dẫn artifact
+6. **Chào người dùng**: lời chào cá nhân hóa, đúng ngôn ngữ cấu hình và có emoji prefix của agent để bạn nhìn là biết ai đang nói
+7. **Chạy các bước hậu xử lý (append steps)**: mọi bước thiết lập sau lời chào mà team đã cấu hình
+8. **Dispatch hoặc hiện menu**: nếu tin nhắn mở đầu của bạn khớp một menu item thì agent đi thẳng vào đó, nếu không thì hiện menu và chờ input
+
+Bước 8 là nơi ý định gặp năng lực. Câu "Hey Mary, brainstorm với tôi nhé" bỏ qua phần render menu vì `bmad-brainstorming` là một mapping quá rõ với mục `BP` trong menu của Mary. Nếu bạn nói mơ hồ, cô ấy chỉ hỏi lại một lần, ngắn gọn, chứ không biến xác nhận thành nghi thức. Nếu chẳng có mục nào phù hợp, cô ấy tiếp tục cuộc hội thoại như bình thường.
+
+## Vì sao không chỉ dùng menu
+
+Menu buộc người dùng phải chủ động học công cụ. Bạn phải nhớ brainstorming nằm dưới mã `BP` của analyst chứ không phải PM, và phải nhớ persona nào sở hữu nhóm khả năng nào. Toàn bộ gánh nặng nhận thức đó do công cụ đẩy sang cho người dùng.
+
+Named agents đảo ngược điều đó. Bạn chỉ cần nói điều mình muốn, với đúng người mình nghĩ tới, bằng ngôn từ tự nhiên. Agent biết họ là ai và họ làm gì. Khi ý định của bạn đủ rõ, họ chỉ việc bắt đầu.
+
+Menu vẫn còn đó như một phương án dự phòng, hiện ra khi bạn đang khám phá, và biến mất khi bạn không cần nó.
+
+## Vì sao không chỉ dùng prompt trống
+
+Prompt trống giả định rằng bạn biết "câu thần chú". "Giúp tôi brainstorm" có thể hiệu quả, nhưng "hãy ideate giúp tôi một ý tưởng SaaS" có thể cho kết quả khác, và đầu ra phụ thuộc khá nhiều vào cách bạn diễn đạt. Khi đó người dùng gần như phải kiêm luôn vai trò kỹ sư prompt (prompt engineer).
+
+Named agents thêm cấu trúc mà không đóng mất sự tự do. Persona giữ ổn định, năng lực thì dễ khám phá, và `bmad-help` luôn chỉ cách bạn một lệnh. Bạn không phải đoán agent làm được gì, nhưng cũng không cần học thuộc một cuốn manual để dùng nó.
+
+## Tùy chỉnh là công dân hạng nhất
+
+Chính mô hình customization làm cho cách tiếp cận này mở rộng được ra ngoài phạm vi của một lập trình viên đơn lẻ.
+
+Mỗi agent đi kèm một `customize.toml` với mặc định hợp lý. Team có thể commit override vào `_bmad/custom/bmad-agent-{role}.toml`. Mỗi cá nhân có thể chồng thêm sở thích riêng trong `.user.toml` bị gitignore. Resolver sẽ merge cả ba lớp tại thời điểm kích hoạt theo các quy tắc có tính dự đoán.
+
+Đa số người dùng không cần tự tay viết các file đó. Skill `bmad-customize` sẽ dẫn họ qua việc chọn đúng mục tiêu, quyết định override ở mức agent hay workflow, viết file và xác minh merge. Nhờ vậy bề mặt tùy chỉnh vẫn tiếp cận được với bất cứ ai hiểu ý định của mình, chứ không chỉ người rành TOML.
+
+Ví dụ cụ thể: một team commit một file yêu cầu Amelia luôn dùng Context7 MCP tool khi tra tài liệu thư viện, và fallback sang Linear nếu story không xuất hiện trong danh sách epic cục bộ. Từ đó mọi dev workflow mà Amelia dispatch như `dev-story`, `quick-dev`, `create-story`, `code-review` đều tự động thừa hưởng hành vi này mà không cần sửa source hay lặp lại cấu hình từng workflow.
+
+Ngoài ra còn có một bề mặt tùy chỉnh thứ hai cho các mối quan tâm *xuyên suốt*: `_bmad/config.toml`, `_bmad/config.user.toml`, `_bmad/custom/config.toml` và `_bmad/custom/config.user.toml`. Đây là nơi **agent roster** sống, tức các descriptor gọn nhẹ mà những skill như `bmad-party-mode`, `bmad-retrospective` và `bmad-advanced-elicitation` dùng để biết ai có mặt và phải nhập vai họ thế nào. Bạn có thể rebrand một agent cho cả tổ chức bằng team override, hoặc thêm những giọng hư cấu như Kirk, Spock hay một persona chuyên gia domain qua `.user.toml`, tất cả mà không cần đụng vào thư mục skill. File per-skill quyết định Mary *hành xử* như thế nào khi cô ấy kích hoạt; cấu hình trung tâm quyết định các skill khác *nhìn thấy* cô ấy ra sao khi quan sát toàn bộ đội hình.
+
+Để xem toàn bộ bề mặt tùy chỉnh và ví dụ thực tế:
+
+- [Cách tùy chỉnh BMad](../how-to/customize-bmad.md): tài liệu tham chiếu cho những gì có thể tùy chỉnh và merge diễn ra thế nào
+- [Cách mở rộng BMad cho tổ chức của bạn](../how-to/expand-bmad-for-your-org.md): năm recipe hoàn chỉnh trải từ quy tắc ở cấp agent, convention workflow, publish ra hệ thống ngoài, thay template đầu ra đến tùy chỉnh roster agent
+- Skill `bmad-customize`: trợ lý soạn cấu hình (authoring helper) có hướng dẫn để biến ý định thành một file override đúng chỗ và đã được kiểm chứng
+
+## Ý tưởng lớn hơn phía sau
+
+Hầu hết các trợ lý AI (AI assistant) ngày nay hoặc là menu, hoặc là prompt, và cả hai đều chuyển phần gánh nặng nhận thức sang người dùng. Agent có tên riêng kết hợp với skill có thể tùy chỉnh cho phép bạn trò chuyện với một đồng đội đã hiểu công việc, đồng thời cho phép tổ chức của bạn nắn đồng đội đó theo nhu cầu mà không cần fork.
+
+Lần tới khi bạn gõ "Hey Mary, brainstorm với tôi nhé" và cô ấy chỉ việc bắt tay vào làm, hãy để ý thứ đã *không* xảy ra. Không có slash command. Không có menu phải điều hướng. Không có lời nhắc gượng gạo về những gì cô ấy có thể làm. Chính sự vắng mặt đó mới là thiết kế.

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

@@ -0,0 +1,59 @@
+---
+title: "Chế độ Party"
+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: "Bối cảnh dự án"
+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: "Phát triển nhanh"
+description: Giảm ma sát có người trong vòng lặp mà vẫn giữ các điểm kiểm tra bảo vệ chất lượng đầu ra
+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 mô hình tự vận hành lâu hơn giữa các điểm kiểm tra, 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 rà soát 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 có người trong vòng lặp 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 mô hình có thể chạy tự chủ lâu hơn, nhưng chỉ sau khi quy trình đã 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
+
+Quy trình bắt đầu bằng việc để con người và mô hình 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 quy trình 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 trình theo dõi lỗi, đầu ra từ chế độ lập kế hoạch, đoạn văn bản sao chép 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, quy trình 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.
+
+Quy trình 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 đặc tả** - xác nhận rằng cách hiểu đã được chốt là đúng thứ cần xây
+- **Rà soát sản phẩm cuối** - điểm kiểm tra 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õ, quy trình sẽ quyết định đây có phải thay đổi thực hiện một lần là xong hay cần đi theo đường đầy đủ hơn. Những thay đổi nhỏ, phạm vi ảnh hưởng 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 để mô hình 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 đó, mô hình có thể tự gánh thêm công việc. Trên con đường đầy đủ, đặc tả đã được phê duyệt trở thành ranh giới mà mô hình 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 sửa đúng. Nếu code sai vì đặc tả yếu, thì vá diff cũng không phải cách sửa đúng. Quy trình đượ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ừ bước rà soát được dùng để xác định vấn đề đến từ ý định, quá trình tạo đặc tả, 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 phỏng vấn ý định có người trong vòng lặp, nhưng nó không giống một điểm kiểm tra lặp đi lặp lại. Quy trình cố gắng giảm thiểu những điểm kiểm tra lặp lại đó. Sau bước định hình ý định ban đầu, con người chủ yếu quay lại khi quy trình không thể tiếp tục an toàn nếu thiếu phán đoán, và ở cuối quy trình để rà soát 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 mẫu 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 mô hình, 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 rà soát không chỉ để tìm lỗi. Nó còn để định tuyến cách sửa mà không phá hỏng động lượng.
+
+Quy trình này hoạt động tốt nhất trên nền tảng có thể tạo 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 ngữ cảnh là một trụ cột trong thiết kế rà soát.
+
+Rà soát kiểu agent 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 chắp vá.
+
+Quick Dev xử lý cả hai bằng cách coi rà soát là bước phân loại.
+
+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, quy trình 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,395 @@
+---
+title: 'Cách tùy chỉnh BMad'
+description: Tùy chỉnh agent và workflow trong khi vẫn giữ khả năng tương thích khi cập nhật
+sidebar:
+  order: 8
+---
+
+Điều chỉnh persona của agent, chèn ngữ cảnh theo domain, thêm khả năng mới và cấu hình hành vi workflow mà không cần sửa các file đã cài. Các tùy chỉnh của bạn sẽ được giữ nguyên qua mọi lần cập nhật.
+
+:::tip[Không muốn tự viết TOML? Hãy dùng `bmad-customize`]
+Skill `bmad-customize` là trợ lý tạo cấu hình có hướng dẫn cho **bề mặt override agent/workflow theo từng skill** được mô tả trong tài liệu này. Nó quét những gì có thể tùy chỉnh trong bản cài đặt của bạn, giúp bạn chọn đúng bề mặt (agent hay workflow), ghi file override và xác minh merge đã áp dụng. Override ở mức cấu hình trung tâm (`_bmad/custom/config.toml`) chưa nằm trong phạm vi v1, nên phần đó vẫn cần viết tay theo mục Cấu hình trung tâm bên dưới. Hãy chạy skill này khi bạn muốn thay đổi theo từng skill; tài liệu này là phần tham chiếu cho *có thể tùy chỉnh gì* và merge hoạt động ra sao.
+:::
+
+## Khi nào nên dùng
+
+- Bạn muốn thay đổi tính cách hoặc phong cách giao tiếp của agent
+- Bạn cần cung cấp cho agent các "persistent facts" để luôn nhớ, ví dụ "tổ chức của chúng tôi chỉ dùng AWS"
+- Bạn muốn thêm các bước khởi động có tính thủ tục mà agent phải chạy mỗi phiên
+- Bạn muốn thêm menu item tùy chỉnh để gọi skill hoặc prompt riêng
+- Team của bạn cần các tùy chỉnh dùng chung được commit vào git, đồng thời vẫn cho phép mỗi cá nhân chồng thêm sở thích riê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))
+- Python 3.11+ có trên PATH của bạn (để chạy resolver; dùng stdlib `tomllib`, không cần `pip install`, `uv` hay virtualenv)
+- Một trình soạn thảo văn bản cho file TOML
+:::
+
+## Cách hoạt động
+
+Mỗi skill có thể tùy chỉnh đều đi kèm một file `customize.toml` chứa cấu hình mặc định. File này định nghĩa toàn bộ bề mặt tùy chỉnh của skill, nên hãy đọc nó để biết có thể chỉnh gì. Bạn **không bao giờ** sửa trực tiếp file này. Thay vào đó, bạn tạo các file override dạng thưa, chỉ chứa những trường bạn muốn đổi.
+
+### Mô hình override ba lớp
+
+```text
+Ưu tiên 1 (thắng): _bmad/custom/{skill-name}.user.toml  (cá nhân, bị gitignore)
+Ưu tiên 2:         _bmad/custom/{skill-name}.toml       (team/tổ chức, được commit)
+Ưu tiên 3 (gốc):   customize.toml của chính skill       (mặc định)
+```
+
+Thư mục `_bmad/custom/` ban đầu là rỗng. File chỉ xuất hiện khi ai đó thực sự bắt đầu tùy chỉnh.
+
+### Quy tắc merge theo hình dạng, không theo tên trường
+
+Resolver áp dụng bốn quy tắc cấu trúc. Tên trường không được hardcode riêng; hành vi hoàn toàn được quyết định bởi dạng dữ liệu:
+
+| Dạng | Quy tắc |
+|---|---|
+| Scalar (string, int, bool, float) | Giá trị override sẽ thắng |
+| Table | Deep merge, tức merge đệ quy theo các quy tắc này |
+| Mảng các table mà mọi phần tử đều dùng cùng **một** trường định danh (`code` ở tất cả phần tử, hoặc `id` ở tất cả phần tử) | Merge theo khóa đó, phần tử trùng khóa sẽ **thay tại chỗ**, phần tử mới sẽ **append** |
+| Mọi mảng khác (mảng scalar, table không có định danh, hoặc trộn `code` và `id`) | **Append**: phần tử gốc trước, rồi team, rồi user |
+
+**Không có cơ chế xóa.** Override không thể xóa phần tử mặc định. Nếu bạn cần vô hiệu hóa một menu item mặc định, hãy override nó theo `code` bằng mô tả hoặc prompt no-op. Nếu cần tái cấu trúc mảng sâu hơn, bạn phải fork skill.
+
+**Quy ước `code` / `id`.** BMad dùng `code` (định danh ngắn như `"BP"` hoặc `"R1"`) và `id` (định danh ổn định dài hơn) làm merge key cho mảng các table. Nếu bạn tự tạo một mảng table muốn có khả năng replace-by-key thay vì append-only, hãy chọn **một** quy ước duy nhất và dùng nhất quán cho toàn bộ mảng. Nếu trộn `code` ở phần tử này và `id` ở phần tử khác, resolver sẽ rơi về chế độ append vì nó không đoán merge theo khóa nào.
+
+### Một số trường của agent là chỉ đọc
+
+`agent.name` và `agent.title` vẫn nằm trong `customize.toml` như metadata nguồn gốc, nhưng `SKILL.md` của agent không đọc hai trường này ở runtime, vì danh tính của agent được hardcode. Bạn đặt `name = "Bob"` trong file override cũng sẽ không có tác dụng. Nếu bạn thật sự cần một agent với tên khác, hãy copy thư mục skill, đổi tên và phát hành nó như một custom skill.
+
+## Các bước thực hiện
+
+### 1. Tìm bề mặt tùy chỉnh của skill
+
+Hãy mở file `customize.toml` trong thư mục skill đã được cài. Ví dụ với PM agent:
+
+```text
+.claude/skills/bmad-agent-pm/customize.toml
+```
+
+(Đường dẫn cụ thể thay đổi theo IDE: Cursor dùng `.cursor/skills/`, Cline dùng `.cline/skills/`, v.v.)
+
+Đây là schema chính thức. Mọi trường bạn nhìn thấy trong file này đều có thể tùy chỉnh, ngoại trừ các trường danh tính chỉ đọc đã nêu ở trên.
+
+### 2. Tạo file override của bạn
+
+Tạo thư mục `_bmad/custom/` ở root dự án nếu nó chưa tồn tại. Sau đó tạo file đặt theo tên skill:
+
+```text
+_bmad/custom/
+  bmad-agent-pm.toml        # override của team (commit vào git)
+  bmad-agent-pm.user.toml   # sở thích cá nhân (gitignore)
+```
+
+:::caution[KHÔNG copy nguyên file `customize.toml`]
+File override phải **thưa**. Chỉ đưa vào những trường bạn thực sự muốn đổi, không hơn.
+
+Mọi trường bạn bỏ qua sẽ tự động được kế thừa từ lớp bên dưới. Nếu bạn copy toàn bộ `customize.toml` vào file override, những bản cập nhật sau này sẽ không chảy vào các giá trị mặc định mới nữa và bạn sẽ âm thầm bị lệch qua mỗi release.
+:::
+
+**Ví dụ: đổi icon và thêm một principle**
+
+```toml
+# _bmad/custom/bmad-agent-pm.toml
+# Chỉ ghi những trường cần đổi. Phần còn lại vẫn kế thừa.
+
+[agent]
+icon = "🏥"
+principles = [
+  "Không phát hành bất cứ thứ gì không thể vượt qua kiểm toán của FDA.",
+]
+```
+
+Ví dụ này append thêm principle mới vào danh sách mặc định và thay icon. Mọi trường khác vẫn giữ nguyên như bản gốc.
+
+### 3. Tùy chỉnh đúng phần bạn cần
+
+Mọi ví dụ bên dưới đều giả định schema agent phẳng của BMad. Các trường nằm trực tiếp trong `[agent]`, không có các sub-table như `metadata` hay `persona`.
+
+**Scalar (`icon`, `role`, `identity`, `communication_style`).** Scalar override sẽ thắng, nên bạn chỉ cần đặt những trường đang muốn đổi:
+
+```toml
+# _bmad/custom/bmad-agent-pm.toml
+
+[agent]
+icon = "🏥"
+role = "Dẫn dắt product discovery cho domain healthcare có ràng buộc pháp lý."
+communication_style = "Chính xác, nhạy với compliance, đặt các câu hỏi mang hình dạng kiểm soát ngay từ sớm."
+```
+
+**Persistent facts, principles, activation hooks (các mảng append).** Bốn mảng dưới đây đều là append-only. Phần tử của team được thêm sau mặc định, phần tử user được thêm cuối cùng.
+
+```toml
+[agent]
+# Các fact tĩnh mà agent luôn giữ trong đầu trong cả phiên: quy tắc tổ chức,
+# hằng số domain, sở thích của người dùng. Khác với runtime memory sidecar.
+#
+# Mỗi mục có thể là một câu literal, hoặc tham chiếu `file:` để nạp nội dung
+# file làm facts (hỗ trợ cả glob).
+persistent_facts = [
+  "Tổ chức của chúng tôi chỉ dùng AWS, không đề xuất GCP hay Azure.",
+  "Mọi PRD đều phải có legal sign-off trước khi engineering kickoff.",
+  "Người dùng mục tiêu là bác sĩ lâm sàng, không phải bệnh nhân, nên ví dụ phải bám theo đối tượng đó.",
+  "file:{project-root}/docs/compliance/hipaa-overview.md",
+  "file:{project-root}/_bmad/custom/company-glossary.md",
+]
+
+# Thêm vào hệ giá trị của agent
+principles = [
+  "Không phát hành bất cứ thứ gì không thể vượt qua kiểm toán của FDA.",
+  "Giá trị người dùng là trước hết, compliance là luôn luôn.",
+]
+
+# Chạy TRƯỚC activation tiêu chuẩn (persona, persistent_facts, config, greet).
+# Dùng cho pre-flight load, compliance checks, hoặc thứ gì cần có sẵn trong
+# context trước khi agent tự giới thiệu.
+activation_steps_prepend = [
+  "Quét {project-root}/docs/compliance/ và nạp mọi tài liệu liên quan HIPAA vào context.",
+]
+
+# Chạy SAU khi greet, TRƯỚC menu. Dùng cho thiết lập nặng về context mà bạn
+# muốn chạy sau khi người dùng đã được chào.
+activation_steps_append = [
+  "Đọc {project-root}/_bmad/custom/company-glossary.md nếu file tồn tại.",
+]
+```
+
+**Hai hook này có vai trò khác nhau.** `prepend` chạy trước lời chào để agent có thể nạp ngữ cảnh cần thiết ngay cả khi cá nhân hóa lời chào. `append` chạy sau lời chào để người dùng không phải nhìn màn hình trống trong lúc agent quét một lượng lớn context.
+
+**Tùy chỉnh menu (merge theo `code`).** Menu là một mảng table. Mỗi item có trường `code`, nên resolver merge theo mã này: item có `code` trùng sẽ thay tại chỗ, item mới sẽ được append.
+
+Với TOML array-of-tables, mỗi item dùng cú pháp `[[agent.menu]]`:
+
+```toml
+# Thay item CE hiện có bằng một custom skill
+[[agent.menu]]
+code = "CE"
+description = "Tạo Epic theo framework delivery của tổ chức"
+skill = "custom-create-epics"
+
+# Thêm item mới (RC chưa tồn tại trong mặc định)
+[[agent.menu]]
+code = "RC"
+description = "Chạy compliance pre-check"
+prompt = """
+Đọc {project-root}/_bmad/custom/compliance-checklist.md
+và quét toàn bộ tài liệu trong {planning_artifacts} theo checklist đó.
+Báo cáo mọi khoảng trống và trích dẫn điều khoản quy định tương ứng.
+"""
+```
+
+Mỗi menu item chỉ có đúng một trong hai trường `skill` hoặc `prompt`. Những item không xuất hiện trong file override của bạn sẽ giữ nguyên mặc định.
+
+**Tham chiếu file.** Khi một trường văn bản cần trỏ tới file (trong `persistent_facts`, `activation_steps_prepend`, `activation_steps_append`, hoặc `prompt` của menu item), hãy dùng đường dẫn đầy đủ dựa trên `{project-root}`. Dù file nằm cạnh override trong `_bmad/custom/`, bạn vẫn nên viết rõ là `{project-root}/_bmad/custom/info.md`. Agent sẽ resolve `{project-root}` ở runtime.
+
+### 4. Cá nhân và team
+
+**File của team** (`bmad-agent-pm.toml`): commit vào git, áp dụng cho cả tổ chức. Dùng cho compliance rules, company persona, năng lực tùy chỉnh dùng chung.
+
+**File cá nhân** (`bmad-agent-pm.user.toml`): tự động bị gitignore. Dùng cho điều chỉnh giọng điệu, sở thích workflow cá nhân và các fact riêng mà agent cần lưu ý cho riêng bạn.
+
+```toml
+# _bmad/custom/bmad-agent-pm.user.toml
+
+[agent]
+persistent_facts = [
+  "Khi trình bày phương án, luôn kèm ước lượng độ phức tạp ở mức thô (low/medium/high).",
+]
+```
+
+## Cách quá trình resolve diễn ra
+
+Khi agent được kích hoạt, `SKILL.md` của nó sẽ gọi một shared Python script để merge ba lớp nói trên và trả về block kết quả ở dạng JSON. Script này dùng `tomllib` của Python stdlib, nên `python3` thuần là đủ:
+
+```bash
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill {skill-root} \
+  --key agent
+```
+
+**Yêu cầu**: Python 3.11+ vì các phiên bản cũ hơn không có `tomllib`. Không cần `pip install`, không cần `uv`, không cần virtualenv. Bạn có thể kiểm tra bằng `python3 --version`. Trên một số nền tảng, `python3` mặc định vẫn là 3.10 hoặc thấp hơn, nên có thể bạn sẽ phải cài 3.11+ riêng.
+
+`--skill` trỏ vào thư mục skill đã cài, nơi có file `customize.toml`. Tên skill được lấy từ basename của thư mục, sau đó script sẽ tự tìm `_bmad/custom/{skill-name}.toml` và `{skill-name}.user.toml`.
+
+Một số lệnh hữu ích:
+
+```bash
+# Resolve toàn bộ block agent
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /duong-dan/tuyet-doi/toi/bmad-agent-pm \
+  --key agent
+
+# Resolve một trường cụ thể
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /duong-dan/tuyet-doi/toi/bmad-agent-pm \
+  --key agent.icon
+
+# Dump toàn bộ
+python3 {project-root}/_bmad/scripts/resolve_customization.py \
+  --skill /duong-dan/tuyet-doi/toi/bmad-agent-pm
+```
+
+Đầu ra luôn là JSON. Nếu script này không khả dụng trên một nền tảng nào đó, `SKILL.md` sẽ hướng dẫn agent đọc trực tiếp ba file TOML và áp dụng cùng các quy tắc merge.
+
+## Tùy chỉnh workflow
+
+Workflow, tức các skill điều phối tiến trình nhiều bước như `bmad-product-brief`, dùng cùng cơ chế override như agent. Khác biệt là bề mặt tùy chỉnh của chúng nằm dưới `[workflow]` thay vì `[agent]`:
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+# Giống agent: prepend/append chạy trước và sau activation mặc định của
+# workflow. Override sẽ append vào mặc định.
+activation_steps_prepend = [
+  "Nạp {project-root}/docs/product/north-star-principles.md làm context.",
+]
+
+activation_steps_append = []
+
+# Cũng dùng semantics literal-hoặc-file: như phía agent. Những fact này được
+# nạp làm context nền tảng trong suốt lần chạy workflow.
+persistent_facts = [
+  "Mọi brief đều phải có một mục explicit về regulatory risk.",
+  "file:{project-root}/docs/compliance/product-brief-checklist.md",
+]
+
+# Scalar: chạy đúng một lần khi workflow hoàn tất output chính. Override thắng.
+on_complete = "Tóm tắt brief trong ba gạch đầu dòng rồi hỏi người dùng có muốn gửi email qua skill gws-gmail-send không."
+```
+
+Cùng một quy ước trường có thể đi xuyên qua ranh giới agent/workflow: `activation_steps_prepend`, `activation_steps_append`, `persistent_facts` với tham chiếu `file:`, và các table kiểu menu `[[...]]` dùng `code` hoặc `id` làm khóa merge. Resolver áp dụng đúng bốn quy tắc cấu trúc đã nêu bất kể top-level key là gì. Tham chiếu từ `SKILL.md` cũng theo namespace tương ứng: `{workflow.activation_steps_prepend}`, `{workflow.persistent_facts}`, `{workflow.on_complete}`. Mọi trường bổ sung mà một workflow tự expose, ví dụ output path, toggle, review setting hay stage flag, cũng sẽ đi theo cùng cơ chế merge dựa trên shape. Muốn biết chính xác workflow đó cho chỉnh gì, hãy đọc `customize.toml` của nó.
+
+### Thứ tự activation
+
+Workflow có thể tùy chỉnh sẽ chạy activation theo thứ tự cố định để bạn biết hook của mình được kích hoạt khi nào:
+
+1. Resolve block `[workflow]` bằng merge base -> team -> user
+2. Chạy `activation_steps_prepend` theo đúng thứ tự
+3. Nạp `persistent_facts` làm ngữ cảnh nền tảng cho cả lần chạy
+4. Nạp config (`_bmad/bmm/config.yaml`) và resolve các biến chuẩn như tên dự án, ngôn ngữ, đường dẫn, ngày tháng
+5. Chào người dùng
+6. Chạy `activation_steps_append` theo đúng thứ tự
+
+Sau bước 6, phần thân chính của workflow mới bắt đầu. Hãy dùng `activation_steps_prepend` khi bạn cần load context trước cả lúc cá nhân hóa lời chào; dùng `activation_steps_append` khi phần thiết lập khá nặng và bạn muốn người dùng thấy lời chào trước.
+
+### Phạm vi của đợt triển khai đầu tiên này
+
+Khả năng tùy chỉnh đang được mở rộng dần. Những trường đã mô tả ở trên, gồm `activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`, là **bề mặt nền tảng** mà mọi workflow có thể tùy chỉnh đều sẽ hỗ trợ, và chúng sẽ ổn định qua các phiên bản. Ngày hôm nay, chỉ với những trường này bạn đã có thể kiểm soát những điểm lớn: thêm bước trước/sau, ghim context nền tảng, kích hoạt hành động tiếp theo sau khi workflow hoàn tất.
+
+Theo thời gian, từng workflow sẽ expose thêm **các điểm tùy chỉnh chuyên biệt hơn** gắn với chính công việc của workflow đó, ví dụ toggle ở từng bước, stage flag, đường dẫn template đầu ra hoặc review gate. Khi những trường đó xuất hiện, chúng sẽ được chồng thêm lên bề mặt nền tảng chứ không thay thế nó, nên những tùy chỉnh bạn viết hôm nay vẫn tiếp tục dùng được.
+
+Nếu bạn đang cần một "núm tinh chỉnh" chi tiết hơn nhưng workflow chưa expose, hãy tạm dùng `activation_steps_*` và `persistent_facts` để điều hướng hành vi, hoặc mở issue mô tả chính xác điểm tùy chỉnh bạn muốn. Chính những nhu cầu đó sẽ quyết định trường nào được bổ sung tiếp theo.
+
+## Cấu hình trung tâm
+
+`customize.toml` theo từng skill bao phủ **hành vi sâu** như hook, menu, `persistent_facts`, override persona cho một agent hay workflow đơn lẻ. Một bề mặt khác sẽ bao phủ **trạng thái cắt ngang** như các câu trả lời lúc cài đặt và roster agent mà những skill bên ngoài như `bmad-party-mode`, `bmad-retrospective` và `bmad-advanced-elicitation` sử dụng. Bề mặt đó nằm trong bốn file TOML ở root dự án:
+
+```text
+_bmad/config.toml               (do installer quản lý) team scope:   câu trả lời lúc cài đặt + agent roster
+_bmad/config.user.toml          (do installer quản lý) user scope:   user_name, language, skill level
+_bmad/custom/config.toml        (do con người viết)    team overrides (commit vào git)
+_bmad/custom/config.user.toml   (do con người viết)    personal overrides (gitignore)
+```
+
+### Merge bốn lớp
+
+```text
+Ưu tiên 1 (thắng): _bmad/custom/config.user.toml
+Ưu tiên 2:         _bmad/custom/config.toml
+Ưu tiên 3:         _bmad/config.user.toml
+Ưu tiên 4 (gốc):   _bmad/config.toml
+```
+
+Các quy tắc cấu trúc hoàn toàn giống phần per-skill customize: scalar override, table deep-merge, mảng dùng `code` hoặc `id` sẽ merge theo khóa, các mảng khác thì append.
+
+### Cái gì nằm ở đâu
+
+Installer sẽ phân chia câu trả lời theo `scope:` khai báo trên từng prompt trong `module.yaml`:
+
+- Các section `[core]` và `[modules.<code>]`: chứa câu trả lời khi cài. `scope = team` sẽ được ghi vào `_bmad/config.toml`; `scope = user` sẽ nằm trong `_bmad/config.user.toml`
+- Section `[agents.<code>]`: "bản chất" của agent gồm code, name, title, icon, description, team, được chưng cất từ khối `agents:` trong `module.yaml` của từng module. Phần này luôn ở scope team
+
+### Quy tắc chỉnh sửa
+
+- `_bmad/config.toml` và `_bmad/config.user.toml` sẽ **được tạo lại sau mỗi lần cài đặt** từ những câu trả lời mà installer thu thập. Hãy coi chúng là output chỉ đọc; mọi chỉnh sửa trực tiếp sẽ bị ghi đè ở lần cài tiếp theo. Nếu muốn thay đổi bền vững một giá trị cài đặt, hãy chạy lại installer hoặc chồng giá trị đó bằng `_bmad/custom/config.toml`
+- `_bmad/custom/config.toml` và `_bmad/custom/config.user.toml` sẽ **không bao giờ** bị installer động vào. Đây mới là bề mặt đúng để thêm custom agent, override descriptor của agent, ép các thiết lập dùng chung cho team và ghim mọi giá trị bạn muốn giữ nguyên bất kể câu trả lời lúc cài là gì
+
+### Ví dụ: đổi thương hiệu cho một agent
+
+```toml
+# _bmad/custom/config.toml (commit vào git, áp dụng cho mọi developer)
+
+[agents.bmad-agent-pm]
+description = "PM trong domain healthcare, nhạy với compliance, luôn đặt câu hỏi theo hướng FDA ngay từ đầu."
+icon = "🏥"
+```
+
+Resolver sẽ merge đè lên `[agents.bmad-agent-pm]` do installer sinh ra. `bmad-party-mode` và mọi roster consumer khác sẽ tự động thấy description mới này.
+
+### Ví dụ: thêm một agent hư cấu
+
+```toml
+# _bmad/custom/config.user.toml (cá nhân, gitignore)
+
+[agents.kirk]
+team = "startrek"
+name = "Captain James T. Kirk"
+title = "Starship Captain"
+icon = "🖖"
+description = "Một chỉ huy táo bạo, thích bẻ luật. Nói chuyện có các quãng ngắt đầy kịch tính. Suy nghĩ thành tiếng về gánh nặng của quyền chỉ huy."
+```
+
+Không cần tạo thư mục skill. Chỉ riêng "essence" này cũng đủ để party-mode spawn Kirk như một giọng nói trong cuộc bàn tròn. Bạn có thể lọc theo trường `team` để chỉ mời nhóm Enterprise.
+
+### Ví dụ: override thiết lập cài đặt của module
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "/shared/org-planning-artifacts"
+```
+
+Giá trị override này sẽ thắng mọi câu trả lời mà từng developer đã nhập khi cài trên máy của họ. Rất hữu ích khi bạn muốn ghim convention của cả team.
+
+### Khi nào dùng bề mặt nào
+
+| Nhu cầu | Bề mặt nên dùng |
+|---|---|
+| Thêm lời nhắc gọi MCP tool vào mọi dev workflow | Theo từng skill: `_bmad/custom/bmad-agent-dev.toml` trong `persistent_facts` |
+| Thêm menu item cho một agent | Theo từng skill: `_bmad/custom/bmad-agent-{role}.toml` với `[[agent.menu]]` |
+| Đổi template đầu ra của một workflow | Theo từng skill: `_bmad/custom/{workflow}.toml` bằng scalar override |
+| Đổi descriptor công khai của một agent | **Cấu hình trung tâm**: `_bmad/custom/config.toml` ở `[agents.<code>]` |
+| Thêm custom agent hoặc agent hư cấu vào roster | **Cấu hình trung tâm**: `_bmad/custom/config*.toml` với entry mới `[agents.<code>]` |
+| Ghim thiết lập cài đặt dùng chung của team | **Cấu hình trung tâm**: `_bmad/custom/config.toml` trong `[modules.<code>]` hoặc `[core]` |
+
+Trong cùng một dự án, bạn hoàn toàn có thể dùng đồng thời cả hai bề mặt này.
+
+## Ví dụ thực chiến
+
+Để xem các recipe thiên về doanh nghiệp như định hình một agent trên mọi workflow mà nó dispatch, ép workflow tuân thủ convention nội bộ, publish output lên Confluence và Jira, tùy chỉnh agent roster, hoặc thay template đầu ra bằng template riêng của tổ chức, hãy xem [Cách mở rộng BMad cho tổ chức của bạn](./expand-bmad-for-your-org.md).
+
+## Khắc phục sự cố
+
+**Tùy chỉnh không xuất hiện?**
+
+- Kiểm tra file của bạn có nằm đúng trong `_bmad/custom/` và dùng đúng tên skill không
+- Kiểm tra cú pháp TOML: string phải có ngoặc kép, table header dùng `[section]`, array-of-tables dùng `[[section]]`, và mọi khóa scalar hay array của một table phải xuất hiện *trước* bất kỳ `[[subtables]]` nào của table đó trong file
+- Với agent, phần tùy chỉnh phải nằm dưới `[agent]`, và các trường bên dưới header đó sẽ thuộc `agent` cho tới khi bạn mở table header khác
+- Hãy nhớ rằng `agent.name` và `agent.title` là chỉ đọc, override vào đó sẽ không có tác dụng
+
+**Tùy chỉnh bị hỏng sau khi update?**
+
+- Bạn có copy nguyên file `customize.toml` vào file override không? **Đừng làm vậy.** File override chỉ nên chứa phần chênh lệch. Nếu copy nguyên file, bạn sẽ khóa cứng mặc định cũ và dần lệch khỏi các bản phát hành mới.
+
+**Muốn biết có thể tùy chỉnh gì?**
+
+- Chạy skill `bmad-customize`. Nó sẽ liệt kê mọi skill có thể tùy chỉnh trong dự án, cho biết skill nào đã có override, rồi dẫn bạn qua quá trình thêm hoặc sửa một override
+- Hoặc đọc trực tiếp `customize.toml` của skill. Mọi trường ở đó đều có thể tùy chỉnh, trừ `name` và `title`
+
+**Muốn reset?**
+
+- Xóa file override của bạn trong `_bmad/custom/`, skill sẽ tự động rơi về cấu hình mặc định tích hợp sẵn

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/expand-bmad-for-your-org.md

@@ -0,0 +1,266 @@
+---
+title: 'Cách mở rộng BMad cho tổ chức của bạn'
+description: Năm mẫu tùy chỉnh giúp thay đổi BMad mà không cần fork, gồm quy tắc ở cấp agent, quy ước workflow, xuất bản ra hệ thống ngoài, thay template và điều chỉnh danh sách agent
+sidebar:
+  order: 9
+---
+
+Bề mặt tùy chỉnh của BMad cho phép một tổ chức định hình lại hành vi mà không phải sửa file đã cài hay fork skill. Hướng dẫn này trình bày năm công thức mẫu (recipe) bao phủ phần lớn nhu cầu ở môi trường doanh nghiệp.
+
+:::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))
+- Đã quen với mô hình tùy chỉnh (xem [Cách tùy chỉnh BMad](./customize-bmad.md))
+- Python 3.11+ có trên PATH để chạy resolver, chỉ dùng stdlib, không cần `pip install`
+:::
+
+:::tip[Cách áp dụng các công thức mẫu này]
+Những **công thức mẫu theo từng skill** bên dưới, tức Recipe 1 đến Recipe 4, có thể được áp dụng bằng cách chạy skill `bmad-customize` rồi mô tả ý định. Skill này sẽ tự chọn đúng bề mặt, viết file override và xác minh kết quả merge. Riêng Recipe 5, tức override cấu hình trung tâm để chỉnh danh sách agent (agent roster), hiện chưa nằm trong phạm vi v1 của skill nên vẫn cần viết tay. Các recipe trong trang này là nguồn sự thật cho phần *nên override cái gì*; `bmad-customize` phụ trách phần *thực hiện ra sao* ở lớp agent/workflow.
+:::
+
+## Mô hình ba lớp để suy nghĩ
+
+Trước khi chọn recipe, bạn cần biết override của mình sẽ rơi vào đâu:
+
+| Lớp | Nơi override sống | Phạm vi |
+|---|---|---|
+| **Agent** như Amelia, Mary, John | section `[agent]` trong `_bmad/custom/bmad-agent-{role}.toml` | Đi cùng persona vào **mọi workflow mà agent đó dispatch** |
+| **Workflow** như `product-brief`, `create-prd` | section `[workflow]` trong `_bmad/custom/{workflow-name}.toml` | Chỉ áp dụng cho lần chạy của workflow đó |
+| **Cấu hình trung tâm** | `[agents.*]`, `[core]`, `[modules.*]` trong `_bmad/custom/config.toml` | Agent roster và các thiết lập lúc cài đặt cần ghim cho cả tổ chức |
+
+Nguyên tắc ngón tay cái:
+
+- Nếu quy tắc nên áp dụng ở mọi nơi một engineer làm dev work, hãy tùy chỉnh **dev agent**
+- Nếu nó chỉ áp dụng khi ai đó viết product brief, hãy tùy chỉnh **workflow product-brief**
+- Nếu nó thay đổi *ai đang ngồi trong phòng* như đổi thương hiệu agent, thêm custom voice hoặc ép chung một artifact path, hãy sửa **cấu hình trung tâm**
+
+## Recipe 1: định hình một agent trên mọi workflow mà nó điều phối (dispatch)
+
+**Trường hợp dùng (use case):** Chuẩn hóa việc dùng công cụ và tích hợp với hệ thống bên ngoài để mọi workflow được dispatch qua agent đó tự động thừa hưởng cùng hành vi. Đây là mẫu áp dụng (pattern) có sức ảnh hưởng lớn nhất.
+
+**Ví dụ:** Amelia, tức dev agent, luôn dùng Context7 cho tài liệu thư viện và fallback sang Linear nếu không tìm thấy story trong danh sách epic.
+
+```toml
+# _bmad/custom/bmad-agent-dev.toml
+
+[agent]
+
+# Áp dụng ở mọi lần kích hoạt. Theo Amelia đi vào dev-story, quick-dev,
+# create-story, code-review, qa-generate và mọi skill cô ấy dispatch.
+persistent_facts = [
+  "Với mọi truy vấn tài liệu thư viện như React, TypeScript, Zod, Prisma..., hãy gọi Context7 MCP tool (`mcp__context7__resolve_library_id` rồi `mcp__context7__get_library_docs`) trước khi dựa vào kiến thức trong dữ liệu huấn luyện (training data). Tài liệu cập nhật phải thắng API đã ghi nhớ.",
+  "Khi không tìm thấy tham chiếu story trong {planning_artifacts}/epics-and-stories.md, hãy tìm trong Linear bằng `mcp__linear__search_issues` theo ID hoặc tiêu đề story trước khi yêu cầu người dùng làm rõ. Nếu Linear trả về kết quả khớp, coi đó là nguồn story có thẩm quyền.",
+]
+```
+
+**Vì sao cách này hiệu quả:** Chỉ với hai câu, bạn đã thay đổi mọi dev workflow trong tổ chức mà không lặp config từng nơi và không sửa source. Mọi engineer mới kéo repo về đều tự động thừa hưởng convention đó.
+
+**File của team và file cá nhân**
+
+- `bmad-agent-dev.toml`: commit vào git, áp dụng cho cả team
+- `bmad-agent-dev.user.toml`: bị gitignore, dùng cho sở thích cá nhân chồng thêm lên trên
+
+## Recipe 2: ép convention của tổ chức bên trong một workflow cụ thể
+
+**Trường hợp dùng (use case):** Định hình *nội dung đầu ra* của một workflow để nó đáp ứng yêu cầu compliance, audit hoặc hệ thống downstream.
+
+**Ví dụ:** mọi product brief đều phải có các trường compliance, và agent biết convention xuất bản của tổ chức.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+persistent_facts = [
+  "Mọi brief phải có trường 'Owner', 'Target Release' và 'Security Review Status'.",
+  "Các brief không mang tính thương mại như công cụ nội bộ hoặc dự án nghiên cứu vẫn phải có phần user value, nhưng có thể bỏ phân biệt cạnh tranh thị trường.",
+  "file:{project-root}/docs/enterprise/brief-publishing-conventions.md",
+]
+```
+
+**Điều gì xảy ra:** Những fact này được nạp trong quá trình activation của workflow. Khi agent soạn brief, nó đã biết các trường bắt buộc và tài liệu convention nội bộ. Mặc định có sẵn, ví dụ `file:{project-root}/**/project-context.md`, vẫn tiếp tục được nạp vì phần này chỉ append thêm.
+
+## Recipe 3: xuất bản kết quả hoàn tất sang hệ thống ngoài
+
+**Trường hợp dùng (use case):** Sau khi workflow tạo ra output chính, tự động đẩy nó sang hệ thống nguồn sự thật của doanh nghiệp như Confluence, Notion, SharePoint, rồi mở tiếp công việc follow-up trong Jira, Linear hoặc Asana.
+
+**Ví dụ:** brief được tự động publish lên Confluence và tùy chọn mở Jira epic.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+
+# Hook ở giai đoạn cuối. Scalar override sẽ thay hẳn mặc định rỗng.
+on_complete = """
+Publish và đề nghị bước tiếp theo:
+
+1. Đọc đường dẫn file brief đã hoàn tất từ bước trước.
+2. Gọi `mcp__atlassian__confluence_create_page` với:
+   - space: "PRODUCT"
+   - parent: "Product Briefs"
+   - title: tiêu đề của brief
+   - body: nội dung markdown của brief
+   Lưu lại URL trang được trả về.
+3. Thông báo cho người dùng: "Brief đã được publish lên Confluence: <url>".
+4. Hỏi: "Bạn có muốn tôi mở Jira epic cho brief này ngay bây giờ không?"
+5. Nếu có, gọi `mcp__atlassian__jira_create_issue` với:
+   - type: "Epic"
+   - project: "PROD"
+   - summary: tiêu đề của brief
+   - description: tóm tắt ngắn cùng liên kết ngược về trang Confluence.
+   Sau đó báo lại epic key và URL.
+6. Nếu không, thoát sạch.
+
+Nếu một trong các MCP tool bị lỗi, hãy báo lỗi, in ra đường dẫn brief
+và yêu cầu người dùng publish thủ công.
+"""
+```
+
+**Vì sao dùng `on_complete` thay vì `activation_steps_append`:** `on_complete` chỉ chạy đúng một lần ở cuối, sau khi output chính của workflow đã được ghi ra. Đó là thời điểm đúng để publish artifact. `activation_steps_append` thì chạy mỗi lần kích hoạt, trước khi workflow làm công việc chính của nó.
+
+**Điểm đánh đổi (trade-offs)**
+
+- Publish lên Confluence là hành động không phá hủy, nên có thể luôn chạy khi hoàn tất
+- Tạo Jira epic là hành động hiển thị cho cả team và kích hoạt các tín hiệu sprint planning, nên nên chặn bởi một bước xác nhận từ người dùng
+- Nếu MCP tool lỗi, workflow phải có phương án dự phòng (fallback) rõ ràng thay vì âm thầm làm mất output
+
+## Recipe 4: thay output template bằng template của riêng bạn
+
+**Trường hợp dùng (use case):** Cấu trúc đầu ra mặc định không khớp định dạng mà tổ chức mong muốn, hoặc trong cùng một repo có nhiều tổ chức cần template riêng.
+
+**Ví dụ:** trỏ workflow product-brief sang template do doanh nghiệp sở hữu.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml
+
+[workflow]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+```
+
+**Cách nó hoạt động:** `customize.toml` của workflow đi kèm `brief_template = "resources/brief-template.md"` dưới dạng đường dẫn tương đối tới skill root. Override của bạn lại trỏ tới một file trong `{project-root}`, nên agent sẽ đọc template của bạn trong bước tương ứng thay vì dùng template mặc định đi kèm.
+
+**Mẹo viết template**
+
+- Giữ template trong `{project-root}/docs/` hoặc `{project-root}/_bmad/custom/templates/` để nó được version cùng với file override
+- Nên dùng cùng convention cấu trúc với template mặc định, ví dụ heading và frontmatter, để agent có điểm tựa ổn định
+- Với repo đa tổ chức, hãy dùng `.user.toml` để từng nhóm nhỏ có thể trỏ sang template riêng mà không cần sửa file dùng chung của team
+
+## Recipe 5: tùy chỉnh danh sách agent (agent roster)
+
+**Trường hợp dùng (use case):** Thay đổi *ai đang ngồi trong phòng* cho những skill dựa trên roster như `bmad-party-mode`, `bmad-retrospective` và `bmad-advanced-elicitation`, mà không cần sửa source hay fork. Dưới đây là ba biến thể thường gặp.
+
+### 5a. Rebrand một agent của BMad trên toàn tổ chức
+
+Mỗi agent thật đều có một descriptor được installer tổng hợp từ `module.yaml`. Bạn có thể override descriptor này để đổi giọng điệu và framing ở mọi roster consumer:
+
+```toml
+# _bmad/custom/config.toml (commit vào git, áp dụng cho mọi developer)
+
+[agents.bmad-agent-analyst]
+description = "Mary, nhà phân tích nghiệp vụ giàu nhận thức pháp lý, pha trộn Porter với Minto nhưng sống cùng các audit trail của FDA. Cô ấy nói như một điều tra viên pháp chứng đang trình bày hồ sơ vụ án."
+```
+
+Party mode sẽ spawn Mary với description mới này. Bản thân activation của analyst vẫn chạy bình thường vì hành vi của Mary sống trong `customize.toml` theo từng skill. Override này chỉ thay đổi cách **các skill bên ngoài nhìn thấy và giới thiệu cô ấy**, chứ không thay đổi cách cô ấy hoạt động bên trong.
+
+### 5b. Thêm một agent hư cấu hoặc agent tự định nghĩa
+
+Chỉ cần một descriptor đầy đủ là đủ cho các tính năng dựa trên roster, không cần thư mục skill. Điều này rất phù hợp nếu bạn muốn tăng màu sắc tính cách cho party mode hay các buổi brainstorming:
+
+```toml
+# _bmad/custom/config.user.toml (cá nhân, gitignore)
+
+[agents.spock]
+team = "startrek"
+name = "Commander Spock"
+title = "Science Officer"
+icon = "🖖"
+description = "Logic là trên hết, cảm xúc bị nén lại. Mở đầu nhận xét bằng 'Fascinating.' Không bao giờ làm tròn lên. Là đối trọng với mọi lập luận chỉ dựa vào linh cảm."
+
+[agents.mccoy]
+team = "startrek"
+name = "Dr. Leonard McCoy"
+title = "Chief Medical Officer"
+icon = "⚕️"
+description = "Sự ấm áp của một bác sĩ miền quê, đi kèm với tính nóng nảy. 'Dammit Jim, I'm a doctor not a ___.' Là đối trọng đạo đức với Spock."
+```
+
+Khi bạn yêu cầu party-mode "mời nhóm Star Trek" hoặc "mời phi hành đoàn Enterprise", nó sẽ lọc theo `team = "startrek"` và spawn Spock cùng McCoy dựa trên các descriptor đó. Các agent thật của BMad như Mary hay Amelia vẫn có thể ngồi cùng bàn nếu bạn muốn.
+
+### 5c. Ghim thiết lập cài đặt dùng chung cho cả team
+
+Installer sẽ hỏi từng developer các giá trị như đường dẫn `planning_artifacts`. Khi tổ chức muốn có một câu trả lời thống nhất, hãy ghim nó trong cấu hình trung tâm. Khi đó, mọi câu trả lời cục bộ của từng người sẽ bị override lúc resolve:
+
+```toml
+# _bmad/custom/config.toml
+
+[modules.bmm]
+planning_artifacts = "{project-root}/shared/planning"
+implementation_artifacts = "{project-root}/shared/implementation"
+
+[core]
+document_output_language = "English"
+```
+
+Những thiết lập cá nhân như `user_name`, `communication_language` hoặc `user_skill_level` nên vẫn nằm trong `_bmad/config.user.toml` riêng của từng developer. File chung của team không nên đụng vào các giá trị đó.
+
+**Vì sao việc này nằm ở cấu hình trung tâm thay vì per-agent customize.toml:** File per-agent chỉ định hình cách *một* agent hành xử khi nó được kích hoạt. Cấu hình trung tâm lại định hình những gì các roster consumer *nhìn thấy khi quan sát cánh đồng chung*: agent nào tồn tại, tên gì, thuộc team nào và các thiết lập cài đặt dùng chung mà toàn repo đã thống nhất. Hai bề mặt khác nhau, hai công việc khác nhau.
+
+## Củng cố các quy tắc toàn cục trong file hướng dẫn phiên của IDE
+
+Tùy chỉnh của BMad chỉ được nạp khi một skill được kích hoạt. Trong khi đó, nhiều công cụ IDE còn nạp một file hướng dẫn toàn cục ở **đầu mọi phiên**, trước cả khi skill nào chạy, như `CLAUDE.md`, `AGENTS.md`, `.cursor/rules/` hay `.github/copilot-instructions.md`. Với những quy tắc phải đúng cả khi bạn đang chat thường, hãy lặp lại phiên bản rút gọn của chúng trong file đó nữa.
+
+**Khi nào nên "đánh đôi"**
+
+- Quy tắc đó đủ quan trọng đến mức một cuộc chat thường, chưa kích hoạt BMad skill nào, cũng vẫn phải tuân theo
+- Bạn muốn áp dụng kiểu "gia cố hai lớp" (belt-and-suspenders) vì hành vi mặc định từ dữ liệu huấn luyện (training data) có thể kéo model đi chệch
+- Quy tắc đủ ngắn để lặp lại mà không làm file hướng dẫn đầu phiên trở nên phình to
+
+**Ví dụ:** một dòng trong `CLAUDE.md` của repo để củng cố quy tắc ở Recipe 1.
+
+```markdown
+<!-- Mọi lần đọc tài liệu thư viện phải đi qua Context7 MCP tool
+(`mcp__context7__resolve_library_id` rồi `mcp__context7__get_library_docs`)
+trước khi dựa vào kiến thức từ dữ liệu huấn luyện (training data). -->
+```
+
+Chỉ một câu, nhưng được nạp ở mọi phiên. Nó kết hợp với cấu hình `bmad-agent-dev.toml` để quy tắc có hiệu lực cả trong workflow của Amelia lẫn trong các cuộc trò chuyện ad-hoc với assistant. Mỗi lớp giữ đúng phạm vi của mình:
+
+| Lớp | Phạm vi | Dùng cho |
+|---|---|---|
+| File hướng dẫn phiên của IDE như `CLAUDE.md` hoặc `AGENTS.md` | Mọi phiên, trước khi bất kỳ skill nào chạy | Quy tắc ngắn, phổ quát, phải sống cả ngoài BMad |
+| Tùy chỉnh agent của BMad | Mọi workflow mà agent đó dispatch | Hành vi riêng theo persona/agent |
+| Tùy chỉnh workflow của BMad | Một lần chạy workflow | Dạng đầu ra, hook publish, template và logic riêng của workflow |
+| Cấu hình trung tâm của BMad | Agent roster và thiết lập cài đặt dùng chung | Ai đang ngồi trong phòng và đường dẫn nào cả team dùng chung |
+
+Hãy giữ file hướng dẫn của IDE **ngắn gọn**. Một tá dòng được chọn kỹ sẽ hiệu quả hơn một danh sách dài lê thê. Model phải đọc file đó ở mọi lượt, và càng nhiều nhiễu thì càng ít tín hiệu.
+
+## Kết hợp các recipe
+
+Cả năm recipe này có thể kết hợp song song. Một cấu hình doanh nghiệp thực tế cho `bmad-product-brief` hoàn toàn có thể đặt `persistent_facts` theo Recipe 2, `on_complete` theo Recipe 3 và `brief_template` theo Recipe 4 trong cùng một file. Quy tắc ở cấp agent theo Recipe 1 sẽ nằm trong file của agent tương ứng, còn cấu hình trung tâm theo Recipe 5 thì ghim roster và thiết lập chung. Tất cả cùng hoạt động đồng thời.
+
+```toml
+# _bmad/custom/bmad-product-brief.toml (cấp workflow)
+
+[workflow]
+persistent_facts = ["..."]
+brief_template = "{project-root}/docs/enterprise/brief-template.md"
+on_complete = """ ... """
+```
+
+```toml
+# _bmad/custom/bmad-agent-analyst.toml (cấp agent, Mary sẽ dispatch product-brief)
+
+[agent]
+persistent_facts = ["Luôn thêm mục 'Regulatory Review' khi domain liên quan tới healthcare, finance hoặc dữ liệu trẻ em."]
+```
+
+Kết quả là Mary nạp quy tắc review pháp lý ngay ở lúc kích hoạt persona. Khi người dùng chọn menu item product-brief, workflow sẽ nạp các convention riêng của nó chồng lên, ghi ra template của doanh nghiệp và publish lên Confluence khi hoàn tất. Mỗi lớp đều đóng góp một phần và không lớp nào đòi hỏi sửa source của BMad.
+
+## Khắc phục sự cố
+
+**Override không có tác dụng?** Hãy kiểm tra file có nằm trong `_bmad/custom/` và dùng đúng tên thư mục skill không, ví dụ `bmad-agent-dev.toml`, chứ không phải `bmad-dev.toml`. Nếu cần, xem lại [Cách tùy chỉnh BMad](./customize-bmad.md).
+
+**Không chắc tên MCP tool?** Hãy dùng đúng tên mà MCP server hiện tại expose trong phiên của bạn. Nếu chưa chắc, hãy yêu cầu Claude Code liệt kê các MCP tool đang có. Những tên hardcode trong `persistent_facts` hay `on_complete` sẽ không chạy nếu MCP server chưa được kết nối.
+
+**Mẫu áp dụng (pattern) trong ví dụ không khớp setup của tôi?** Các recipe trên chỉ là ví dụ mẫu. Cơ chế bên dưới, gồm merge ba lớp, quy tắc cấu trúc và mô hình agent-span-workflow, vẫn hỗ trợ nhiều pattern khác. Hãy kết hợp chúng theo nhu cầu thực tế của bạn.