Merge cb6006686c into c46502f640

feat(installer): overhaul branding, versioning, and skill cleanup (#2223 )
* feat(installer): overhaul branding, versioning, and skill cleanup Logo and branding: - Responsive logo: full "BMAD METHOD" at >=95 cols, "BMAD" for narrower terminals - Color scheme updated from yellow to blue (matching bmadcode.com brand) - Added copyright notice and tagline in white for contrast - Removed version number from logo (individual module versions shown in summary) - Added ™ to both wide and narrow logo variants Installer start message: - Replaced outdated V6 launch announcement with clean welcome - Consolidated redundant module/platform messaging into single intro - Tightened open source manifesto (same spirit, fewer words) - Merged speaking/media into support section with contact email - Added full social links: Website, Discord, YouTube, X, Facebook - Replaced docs.bmad-method.org and changelog links with bmadcode.com hub Install summary improvements: - Module names now show full display names from module.yaml (not abbreviations) - All module versions sourced from .claude-plugin/marketplace.json exclusively - Summary shows version transitions: "v6.2.2 -> v6.3.0", "v6.3.0, no change", or "v6.3.0, installed" for fresh installs - Switched summary from clack note() to box() for full-brightness text - Removed dim/gray styling that was hard to read on dark terminals - Links styled with color.blue instead of color.dim - Get started section leads with actionable steps (launch agent, run bmad-help) - Removed redundant social links (already shown in start message) Version source unification: - All module versions now come from .claude-plugin/marketplace.json only - Removed package.json as version source for core/bmm modules - Updated manifest.js getModuleVersionInfo() to use marketplace.json - Updated installer.js _getMarketplaceVersion() helper - Updated ui.js getMarketplaceVersion() for module selection display - Quick Update menu no longer shows misleading version (was using package.json) - Module selection list now shows versions next to each module name Skill cleanup overhaul: - Replaced blunt-force bmad-* prefix deletion with surgical removal system - Added removals.txt support: optional per-project file listing skills to remove - Created initial removals.txt with all skills removed since v6.2.0 - Install/update: captures previously installed skill IDs from skill-manifest.csv before manifest regeneration, then removes those + removals.txt entries - Uninstall: removes all installed skills via skill-manifest.csv + removals.txt - Deselecting modules now correctly removes their skills from IDE directories - User-created bmad-* skills in IDE directories are no longer destroyed - Legacy directory cleanup retains prefix matching (those dirs are abandoned) Bug fixes: - Fixed duplicate "CORE module already up to date" during quick update - Fixed version display showing package.json version instead of actual module version - Updated test fixture for bmad-os-* preservation test to use skill-manifest.csv * fix(installer): address Augment review findings - Fix plugins[0] fragility: extract highest version across all plugins in marketplace.json instead of assuming first entry (ui.js, installer.js, manifest.js) - Fix _readMarketplaceVersion ignoring moduleSourcePath: custom modules can now source their own marketplace.json by walking up from source path - Hard-exclude bmad-os-* utility skills in both surgical and legacy cleanup modes, preventing accidental deletion if tracked in manifests - Distinguish missing file vs parse error in skill-manifest.csv reading: warn on corrupt CSV instead of silently skipping cleanup * fix(installer): resolve module source before reading marketplace version Move _readMarketplaceVersion call after source type resolution so custom modules use their own source path instead of falling back to the external module cache, which could match a different module with the same code.
2026-04-07 18:59:23 +02:00 · 2026-04-07 02:31:36 -05:00 · 2026-04-06 00:30:00 -05:00 · 2026-04-05 13:14:03 -07:00 · 2026-04-05 00:52:39 -05:00 · 2026-04-04 20:49:55 -07:00
45 changed files with 3916 additions and 249 deletions
--- a/CONTRIBUTING.md
+++ b/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                                              |
-
+| ----------------------- | -------------------------------------------------------- |
-| Work Type     | Requirement                                    |
+| Typo / small bug fix    | Just open the PR                                         |
-| ------------- | ---------------------------------------------- |
+| Feature or large change | Confirm with a maintainer on Discord **before** you start |
 | 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.
 ---
@ -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
--- a/README.md
+++ b/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.
@ -34,7 +36,7 @@ Traditional AI tools do the thinking for you, producing average results. BMad ag
 ## Quick Start
-**Prerequisites**: [Node.js](https://nodejs.org) v20+
+**Prerequisites**: [Node.js](https://nodejs.org) v20+ · [Python](https://www.python.org) 3.10+ · [uv](https://docs.astral.sh/uv/)
 ```bash
 npx bmad-method install
@ -79,18 +81,15 @@ BMad Method extends with official modules for specialized domains. Available dur
 ## Community
 - [Discord](https://discord.gg/gk8jAdXWmj) — Get help, share ideas, collaborate
- [Subscribe on YouTube](https://www.youtube.com/@BMadCode) — Tutorials, master class, and podcast (launching Feb 2025)
+- [YouTube](https://youtube.com/@BMadCode) — Tutorials, master class, and more
 - [X / Twitter](https://x.com/BMadCode)
 - [Website](https://bmadcode.com)
 - [GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues) — Bug reports and feature requests
 - [Discussions](https://github.com/bmad-code-org/BMAD-METHOD/discussions) — Community conversations
 ## Support BMad
-BMad is free for everyone — and always will be. If you'd like to support development:
+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.
 - ⭐ 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)
 ## Contributing
--- a/docs/cs/404.md
+++ b/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)
--- a/docs/cs/_STYLE_GUIDE.md
+++ b/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í
 ```
--- a/docs/cs/explanation/advanced-elicitation.md
+++ b/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.
 :::
--- a/docs/cs/explanation/adversarial-review.md
+++ b/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ě.
 :::
--- a/docs/cs/explanation/brainstorming.md
+++ b/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.
 :::
--- a/docs/cs/explanation/established-projects-faq.md
+++ b/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!
--- a/docs/cs/explanation/party-mode.md
+++ b/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.
 :::
--- a/docs/cs/explanation/preventing-agent-conflicts.md
+++ b/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
 :::
--- a/docs/cs/explanation/project-context.md
+++ b/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.
 :::
--- a/docs/cs/explanation/quick-dev.md
+++ b/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.
--- a/docs/cs/explanation/why-solutioning-matters.md
+++ b/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.
 :::
--- a/docs/cs/how-to/customize-bmad.md
+++ b/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.
--- a/docs/cs/how-to/established-projects.md
+++ b/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
--- a/docs/cs/how-to/get-answers-about-bmad.md
+++ b/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)
--- a/docs/cs/how-to/install-bmad.md
+++ b/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.
--- a/docs/cs/how-to/non-interactive-installation.md
+++ b/docs/cs/how-to/non-interactive-installation.md
@ -0,0 +1,171 @@
 ---
 title: Neinteraktivní instalace
 description: Instalace BMad pomocí příznaků příkazové řádky pro CI/CD pipelines a automatizované nasazení
 sidebar:
  order: 2
 ---
 Použijte příznaky příkazové řádky k neinteraktivní instalaci BMad. To je užitečné pro:
 ## Kdy to použít
 - Automatizovaná nasazení a CI/CD pipelines
 - Skriptované instalace
 - Hromadné instalace napříč více projekty
 - Rychlé instalace se známými konfiguracemi
 :::note[Předpoklady]
 Vyžaduje [Node.js](https://nodejs.org) v20+ a `npx` (součástí npm).
 :::
 ## Dostupné příznaky
 ### Možnosti instalace
 | Příznak | Popis | Příklad |
 |---------|-------|---------|
 | `--directory <cesta>` | Instalační adresář | `--directory ~/projects/myapp` |
 | `--modules <moduly>` | Čárkou oddělená ID modulů | `--modules bmm,bmb` |
 | `--tools <nástroje>` | Čárkou oddělená ID nástrojů/IDE (použijte `none` pro přeskočení) | `--tools claude-code,cursor` nebo `--tools none` |
 | `--custom-content <cesty>` | Čárkou oddělené cesty k vlastním modulům | `--custom-content ~/my-module,~/another-module` |
 | `--action <typ>` | Akce pro existující instalace: `install` (výchozí), `update` nebo `quick-update` | `--action quick-update` |
 ### Základní konfigurace
 | Příznak | Popis | Výchozí |
 |---------|-------|---------|
 | `--user-name <jméno>` | Jméno, které agenti použijí | Systémové uživatelské jméno |
 | `--communication-language <jazyk>` | Jazyk komunikace agentů | English |
 | `--document-output-language <jazyk>` | Jazyk výstupních dokumentů | English |
 | `--output-folder <cesta>` | Cesta k výstupní složce | _bmad-output |
 ### Další možnosti
 | Příznak | Popis |
 |---------|-------|
 | `-y, --yes` | Přijmout všechna výchozí nastavení a přeskočit výzvy |
 | `-d, --debug` | Povolit ladící výstup pro generování manifestu |
 ## ID modulů
 Dostupná ID modulů pro příznak `--modules`:
 - `bmm` — BMad Method Master
 - `bmb` — BMad Builder
 Zkontrolujte [registr BMad](https://github.com/bmad-code-org) pro dostupné externí moduly.
 ## ID nástrojů/IDE
 Dostupná ID nástrojů pro příznak `--tools`:
 **Preferované:** `claude-code`, `cursor`
 Spusťte `npx bmad-method install` interaktivně jednou pro zobrazení aktuálního seznamu podporovaných nástrojů, nebo zkontrolujte [konfiguraci kódů platforem](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/cli/installers/lib/ide/platform-codes.yaml).
 ## Režimy instalace
 | Režim | Popis | Příklad |
 |-------|-------|---------|
 | Plně neinteraktivní | Zadejte všechny příznaky pro přeskočení výzev | `npx bmad-method install --directory . --modules bmm --tools claude-code --yes` |
 | Polo-interaktivní | Zadejte některé příznaky; BMad se zeptá na zbytek | `npx bmad-method install --directory . --modules bmm` |
 | Pouze výchozí | Přijměte vše výchozí s `-y` | `npx bmad-method install --yes` |
 | Bez nástrojů | Přeskočte konfiguraci nástrojů/IDE | `npx bmad-method install --modules bmm --tools none` |
 ## Příklady
 ### Instalace v CI/CD pipeline
 ```bash
 #!/bin/bash
 # install-bmad.sh
 npx bmad-method install \
  --directory "${GITHUB_WORKSPACE}" \
  --modules bmm \
  --tools claude-code \
  --user-name "CI Bot" \
  --communication-language English \
  --document-output-language English \
  --output-folder _bmad-output \
  --yes
 ```
 ### Aktualizace existující instalace
 ```bash
 npx bmad-method install \
  --directory ~/projects/myapp \
  --action update \
  --modules bmm,bmb,custom-module
 ```
 ### Rychlá aktualizace (zachování nastavení)
 ```bash
 npx bmad-method install \
  --directory ~/projects/myapp \
  --action quick-update
 ```
 ### Instalace s vlastním obsahem
 ```bash
 npx bmad-method install \
  --directory ~/projects/myapp \
  --modules bmm \
  --custom-content ~/my-custom-module,~/another-module \
  --tools claude-code
 ```
 ## Co získáte
 - Plně nakonfigurovaný adresář `_bmad/` ve vašem projektu
 - Agenty a workflow nakonfigurované pro vybrané moduly a nástroje
 - Složku `_bmad-output/` pro generované artefakty
 ## Validace a zpracování chyb
 BMad validuje všechny zadané příznaky:
 - **Adresář** — Musí být platná cesta s oprávněním k zápisu
 - **Moduly** — Upozorní na neplatná ID modulů (ale nespadne)
 - **Nástroje** — Upozorní na neplatná ID nástrojů (ale nespadne)
 - **Vlastní obsah** — Každá cesta musí obsahovat platný soubor `module.yaml`
 - **Akce** — Musí být jedna z: `install`, `update`, `quick-update`
 Neplatné hodnoty buď:
 1. Zobrazí chybu a ukončí se (pro kritické možnosti jako adresář)
 2. Zobrazí varování a přeskočí (pro volitelné položky jako vlastní obsah)
 3. Přepnou na interaktivní výzvy (pro chybějící povinné hodnoty)
 :::tip[Osvědčené postupy]
 - Používejte absolutní cesty pro `--directory` pro zamezení nejednoznačnosti
 - Otestujte příznaky lokálně před použitím v CI/CD pipelines
 - Kombinujte s `-y` pro skutečně bezobslužné instalace
 - Použijte `--debug` pokud narazíte na problémy během instalace
 :::
 ## Řešení problémů
 ### Instalace selže s „Invalid directory“
 - Cesta k adresáři musí existovat (nebo musí existovat jeho nadřazený adresář)
 - Potřebujete oprávnění k zápisu
 - Cesta musí být absolutní nebo správně relativní k aktuálnímu adresáři
 ### Modul nenalezen
 - Ověřte, že ID modulu je správné
 - Externí moduly musí být dostupné v registru
 ### Neplatná cesta k vlastnímu obsahu
 Ujistěte se, že každá cesta k vlastnímu obsahu:
 - Ukazuje na adresář
 - Obsahuje soubor `module.yaml` v kořeni
 - Má pole `code` v `module.yaml`
 :::note[Stále jste uvízli?]
 Spusťte s `--debug` pro detailní výstup, zkuste interaktivní režim pro izolaci problému, nebo nahlaste na <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
 :::
--- a/docs/cs/how-to/project-context.md
+++ b/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
--- a/docs/cs/how-to/quick-fixes.md
+++ b/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.
--- a/docs/cs/how-to/shard-large-documents.md
+++ b/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
--- a/docs/cs/how-to/upgrade-to-v6.md
+++ b/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í        |
--- a/docs/cs/index.md
+++ b/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.
--- a/docs/cs/reference/agents.md
+++ b/docs/cs/reference/agents.md
@ -0,0 +1,55 @@
 ---
 title: Agenti
 description: Výchozí BMM agenti s jejich skill ID, spouštěči nabídky a primárními workflow
 sidebar:
  order: 2
 ---
 ## Výchozí agenti
 Tato stránka uvádí výchozí BMM (Agile suite) agenty, kteří se instalují s BMad Method, společně s jejich skill ID, spouštěči nabídky a primárními workflow. Každý agent se vyvolává jako skill.
 ## Poznámky
 - Každý agent je dostupný jako skill, generovaný instalátorem. Skill ID (např. `bmad-dev`) se používá k vyvolání agenta.
 - Spouštěče jsou krátké kódy nabídky (např. `CP`) a fuzzy shody zobrazené v nabídce každého agenta.
 - Generování QA testů zajišťuje workflow skill `bmad-qa-generate-e2e-tests`, dostupný přes Developer agenta. Plný Test Architect (TEA) žije ve vlastním modulu.
 | Agent                       | Skill ID             | Spouštěče                                    | Primární workflow                                                                                   |
 | --------------------------- | -------------------- | -------------------------------------------- | --------------------------------------------------------------------------------------------------- |
 | Analyst (Mary)              | `bmad-analyst`       | `BP`, `RS`, `CB`, `WB`, `DP`                 | Brainstorm projektu, výzkum, tvorba briefu, PRFAQ výzva, dokumentace projektu                       |
 | Product Manager (John)      | `bmad-pm`            | `CP`, `VP`, `EP`, `CE`, `IR`, `CC`           | Tvorba/validace/editace PRD, tvorba epiců a stories, připravenost implementace, korekce kurzu       |
 | Architect (Winston)         | `bmad-architect`     | `CA`, `IR`                                    | Tvorba architektury, připravenost implementace                                                      |
 | Developer (Amelia)          | `bmad-agent-dev`     | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER`     | Dev story, Quick Dev, generování QA testů, revize kódu, plánování sprintu, tvorba story, retrospektiva epicu |
 | UX Designer (Sally)         | `bmad-ux-designer`   | `CU`                                          | Tvorba UX designu                                                                                   |
 | Technical Writer (Paige)    | `bmad-tech-writer`   | `DP`, `WD`, `US`, `MG`, `VD`, `EC`           | Dokumentace projektu, psaní dokumentu, aktualizace standardů, generování Mermaid, validace dok., vysvětlení konceptu |
 ## Typy spouštěčů
 Spouštěče nabídky agentů používají dva různé typy vyvolání. Znalost typu spouštěče vám pomůže poskytnout správný vstup.
 ### Workflow spouštěče (bez argumentů)
 Většina spouštěčů načítá strukturovaný soubor workflow. Zadejte kód spouštěče a agent zahájí workflow a vyzve vás k zadání vstupu v každém kroku.
 Příklady: `CP` (tvorba PRD), `DS` (Dev story), `CA` (tvorba architektury), `QD` (Quick Dev)
 ### Konverzační spouštěče (vyžadují argumenty)
 Některé spouštěče zahajují volnou konverzaci místo strukturovaného workflow. Tyto očekávají, že popíšete, co potřebujete, společně s kódem spouštěče.
 | Agent | Spouštěč | Co poskytnout |
 | --- | --- | --- |
 | Technical Writer (Paige) | `WD` | Popis dokumentu k napsání |
 | Technical Writer (Paige) | `US` | Preference nebo konvence k přidání do standardů |
 | Technical Writer (Paige) | `MG` | Popis diagramu a typ (sekvence, vývojový diagram atd.) |
 | Technical Writer (Paige) | `VD` | Dokument k validaci a oblasti zaměření |
 | Technical Writer (Paige) | `EC` | Název konceptu k vysvětlení |
 **Příklad:**
 ```text
 WD Write a deployment guide for our Docker setup
 MG Create a sequence diagram showing the auth flow
 EC Explain how the module system works
 ```
--- a/docs/cs/reference/commands.md
+++ b/docs/cs/reference/commands.md
@ -0,0 +1,135 @@
 ---
 title: Skills
 description: Reference BMad skills — co to je, jak fungují a kde je najít.
 sidebar:
  order: 3
 ---
 Skills jsou předpřipravené prompty, které načítají agenty, spouštějí workflow nebo provádějí úkoly ve vašem IDE. Instalátor BMad je generuje z vašich nainstalovaných modulů při instalaci. Pokud později přidáte, odeberete nebo změníte moduly, přeinstalujte pro synchronizaci skills (viz [Řešení problémů](#řešení-problémů)).
 ## Skills vs. spouštěče nabídky agentů
 BMad nabízí dva způsoby zahájení práce a slouží k různým účelům.
 | Mechanismus | Jak se vyvolává | Co se stane |
 | --- | --- | --- |
 | **Skill** | Zadejte název skillu (např. `bmad-help`) ve vašem IDE | Přímo načte agenta, spustí workflow nebo provede úkol |
 | **Spouštěč nabídky agenta** | Nejprve načtěte agenta, pak zadejte krátký kód (např. `DS`) | Agent interpretuje kód a spustí odpovídající workflow, přičemž zůstává v charakteru |
 Spouštěče nabídky agentů vyžadují aktivní relaci agenta. Používejte skills, když víte, který workflow chcete. Používejte spouštěče, když již pracujete s agentem a chcete přepnout úkol bez opuštění konverzace.
 ## Jak se skills generují
 Když spustíte `npx bmad-method install`, instalátor čte manifesty každého vybraného modulu a zapíše jeden skill na agenta, workflow, úkol a nástroj. Každý skill je adresář obsahující soubor `SKILL.md`, který instruuje AI k načtení odpovídajícího zdrojového souboru a následování jeho instrukcí.
 Instalátor používá šablony pro každý typ skillu:
 | Typ skillu | Co generovaný soubor dělá |
 | --- | --- |
 | **Spouštěč agenta** | Načte soubor persony agenta, aktivuje jeho nabídku a zůstává v charakteru |
 | **Workflow skill** | Načte konfiguraci workflow a následuje jeho kroky |
 | **Task skill** | Načte samostatný soubor úkolu a následuje jeho instrukce |
 | **Tool skill** | Načte samostatný soubor nástroje a následuje jeho instrukce |
 :::note[Opětovné spuštění instalátoru]
 Pokud přidáte nebo odeberete moduly, spusťte instalátor znovu. Přegeneruje všechny soubory skills tak, aby odpovídaly vašemu aktuálnímu výběru modulů.
 :::
 ## Kde žijí soubory skills
 Instalátor zapisuje soubory skills do adresáře specifického pro IDE uvnitř vašeho projektu. Přesná cesta závisí na IDE, které jste vybrali během instalace.
 | IDE / CLI | Adresář skills |
 | --- | --- |
 | Claude Code | `.claude/skills/` |
 | Cursor | `.cursor/skills/` |
 | Windsurf | `.windsurf/skills/` |
 | Další IDE | Viz výstup instalátoru pro cílovou cestu |
 Každý skill je adresář obsahující soubor `SKILL.md`. Například instalace Claude Code vypadá takto:
 ```text
 .claude/skills/
 ├── bmad-help/
 │   └── SKILL.md
 ├── bmad-create-prd/
 │   └── SKILL.md
 ├── bmad-agent-dev/
 │   └── SKILL.md
 └── ...
 ```
 Název adresáře určuje název skillu ve vašem IDE. Například adresář `bmad-agent-dev/` registruje skill `bmad-agent-dev`.
 ## Jak objevit vaše skills
 Zadejte název skillu ve vašem IDE pro jeho vyvolání. Některé platformy vyžadují povolení skills v nastavení, než se zobrazí.
 Spusťte `bmad-help` pro kontextové poradenství k dalšímu kroku.
 :::tip[Rychlé objevování]
 Generované adresáře skills ve vašem projektu jsou kanonický seznam. Otevřete je v prohlížeči souborů, abyste viděli každý skill s jeho popisem.
 :::
 ## Kategorie skills
 ### Agentní skills
 Agentní skills načítají specializovanou AI personu s definovanou rolí, komunikačním stylem a nabídkou workflow. Po načtení agent zůstává v charakteru a reaguje na spouštěče nabídky.
 | Příklad skillu | Agent | Role |
 | --- | --- | --- |
 | `bmad-agent-dev` | Amelia (Developer) | Implementuje stories s přísným dodržováním specifikací |
 | `bmad-pm` | John (Product Manager) | Vytváří a validuje PRD |
 | `bmad-architect` | Winston (Architect) | Navrhuje systémovou architekturu |
 Viz [Agenti](./agents.md) pro úplný seznam výchozích agentů a jejich spouštěčů.
 ### Workflow skills
 Workflow skills spouštějí strukturovaný, vícekrokový proces bez předchozího načtení persony agenta. Načtou konfiguraci workflow a následují jeho kroky.
 | Příklad skillu | Účel |
 | --- | --- |
 | `bmad-product-brief` | Vytvoření product briefu — řízené discovery, když je váš koncept jasný |
 | `bmad-prfaq` | Working Backwards PRFAQ výzva pro zátěžový test vašeho produktového konceptu |
 | `bmad-create-prd` | Vytvoření dokumentu požadavků (PRD) |
 | `bmad-create-architecture` | Návrh systémové architektury |
 | `bmad-create-epics-and-stories` | Vytvoření epiců a stories |
 | `bmad-dev-story` | Implementace story |
 | `bmad-code-review` | Spuštění revize kódu |
 | `bmad-quick-dev` | Sjednocený quick flow — vyjasnění záměru, plán, implementace, revize, prezentace |
 Viz [Mapa pracovních postupů](./workflow-map.md) pro kompletní referenci workflow organizovanou podle fází.
 ### Task a tool skills
 Tasks a tools jsou samostatné operace, které nevyžadují kontext agenta nebo workflow.
 **BMad-Help: Váš inteligentní průvodce**
 `bmad-help` je vaše primární rozhraní pro objevení, co dělat dál. Zkoumá váš projekt, rozumí dotazům v přirozeném jazyce a doporučuje další povinný nebo volitelný krok na základě nainstalovaných modulů.
 :::note[Příklad]
 ```
 bmad-help
 bmad-help I have a SaaS idea and know all the features. Where do I start?
 bmad-help What are my options for UX design?
 ```
 :::
 **Další základní tasks a tools**
 Základní modul zahrnuje 11 vestavěných nástrojů — revize, komprese, brainstorming, správa dokumentů a další. Viz [Základní nástroje](./core-tools.md) pro kompletní referenci.
 ## Konvence pojmenování
 Všechny skills používají prefix `bmad-` následovaný popisným názvem (např. `bmad-dev`, `bmad-create-prd`, `bmad-help`). Viz [Moduly](./modules.md) pro dostupné moduly.
 ## Řešení problémů
 **Skills se nezobrazují po instalaci.** Některé platformy vyžadují explicitní povolení skills v nastavení. Zkontrolujte dokumentaci vašeho IDE nebo se zeptejte AI asistenta, jak skills povolit. Může být také nutné restartovat IDE nebo znovu načíst okno.
 **Očekávané skills chybí.** Instalátor generuje skills pouze pro moduly, které jste vybrali. Spusťte `npx bmad-method install` znovu a ověřte výběr modulů. Zkontrolujte, že soubory skills existují v očekávaném adresáři.
 **Skills z odebraného modulu se stále zobrazují.** Instalátor automaticky nemaže staré soubory skills. Odstraňte zastaralé adresáře z adresáře skills vašeho IDE, nebo smažte celý adresář skills a přeinstalujte pro čistou sadu.
--- a/docs/cs/reference/core-tools.md
+++ b/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
--- a/docs/cs/reference/modules.md
+++ b/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.
--- a/docs/cs/reference/testing.md
+++ b/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).
--- a/docs/cs/reference/workflow-map.md
+++ b/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)
--- a/docs/cs/roadmap.mdx
+++ b/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>
--- a/docs/cs/tutorials/getting-started.md
+++ b/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.
--- a/docs/how-to/get-answers-about-bmad.md
+++ b/docs/how-to/get-answers-about-bmad.md
@ -5,80 +5,27 @@ sidebar:
  order: 4
 ---
-## Start Here: BMad-Help
+Use BMad's built-in help, source docs, or the community to get answers — from quickest to most thorough.
-**The fastest way to get answers about BMad is the `bmad-help` skill.** This intelligent guide will answer upwards of 80% of all questions and is available to you directly in your IDE as you work.
+## 1. Ask BMad-Help
-BMad-Help is more than a lookup tool — it:
+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.
 - **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:
 ```
-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 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 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 responds with:
+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.
 - 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
 :::note[Example]
 **Q:** "Tell me the fastest way to build something with BMad"
@ -86,30 +33,27 @@ https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
 **A:** Use Quick Flow: Run `bmad-quick-dev` — it clarifies your intent, plans, implements, reviews, and presents results in a single workflow, skipping the full planning phases.
 :::
-## What You Get
+**Tips for better answers:**
 Direct answers about BMad—how agents work, what workflows do, why things are structured the way they are—without waiting for someone else to respond.
 ## Tips
 - **Verify surprising answers** — LLMs occasionally get things wrong. Check the source file or ask on Discord.
 - **Be specific** — "What does step 3 of the PRD workflow do?" beats "How does PRD work?"
 - **Verify surprising claims** — LLMs occasionally get things wrong. Check the source file or ask on Discord.
-## Still Stuck?
+### Not using an agent? Use the docs site
-Tried the LLM approach and still need help? You now have a much better question to ask.
+If your AI can't read local files (ChatGPT, Claude.ai, etc.), fetch [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) into your session — it's a single-file snapshot of the BMad documentation.
 ## 3. Ask Someone
 If neither BMad-Help nor the source answered your question, you now have a much better question to ask.
 | Channel                   | Use For                                     |
 | ------------------------- | ------------------------------------------- |
-| `#bmad-method-help`       | Quick questions (real-time chat)            |
+| `help-requests` forum     | Questions                                   |
 | `help-requests` forum     | Detailed questions (searchable, persistent) |
 | `#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—*
--- a/removals.txt
+++ b/removals.txt
@ -0,0 +1,17 @@
 # BMad Method - Skill Removal List
 # Entries listed here will be removed from IDE skill directories during install/update.
 # One entry per line. Lines starting with # are comments.
 # Each entry is a skill directory name (canonicalId) that was removed or renamed.
 # Removed agents (v6.2.0 - v6.2.2)
 bmad-agent-sm
 bmad-agent-qa
 bmad-agent-quick-flow-solo-dev
 # Removed skills (v6.2.0 - v6.2.2)
 bmad-create-product-brief
 bmad-product-brief-preview
 bmad-quick-spec
 bmad-quick-flow
 bmad-quick-dev-new-preview
 bmad-init
--- a/src/bmm-skills/4-implementation/bmad-code-review/steps/step-01-gather-context.md
+++ b/src/bmm-skills/4-implementation/bmad-code-review/steps/step-01-gather-context.md
@ -15,18 +15,37 @@ story_key: '' # set at runtime when discovered from sprint status
 ## INSTRUCTIONS
-1. **Detect review intent from invocation text.** Check the triggering prompt for phrases that map to a review mode:
+1. **Find the review target.** The conversation context before this skill was triggered IS your starting point — not a blank slate. Check in this order — stop as soon as the review target is identified:
-   - "staged" / "staged changes" → Staged changes only
+
-   - "uncommitted" / "working tree" / "all changes" → Uncommitted changes (staged + unstaged)
+   **Tier 1 — Explicit argument.**
-   - "branch diff" / "vs main" / "against main" / "compared to {branch}" → Branch diff (extract base branch if mentioned)
+   Did the user pass a PR, commit SHA, branch, spec file, or diff source this message?
-   - "commit range" / "last N commits" / "{sha}..{sha}" → Specific commit range
+   - PR reference → resolve to branch/commit via `gh pr view`. If resolution fails, ask for a SHA or branch.
-   - "this diff" / "provided diff" / "paste" → User-provided diff (do not match bare "diff" — it appears in other modes)
+   - Commit or branch → use directly.
-   - When multiple phrases match, prefer the most specific match (e.g., "branch diff" over bare "diff").
+   - Spec file → set `{spec_file}` to the provided path. Check its frontmatter for `baseline_commit`. If found, use as diff baseline. If not found, continue the cascade (a spec alone does not identify a diff source).
-   - **If a clear match is found:** Announce the detected mode (e.g., "Detected intent: review staged changes only") and proceed directly to constructing `{diff_output}` using the corresponding sub-case from instruction 3. Skip to instruction 4 (spec question).
+   - Also scan the argument for diff-mode keywords that narrow the scope:
-   - **If no match from invocation text, check sprint tracking.** Look for a sprint status file (`*sprint-status*`) in `{implementation_artifacts}` or `{planning_artifacts}`. If found, scan for any story with status `review`. Handle as follows:
+     - "staged" / "staged changes" → Staged changes only
-     - **Exactly one `review` story:** Set `{story_key}` to the story's key (e.g., `1-2-user-auth`). Suggest it: "I found story {{story-id}} in `review` status. Would you like to review its changes? [Y] Yes / [N] No, let me choose". If confirmed, use the story context to determine the diff source (branch name derived from story slug, or uncommitted changes). If declined, clear `{story_key}` and fall through to instruction 2.
+     - "uncommitted" / "working tree" / "all changes" → Uncommitted changes (staged + unstaged)
-     - **Multiple `review` stories:** Present them as numbered options alongside a manual choice option. Wait for user selection. If the user selects a story, set `{story_key}` to the selected story's key and use the selected story's context to determine the diff source as in the single-story case above, and proceed to instruction 3. If the user selects the manual choice, clear `{story_key}` and fall through to instruction 2.
+     - "branch diff" / "vs main" / "against main" / "compared to <branch>" → Branch diff (extract base branch if mentioned)
-   - **If no match and no sprint tracking:** Fall through to instruction 2.
+     - "commit range" / "last N commits" / "<from-sha>..<to-sha>" → Specific commit range
     - "this diff" / "provided diff" / "paste" → User-provided diff (do not match bare "diff" — it appears in other modes)
   - When multiple keywords match, prefer the most specific (e.g., "branch diff" over bare "diff").
   **Tier 2 — Recent conversation.**
   Do the last few messages reveal what the user wants to be reviewed? Look for spec paths, commit refs, branches, PRs, or descriptions of a change. Apply the same diff-mode keyword scan and routing as Tier 1.
   **Tier 3 — Sprint tracking.**
   Look for a sprint status file (`*sprint-status*`) in `{implementation_artifacts}` or `{planning_artifacts}`. If found, scan for stories with status `review`:
   - **Exactly one `review` story:** Set `{story_key}` to the story's key (e.g., `1-2-user-auth`). Suggest it: "I found story <story-id> in `review` status. Would you like to review its changes? [Y] Yes / [N] No, let me choose". If confirmed, use the story context to determine the diff source (branch name derived from story slug, or uncommitted changes). If declined, clear `{story_key}` and fall through.
   - **Multiple `review` stories:** Present them as numbered options alongside a manual choice option. Wait for user selection. If a story is selected, set `{story_key}` and use its context to determine the diff source. If manual choice is selected, clear `{story_key}` and fall through.
   - **None:** Fall through.
   **Tier 4 — Current git state.**
   If version control is unavailable, skip to Tier 5. Otherwise, check the current branch and HEAD. If the branch is not `main` (or the default branch), confirm: "I see HEAD is `<short-sha>` on `<branch>` — do you want to review this branch's changes?" If confirmed, treat as a branch diff against `main`. If declined, fall through.
   **Tier 5 — Ask.**
   Fall through to instruction 2.
   Never ask extra questions beyond what the cascade prescribes. If a tier above already identified the target, skip the remaining tiers and proceed to instruction 3 (construct diff).
 2. HALT. Ask the user: **What do you want to review?** Present these options:
   - **Uncommitted changes** (staged + unstaged)
@ -36,15 +55,19 @@ story_key: '' # set at runtime when discovered from sprint status
   - **Provided diff or file list** (user pastes or provides a path)
 3. Construct `{diff_output}` from the chosen source.
   - For **staged changes only**: run `git diff --cached`.
   - For **uncommitted changes** (staged + unstaged): run `git diff HEAD`.
   - For **branch diff**: verify the base branch exists before running `git diff`. If it does not exist, HALT and ask the user for a valid branch.
   - For **commit range**: verify the range resolves. If it does not, HALT and ask the user for a valid range.
   - For **provided diff**: validate the content is non-empty and parseable as a unified diff. If it is not parseable, HALT and ask the user to provide a valid diff.
   - For **file list**: validate each path exists in the working tree. Construct `{diff_output}` by running `git diff HEAD -- <path1> <path2> ...`. If any paths are untracked (new files not yet staged), use `git diff --no-index /dev/null <path>` to include them. If the diff is empty (files have no uncommitted changes and are not untracked), ask the user whether to review the full file contents or to specify a different baseline.
   - After constructing `{diff_output}`, verify it is non-empty regardless of source type. If empty, HALT and tell the user there is nothing to review.
-4. Ask the user: **Is there a spec or story file that provides context for these changes?**
+4. **Set the spec context.**
-   - If yes: set `{spec_file}` to the path provided, verify the file exists and is readable, then set `{review_mode}` = `"full"`.
+   - If `{spec_file}` is already set (from Tier 1 or Tier 2): verify the file exists and is readable, then set `{review_mode}` = `"full"`.
-   - If no: set `{review_mode}` = `"no-spec"`.
+   - Otherwise, ask the user: **Is there a spec or story file that provides context for these changes?**
     - If yes: set `{spec_file}` to the path provided, verify the file exists and is readable, then set `{review_mode}` = `"full"`.
     - If no: set `{review_mode}` = `"no-spec"`.
 5. If `{review_mode}` = `"full"` and the file at `{spec_file}` has a `context` field in its frontmatter listing additional docs, load each referenced document. Warn the user about any docs that cannot be found.
--- a/src/bmm-skills/4-implementation/bmad-quick-dev/step-01-clarify-and-route.md
+++ b/src/bmm-skills/4-implementation/bmad-quick-dev/step-01-clarify-and-route.md
@ -49,6 +49,12 @@ Never ask extra questions if you already understand what the user intends.
     - **Epics** (`*epic*`) — feature breakdown into implementable stories
     - **Product Brief** (`*brief*`) — project vision and scope
   - Scan the listing for files matching these patterns. If any look relevant to the current intent, load them selectively — you don't need all of them, but you need the right constraints and requirements rather than guessing from code alone.
   - **Previous story continuity.** Using the intent and loaded context (especially any epics file), infer whether the current work is a story from an epic. Do not rely on filename patterns or regex — reason about the intent, the artifact listing, and epics content together. If the intent is an epic story:
     1. Identify the epic and story number.
     2. Scan `{implementation_artifacts}` for specs from the same epic with `status: done` and a lower story number.
     3. Load the most recent one (highest story number below current).
     4. Extract its **Code Map**, **Design Notes**, **Spec Change Log**, and **task list** as continuity context for step-02 planning.
     If no `done` spec is found but an `in-review` spec exists for the same epic with a lower story number, note it to the user and ask whether to load it. If the intent is not an epic story, or no previous spec exists, skip this silently.
 2. Clarify intent. Do not fantasize, do not leave open questions. If you must ask questions, ask them as a numbered list. When the human replies, verify that every single numbered question was answered. If any were ignored, HALT and re-ask only the missing questions before proceeding. Keep looping until intent is clear enough to implement.
 3. Version control sanity check. Is the working tree clean? Does the current branch make sense for this intent — considering its name and recent history? If the tree is dirty or the branch is an obvious mismatch, HALT and ask the human before proceeding. If version control is unavailable, skip this check.
 4. Multi-goal check (see SCOPE STANDARD). If the intent fails the single-goal criteria:
--- a/test/test-installation-components.js
+++ b/test/test-installation-components.js
@ -1301,6 +1301,14 @@ async function runTests() {
      '---\nname: bmad-architect\ndescription: Architect\n---\nOld skill content\n',
    );
    // Add bmad-architect to the existing skill-manifest.csv so cleanup knows it was previously installed
    const configDir27 = path.join(installedBmadDir27, '_config');
    const existingCsv27 = await fs.readFile(path.join(configDir27, 'skill-manifest.csv'), 'utf8');
    await fs.writeFile(
      path.join(configDir27, 'skill-manifest.csv'),
      existingCsv27.trimEnd() + '\n"bmad-architect","bmad-architect","Architect","bmm","_bmad/bmm/agents/bmad-architect/SKILL.md","true"\n',
    );
    // Run Claude Code setup (which triggers cleanup then install)
    const ideManager27 = new IdeManager();
    await ideManager27.ensureInitialized();
--- a/tools/installer/cli-utils.js
+++ b/tools/installer/cli-utils.js
@ -19,24 +19,33 @@ const CLIUtils = {
   * Display BMAD logo and version using @clack intro + box
   */
  async displayLogo() {
    const version = this.getVersion();
    const color = await prompts.getColor();
    const termWidth = process.stdout.columns || 80;
-    // ASCII art logo
+    // Full "BMad Method" logo for wide terminals, "BMad" only for narrow
-    const logo = [
+    const logoWide = [
      ' ██████╗ ███╗   ███╗ █████╗ ██████╗     ███╗   ███╗███████╗████████╗██╗  ██╗ ██████╗ ██████╗ ™',
      '██╔══██╗████╗ ████║██╔══██╗██╔══██╗    ████╗ ████║██╔════╝╚══██╔══╝██║  ██║██╔═══██╗██╔══██╗',
      '██████╔╝██╔████╔██║███████║██║  ██║    ██╔████╔██║█████╗     ██║   ███████║██║   ██║██║  ██║',
      '██╔══██╗██║╚██╔╝██║██╔══██║██║  ██║    ██║╚██╔╝██║██╔══╝     ██║   ██╔══██║██║   ██║██║  ██║',
      '██████╔╝██║ ╚═╝ ██║██║  ██║██████╔╝    ██║ ╚═╝ ██║███████╗   ██║   ██║  ██║╚██████╔╝██████╔╝',
      '╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═════╝     ╚═╝     ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ',
    ];
    const logoNarrow = [
      '    ██████╗ ███╗   ███╗ █████╗ ██████╗ ™',
      '    ██╔══██╗████╗ ████║██╔══██╗██╔══██╗',
      '    ██████╔╝██╔████╔██║███████║██║  ██║',
      '    ██╔══██╗██║╚██╔╝██║██╔══██║██║  ██║',
      '    ██████╔╝██║ ╚═╝ ██║██║  ██║██████╔╝',
      '    ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═════╝',
-    ]
+    ];
      .map((line) => color.yellow(line))
      .join('\n');
-    const tagline = '    Build More, Architect Dreams';
+    const logoLines = termWidth >= 95 ? logoWide : logoNarrow;
    const logo = logoLines.map((line) => color.blue(line)).join('\n');
    const tagline = color.white('    Build More, Architect Dreams\n    © BMad Code');
-    await prompts.box(`${logo}\n${tagline}`, `v${version}`, {
+    await prompts.box(`${logo}\n${tagline}`, '', {
      contentAlign: 'center',
      rounded: true,
      formatBorder: color.blue,
--- a/tools/installer/core/installer.js
+++ b/tools/installer/core/installer.js
@ -26,6 +26,44 @@ class Installer {
    this.bmadFolderName = BMAD_FOLDER_NAME;
  }
  /**
   * Read the module version from .claude-plugin/marketplace.json
   * Walks up from sourcePath looking for .claude-plugin/marketplace.json
   * @param {string} sourcePath - Module source directory
   * @returns {string} Version string or empty string
   */
  async _getMarketplaceVersion(sourcePath) {
    let dir = sourcePath;
    for (let i = 0; i < 5; i++) {
      const marketplacePath = path.join(dir, '.claude-plugin', 'marketplace.json');
      if (await fs.pathExists(marketplacePath)) {
        try {
          const data = JSON.parse(await fs.readFile(marketplacePath, 'utf8'));
          return this._extractMarketplaceVersion(data);
        } catch {
          return '';
        }
      }
      const parent = path.dirname(dir);
      if (parent === dir) break;
      dir = parent;
    }
    return '';
  }
  /**
   * Extract the highest version from marketplace.json plugins array
   */
  _extractMarketplaceVersion(data) {
    const plugins = data?.plugins;
    if (!Array.isArray(plugins) || plugins.length === 0) return '';
    let best = '';
    for (const p of plugins) {
      if (p.version && (!best || p.version > best)) best = p.version;
    }
    return best;
  }
  /**
   * Main installation method
   * @param {Object} config - Installation configuration
@ -52,9 +90,36 @@ class Installer {
      await this._validateIdeSelection(config);
      // Capture pre-install module versions for from→to display
      const preInstallVersions = new Map();
      if (existingInstall.installed) {
        const existingModules = await this.manifest.getAllModuleVersions(paths.bmadDir);
        for (const mod of existingModules) {
          if (mod.name && mod.version) {
            preInstallVersions.set(mod.name, mod.version);
          }
        }
      }
      // Results collector for consolidated summary
      const results = [];
-      const addResult = (step, status, detail = '') => results.push({ step, status, detail });
+      const addResult = (step, status, detail = '', meta = {}) => results.push({ step, status, detail, ...meta });
      // Capture previously installed skill IDs before they get overwritten
      const previousSkillIds = new Set();
      const prevCsvPath = path.join(paths.bmadDir, '_config', 'skill-manifest.csv');
      if (await fs.pathExists(prevCsvPath)) {
        try {
          const csvParse = require('csv-parse/sync');
          const content = await fs.readFile(prevCsvPath, 'utf8');
          const records = csvParse.parse(content, { columns: true, skip_empty_lines: true });
          for (const r of records) {
            if (r.canonicalId) previousSkillIds.add(r.canonicalId);
          }
        } catch (error) {
          await prompts.log.warn(`Failed to parse skill-manifest.csv: ${error.message}`);
        }
      }
      await this._cacheCustomModules(paths, addResult);
@ -65,7 +130,7 @@ class Installer {
      await this._installAndConfigure(config, originalConfig, paths, officialModuleIds, allModules, addResult, officialModules);
-      await this._setupIdes(config, allModules, paths, addResult);
+      await this._setupIdes(config, allModules, paths, addResult, previousSkillIds);
      const restoreResult = await this._restoreUserFiles(paths, updateState);
@ -76,6 +141,7 @@ class Installer {
        ides: config.ides,
        customFiles: restoreResult.customFiles.length > 0 ? restoreResult.customFiles : undefined,
        modifiedFiles: restoreResult.modifiedFiles.length > 0 ? restoreResult.modifiedFiles : undefined,
        preInstallVersions,
      });
      return {
@ -321,7 +387,7 @@ class Installer {
  /**
   * Set up IDE integrations for each selected IDE.
   */
-  async _setupIdes(config, allModules, paths, addResult) {
+  async _setupIdes(config, allModules, paths, addResult, previousSkillIds = new Set()) {
    if (config.skipIde || !config.ides || config.ides.length === 0) return;
    await this.ideManager.ensureInitialized();
@ -336,6 +402,7 @@ class Installer {
      const setupResult = await this.ideManager.setup(ide, paths.projectRoot, paths.bmadDir, {
        selectedModules: allModules || [],
        verbose: config.verbose,
        previousSkillIds,
      });
      if (setupResult.success) {
@ -556,7 +623,7 @@ class Installer {
      message(`${isQuickUpdate ? 'Updating' : 'Installing'} ${moduleName}...`);
      const moduleConfig = officialModules.moduleConfigs[moduleName] || {};
-      await officialModules.install(
+      const installResult = await officialModules.install(
        moduleName,
        paths.bmadDir,
        (filePath) => {
@ -570,7 +637,12 @@ class Installer {
        },
      );
-      addResult(`Module: ${moduleName}`, 'ok', isQuickUpdate ? 'updated' : 'installed');
+      // Get display name from source module.yaml; version from marketplace.json
      const sourcePath = await officialModules.findModuleSource(moduleName, { silent: true });
      const moduleInfo = sourcePath ? await officialModules.getModuleInfo(sourcePath, moduleName, '') : null;
      const displayName = moduleInfo?.name || moduleName;
      const version = sourcePath ? await this._getMarketplaceVersion(sourcePath) : '';
      addResult(displayName, 'ok', '', { moduleCode: moduleName, newVersion: version });
    }
  }
@ -598,7 +670,11 @@ class Installer {
        [moduleName]: { ...config.coreConfig, ...result.moduleConfig, ...collectedModuleConfig },
      });
-      addResult(`Module: ${moduleName}`, 'ok', isQuickUpdate ? 'updated' : 'installed');
+      // Get display name from source module.yaml; version from marketplace.json
      const moduleInfo = await officialModules.getModuleInfo(sourcePath, moduleName, '');
      const displayName = moduleInfo?.name || moduleName;
      const version = await this._getMarketplaceVersion(sourcePath);
      addResult(displayName, 'ok', '', { moduleCode: moduleName, newVersion: version });
    }
  }
@ -1062,23 +1138,10 @@ class Installer {
    const selectedIdes = new Set((context.ides || []).map((ide) => String(ide).toLowerCase()));
    // Build step lines with status indicators
    const preVersions = context.preInstallVersions || new Map();
    const lines = [];
    for (const r of results) {
-      let stepLabel = null;
+      const stepLabel = r.step;
      if (r.status !== 'ok') {
        stepLabel = r.step;
      } else if (r.step === 'Core') {
        stepLabel = 'BMAD';
      } else if (r.step.startsWith('Module: ')) {
        stepLabel = r.step;
      } else if (selectedIdes.has(String(r.step).toLowerCase())) {
        stepLabel = r.step;
      }
      if (!stepLabel) {
        continue;
      }
      let icon;
      if (r.status === 'ok') {
@ -1088,18 +1151,32 @@ class Installer {
      } else {
        icon = color.red('\u2717');
      }
-      const detail = r.detail ? color.dim(` (${r.detail})`) : '';
+
      // Build version detail for module results
      let detail = '';
      if (r.moduleCode && r.newVersion) {
        const oldVersion = preVersions.get(r.moduleCode);
        if (oldVersion && oldVersion === r.newVersion) {
          detail = ` (v${r.newVersion}, no change)`;
        } else if (oldVersion) {
          detail = ` (v${oldVersion} → v${r.newVersion})`;
        } else {
          detail = ` (v${r.newVersion}, installed)`;
        }
      } else if (r.detail) {
        detail = ` (${r.detail})`;
      }
      lines.push(`  ${icon}  ${stepLabel}${detail}`);
    }
    if ((context.ides || []).length === 0) {
-      lines.push(`  ${color.green('\u2713')}  No IDE selected ${color.dim('(installed in _bmad only)')}`);
+      lines.push(`  ${color.green('\u2713')}  No IDE selected (installed in _bmad only)`);
    }
    // Context and warnings
    lines.push('');
    if (context.bmadDir) {
-      lines.push(`  Installed to: ${color.dim(context.bmadDir)}`);
+      lines.push(`  Installed to: ${context.bmadDir}`);
    }
    if (context.customFiles && context.customFiles.length > 0) {
      lines.push(`  ${color.cyan(`Custom files preserved: ${context.customFiles.length}`)}`);
@ -1111,17 +1188,18 @@ class Installer {
    // Next steps
    lines.push(
      '',
-      '  Next steps:',
+      '  Get started:',
-      `    Read our new Docs Site: ${color.dim('https://docs.bmad-method.org/')}`,
+      `    1. Launch your AI agent from your project folder`,
-      `    Join our Discord: ${color.dim('https://discord.gg/gk8jAdXWmj')}`,
+      `    2. Not sure what to do? Invoke the ${color.cyan('bmad-help')} skill and ask it what to do!`,
-      `    Star us on GitHub: ${color.dim('https://github.com/bmad-code-org/BMAD-METHOD/')}`,
+      '',
-      `    Subscribe on YouTube: ${color.dim('https://www.youtube.com/@BMadCode')}`,
+      `    Blog, Docs and Guides: ${color.blue('https://bmadcode.com/')}`,
      `    Community: ${color.blue('https://discord.gg/gk8jAdXWmj')}`,
    );
    if (context.ides && context.ides.length > 0) {
      lines.push(`    Invoke the ${color.cyan('bmad-help')} skill in your IDE Agent to get started`);
    }
-    await prompts.note(lines.join('\n'), 'BMAD is ready to use!');
+    await prompts.box(lines.join('\n'), 'BMAD is ready to use!', {
      rounded: true,
      formatBorder: color.green,
    });
  }
  /**
@ -1231,6 +1309,7 @@ class Installer {
    }
    for (const moduleName of modulesToUpdate) {
      if (moduleName === 'core') continue; // Already collected above
      const modulePrompted = await quickModules.collectModuleConfigQuick(moduleName, projectDir, true);
      if (modulePrompted) {
        promptedForNewFields = true;
--- a/tools/installer/core/manifest.js
+++ b/tools/installer/core/manifest.js
@ -837,14 +837,13 @@ class Manifest {
   * @returns {Object} Version info object with version, source, npmPackage, repoUrl
   */
  async getModuleVersionInfo(moduleName, bmadDir, moduleSourcePath = null) {
    const os = require('node:os');
    const yaml = require('yaml');
-    // Built-in modules use BMad version (only core and bmm are in BMAD-METHOD repo)
+    // Resolve source type first, then read version with the correct path context
    if (['core', 'bmm'].includes(moduleName)) {
-      const bmadVersion = require(path.join(getProjectRoot(), 'package.json')).version;
+      const version = await this._readMarketplaceVersion(moduleName, moduleSourcePath);
      return {
-        version: bmadVersion,
+        version,
        source: 'built-in',
        npmPackage: null,
        repoUrl: null,
@ -857,42 +856,20 @@ class Manifest {
    const moduleInfo = await extMgr.getModuleByCode(moduleName);
    if (moduleInfo) {
-      // External module - try to get version from npm registry first, then fall back to cache
+      // External module: use moduleSourcePath if provided, otherwise fall back to cache
-      let version = null;
+      const version = await this._readMarketplaceVersion(moduleName, moduleSourcePath);
      if (moduleInfo.npmPackage) {
        // Fetch version from npm registry
        try {
          version = await this.fetchNpmVersion(moduleInfo.npmPackage);
        } catch {
          // npm fetch failed, try cache as fallback
        }
      }
      // If npm didn't work, try reading from cached repo's package.json
      if (!version) {
        const cacheDir = path.join(os.homedir(), '.bmad', 'cache', 'external-modules', moduleName);
        const packageJsonPath = path.join(cacheDir, 'package.json');
        if (await fs.pathExists(packageJsonPath)) {
          try {
            const pkg = require(packageJsonPath);
            version = pkg.version;
          } catch (error) {
            await prompts.log.warn(`Failed to read package.json for ${moduleName}: ${error.message}`);
          }
        }
      }
      return {
-        version: version,
+        version,
        source: 'external',
        npmPackage: moduleInfo.npmPackage || null,
        repoUrl: moduleInfo.url || null,
      };
    }
-    // Custom module - check cache directory
+    // Custom module: resolve path from source or cache before reading version
    const customSourcePath = moduleSourcePath || path.join(bmadDir, '_config', 'custom', moduleName);
    const version = await this._readMarketplaceVersion(moduleName, customSourcePath);
    const cacheDir = path.join(bmadDir, '_config', 'custom', moduleName);
    const moduleYamlPath = path.join(cacheDir, 'module.yaml');
@ -901,7 +878,7 @@ class Manifest {
        const yamlContent = await fs.readFile(moduleYamlPath, 'utf8');
        const moduleConfig = yaml.parse(yamlContent);
        return {
-          version: moduleConfig.version || null,
+          version: version || moduleConfig.version || null,
          source: 'custom',
          npmPackage: moduleConfig.npmPackage || null,
          repoUrl: moduleConfig.repoUrl || null,
@ -913,13 +890,62 @@ class Manifest {
    // Unknown module
    return {
-      version: null,
+      version,
      source: 'unknown',
      npmPackage: null,
      repoUrl: null,
    };
  }
  /**
   * Read version from .claude-plugin/marketplace.json for a module
   * @param {string} moduleName - Module code
   * @returns {string|null} Version or null
   */
  async _readMarketplaceVersion(moduleName, moduleSourcePath = null) {
    const os = require('node:os');
    let marketplacePath;
    if (['core', 'bmm'].includes(moduleName)) {
      marketplacePath = path.join(getProjectRoot(), '.claude-plugin', 'marketplace.json');
    } else if (moduleSourcePath) {
      // Walk up from source path to find marketplace.json
      let dir = moduleSourcePath;
      for (let i = 0; i < 5; i++) {
        const candidate = path.join(dir, '.claude-plugin', 'marketplace.json');
        if (await fs.pathExists(candidate)) {
          marketplacePath = candidate;
          break;
        }
        const parent = path.dirname(dir);
        if (parent === dir) break;
        dir = parent;
      }
    }
    // Fallback to external module cache
    if (!marketplacePath) {
      const cacheDir = path.join(os.homedir(), '.bmad', 'cache', 'external-modules', moduleName);
      marketplacePath = path.join(cacheDir, '.claude-plugin', 'marketplace.json');
    }
    try {
      if (await fs.pathExists(marketplacePath)) {
        const data = JSON.parse(await fs.readFile(marketplacePath, 'utf8'));
        const plugins = data?.plugins;
        if (!Array.isArray(plugins) || plugins.length === 0) return null;
        let best = null;
        for (const p of plugins) {
          if (p.version && (!best || p.version > best)) best = p.version;
        }
        return best;
      }
    } catch {
      // ignore
    }
    return null;
  }
  /**
   * Fetch latest version from npm for a package
   * @param {string} packageName - npm package name
--- a/tools/installer/ide/_config-driven.js
+++ b/tools/installer/ide/_config-driven.js
@ -86,7 +86,7 @@ class ConfigDrivenIdeSetup {
    if (!options.silent) await prompts.log.info(`Setting up ${this.name}...`);
    // Clean up any old BMAD installation first
-    await this.cleanup(projectDir, options);
+    await this.cleanup(projectDir, options, bmadDir);
    if (!this.installerConfig) {
      return { success: false, reason: 'no-config' };
@ -215,15 +215,34 @@ class ConfigDrivenIdeSetup {
   * Cleanup IDE configuration
   * @param {string} projectDir - Project directory
   */
-  async cleanup(projectDir, options = {}) {
+  async cleanup(projectDir, options = {}, bmadDir = null) {
    const resolvedBmadDir = bmadDir || (await this._findBmadDir(projectDir));
    // Build removal set: previously installed skills + removals.txt entries
    let removalSet;
    if (options.previousSkillIds && options.previousSkillIds.size > 0) {
      // Install/update flow: use pre-captured skill IDs (before manifest was overwritten)
      removalSet = new Set(options.previousSkillIds);
      if (resolvedBmadDir) {
        const removals = await this.loadRemovalLists(resolvedBmadDir);
        for (const entry of removals) removalSet.add(entry);
      }
    } else if (resolvedBmadDir) {
      // Uninstall flow: read from current skill-manifest.csv + removals.txt
      removalSet = await this._buildUninstallSet(resolvedBmadDir);
    } else {
      removalSet = new Set();
    }
    // Migrate legacy target directories (e.g. .opencode/agent → .opencode/agents)
    // Legacy dirs are abandoned entirely, so use prefix matching (null removalSet)
    if (this.installerConfig?.legacy_targets) {
      if (!options.silent) await prompts.log.message('  Migrating legacy directories...');
      for (const legacyDir of this.installerConfig.legacy_targets) {
        if (this.isGlobalPath(legacyDir)) {
          await this.warnGlobalLegacy(legacyDir, options);
        } else {
-          await this.cleanupTarget(projectDir, legacyDir, options);
+          await this.cleanupTarget(projectDir, legacyDir, options, null);
          await this.removeEmptyParents(projectDir, legacyDir);
        }
      }
@ -244,9 +263,9 @@ class ConfigDrivenIdeSetup {
      await this.cleanupRovoDevPrompts(projectDir, options);
    }
-    // Clean target directory
+    // Clean current target directory
    if (this.installerConfig?.target_dir) {
-      await this.cleanupTarget(projectDir, this.installerConfig.target_dir, options);
+      await this.cleanupTarget(projectDir, this.installerConfig.target_dir, options, removalSet);
    }
  }
@ -286,23 +305,117 @@ class ConfigDrivenIdeSetup {
  }
  /**
-   * Cleanup a specific target directory
+   * Find the _bmad directory in a project
   * @param {string} projectDir - Project directory
   * @returns {string|null} Path to bmad dir or null
   */
  async _findBmadDir(projectDir) {
    const bmadDir = path.join(projectDir, BMAD_FOLDER_NAME);
    return (await fs.pathExists(bmadDir)) ? bmadDir : null;
  }
  /**
   * Build the full set of entries to remove for uninstall.
   * Reads skill-manifest.csv to know exactly what was installed, plus removal lists.
   * @param {string} bmadDir - BMAD installation directory
   * @returns {Set<string>} Set of entries to remove
   */
  async _buildUninstallSet(bmadDir) {
    const removals = await this.loadRemovalLists(bmadDir);
    // Also add all currently installed skills from skill-manifest.csv
    const csvPath = path.join(bmadDir, '_config', 'skill-manifest.csv');
    try {
      if (await fs.pathExists(csvPath)) {
        const content = await fs.readFile(csvPath, 'utf8');
        const records = csv.parse(content, { columns: true, skip_empty_lines: true });
        for (const record of records) {
          if (record.canonicalId) {
            removals.add(record.canonicalId);
          }
        }
      }
    } catch {
      // If we can't read the manifest, we still have the removal lists
    }
    return removals;
  }
  /**
   * Load removal lists from all module sources in the bmad directory.
   * Each module can have an optional removals.txt listing entries to remove.
   * @param {string} bmadDir - BMAD installation directory
   * @returns {Set<string>} Set of entries to remove
   */
  async loadRemovalLists(bmadDir) {
    const removals = new Set();
    const { getProjectRoot } = require('../project-root');
    // Read project-level removals.txt (covers core and bmm)
    const projectRemovalsPath = path.join(getProjectRoot(), 'removals.txt');
    await this._readRemovalFile(projectRemovalsPath, removals);
    // Read per-module removals.txt from installed module directories
    try {
      const entries = await fs.readdir(bmadDir);
      for (const entry of entries) {
        if (entry.startsWith('_')) continue;
        const removalPath = path.join(bmadDir, entry, 'removals.txt');
        await this._readRemovalFile(removalPath, removals);
      }
    } catch {
      // bmadDir may not exist yet on fresh install
    }
    return removals;
  }
  /**
   * Read a removals.txt file and add entries to the set
   * @param {string} filePath - Path to removals.txt
   * @param {Set<string>} removals - Set to add entries to
   */
  async _readRemovalFile(filePath, removals) {
    try {
      if (await fs.pathExists(filePath)) {
        const content = await fs.readFile(filePath, 'utf8');
        for (const line of content.split('\n')) {
          const trimmed = line.trim();
          if (trimmed && !trimmed.startsWith('#')) {
            removals.add(trimmed);
          }
        }
      }
    } catch {
      // Optional file — ignore errors
    }
  }
  /**
   * Cleanup a specific target directory.
   * When removalSet is provided, only removes entries in that set.
   * When removalSet is null (legacy dirs), removes all bmad-prefixed entries.
   * @param {string} projectDir - Project directory
   * @param {string} targetDir - Target directory to clean
   * @param {Object} options - Cleanup options
   * @param {Set<string>|null} removalSet - Entries to remove, or null for legacy prefix matching
   */
-  async cleanupTarget(projectDir, targetDir, options = {}) {
+  async cleanupTarget(projectDir, targetDir, options = {}, removalSet = new Set()) {
    const targetPath = path.join(projectDir, targetDir);
    if (!(await fs.pathExists(targetPath))) {
      return;
    }
-    // Remove all bmad* files
+    if (removalSet && removalSet.size === 0) {
      return;
    }
    let entries;
    try {
      entries = await fs.readdir(targetPath);
    } catch {
      // Directory exists but can't be read - skip cleanup
      return;
    }
@ -313,23 +426,26 @@ class ConfigDrivenIdeSetup {
    let removedCount = 0;
    for (const entry of entries) {
-      if (!entry || typeof entry !== 'string') {
+      if (!entry || typeof entry !== 'string') continue;
-        continue;
+
-      }
+      // Always preserve bmad-os-* utility skills regardless of cleanup mode
-      if (entry.startsWith('bmad') && !entry.startsWith('bmad-os-')) {
+      if (entry.startsWith('bmad-os-')) continue;
-        const entryPath = path.join(targetPath, entry);
+
      // Surgical removal from set, or legacy prefix matching when set is null
      const shouldRemove = removalSet ? removalSet.has(entry) : entry.startsWith('bmad');
      if (shouldRemove) {
        try {
-          await fs.remove(entryPath);
+          await fs.remove(path.join(targetPath, entry));
          removedCount++;
        } catch {
-          // Skip entries that can't be removed (broken symlinks, permission errors)
+          // Skip entries that can't be removed
        }
      }
    }
-    if (removedCount > 0 && !options.silent) {
+    // Only log cleanup when it's not a routine reinstall (legacy dir cleanup or actual removals)
-      await prompts.log.message(`  Cleaned ${removedCount} BMAD files from ${targetDir}`);
+    // Suppress for current target_dir since it's always cleaned before a fresh write
    }
    // Remove empty directory after cleanup
    if (removedCount > 0) {
@ -339,7 +455,7 @@ class ConfigDrivenIdeSetup {
          await fs.remove(targetPath);
        }
      } catch {
-        // Directory may already be gone or in use — skip
+        // Directory may already be gone or in use
      }
    }
  }
--- a/tools/installer/install-messages.yaml
+++ b/tools/installer/install-messages.yaml
@ -6,32 +6,25 @@
 startMessage: |
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  🎉 V6 IS HERE! Welcome to BMad Method V6 - Official Stable Release!
+  Agile AI-Driven Development. Powered by BMad Core and a growing module ecosystem.
  Install official and community modules during setup to customize your experience.
-  The BMad Method is now a Platform powered by the BMad Method Core and Module Ecosystem!
+  🌟 100% free. 100% open source. Always.
-    - Select and install modules during setup - customize your experience
+     No paywalls. No gated content. Knowledge shared, not sold.
    - New BMad Method for Agile AI-Driven Development (the evolution of V4)
    - Exciting new modules available during installation, with community modules coming soon
    - Documentation: https://docs.bmad-method.org
-  🌟 BMad is 100% free and open source.
+  🌐 CONNECT:
-    - No gated Discord. No paywalls. No gated content.
+    Website:   https://bmadcode.com/
-    - We believe in empowering everyone, not just those who can pay.
+    Discord:   https://discord.gg/gk8jAdXWmj
-    - Knowledge should be shared, not sold.
+    YouTube:   https://www.youtube.com/@BMadCode
    X:         https://x.com/BMadCode
    Facebook:  https://facebook.com/@BMadCode
-  🎤 SPEAKING & MEDIA:
+  ⭐ SUPPORT THE PROJECT:
-    - Available for conferences, podcasts, and media appearances
+    Star us:   https://github.com/bmad-code-org/BMAD-METHOD/
-    - Topics: AI-Native Transformation, Spec and Context Engineering, BMad Method
+    Donate:    https://buymeacoffee.com/bmad
-    - For speaking inquiries or interviews, reach out to BMad on Discord!
+    Corporate sponsorship and speaking inquiries: contact@bmadcode.com
-  ⭐ HELP US GROW:
+  Docs, blog, and latest updates: https://bmadcode.com/
    - Star us on GitHub: https://github.com/bmad-code-org/BMAD-METHOD/
    - Subscribe on YouTube: https://www.youtube.com/@BMadCode
    - Free Community and Support: https://discord.gg/gk8jAdXWmj
    - Donate: https://buymeacoffee.com/bmad
    - Corporate Sponsorship available
  Latest updates: https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CHANGELOG.md
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
--- a/tools/installer/ui.js
+++ b/tools/installer/ui.js
@ -4,8 +4,50 @@ const fs = require('fs-extra');
 const { CLIUtils } = require('./cli-utils');
 const { CustomHandler } = require('./custom-handler');
 const { ExternalModuleManager } = require('./modules/external-manager');
 const { getProjectRoot } = require('./project-root');
 const prompts = require('./prompts');
 /**
 * Read module version from .claude-plugin/marketplace.json
 * @param {string} moduleCode - Module code (e.g., 'core', 'bmm', 'cis')
 * @returns {string} Version string or empty string
 */
 async function getMarketplaceVersion(moduleCode) {
  let marketplacePath;
  if (moduleCode === 'core' || moduleCode === 'bmm') {
    marketplacePath = path.join(getProjectRoot(), '.claude-plugin', 'marketplace.json');
  } else {
    const cacheDir = path.join(os.homedir(), '.bmad', 'cache', 'external-modules', moduleCode);
    marketplacePath = path.join(cacheDir, '.claude-plugin', 'marketplace.json');
  }
  try {
    if (await fs.pathExists(marketplacePath)) {
      const data = JSON.parse(await fs.readFile(marketplacePath, 'utf8'));
      return _extractMarketplaceVersion(data);
    }
  } catch {
    // ignore
  }
  return '';
 }
 /**
 * Extract the highest version from marketplace.json plugins array.
 * Handles multiple plugins per file safely.
 * @param {Object} data - Parsed marketplace.json
 * @returns {string} Version string or empty string
 */
 function _extractMarketplaceVersion(data) {
  const plugins = data?.plugins;
  if (!Array.isArray(plugins) || plugins.length === 0) return '';
  // Use the highest version across all plugins in the file
  let best = '';
  for (const p of plugins) {
    if (p.version && (!best || p.version > best)) best = p.version;
  }
  return best;
 }
 // Separator class for visual grouping in select/multiselect prompts
 // Note: @clack/prompts doesn't support separators natively, they are filtered out
 class Separator {
@ -70,17 +112,14 @@ class UI {
    if (hasExistingInstall) {
      // Get version information
      const { existingInstall, bmadDir } = await this.getExistingInstallation(confirmedDirectory);
      const packageJsonPath = path.join(__dirname, '../../package.json');
      const currentVersion = require(packageJsonPath).version;
      const installedVersion = existingInstall.installed ? existingInstall.version || 'unknown' : 'unknown';
      // Build menu choices dynamically
      const choices = [];
      // Always show Quick Update first (allows refreshing installation even on same version)
-      if (installedVersion !== 'unknown') {
+      if (existingInstall.installed) {
        choices.push({
-          name: `Quick Update (v${installedVersion} → v${currentVersion})`,
+          name: 'Quick Update',
          value: 'quick-update',
        });
      }
@ -880,14 +919,18 @@ class UI {
    const lockedValues = ['core'];
    // Core module is always installed — show it locked at the top
-    allOptions.push({ label: 'BMad Core Module', value: 'core', hint: 'Core configuration and shared resources' });
+    const coreVersion = await getMarketplaceVersion('core');
    const coreLabel = coreVersion ? `BMad Core Module (v${coreVersion})` : 'BMad Core Module';
    allOptions.push({ label: coreLabel, value: 'core', hint: 'Core configuration and shared resources' });
    initialValues.push('core');
    // Helper to build module entry with proper sorting and selection
-    const buildModuleEntry = (mod, value, group) => {
+    const buildModuleEntry = async (mod, value, group) => {
      const isInstalled = installedModuleIds.has(value);
      const version = await getMarketplaceVersion(value);
      const label = version ? `${mod.name} (v${version})` : mod.name;
      return {
-        label: mod.name,
+        label,
        value,
        hint: mod.description || group,
        // Pre-select only if already installed (not on fresh install)
@ -899,7 +942,7 @@ class UI {
    const localEntries = [];
    for (const mod of localModules) {
      if (!mod.isCustom && mod.id !== 'core') {
-        const entry = buildModuleEntry(mod, mod.id, 'Local');
+        const entry = await buildModuleEntry(mod, mod.id, 'Local');
        localEntries.push(entry);
        if (entry.selected) {
          initialValues.push(mod.id);
@ -912,7 +955,7 @@ class UI {
    const officialModules = [];
    for (const mod of externalModules) {
      if (mod.type === 'bmad-org') {
-        const entry = buildModuleEntry(mod, mod.code, 'Official');
+        const entry = await buildModuleEntry(mod, mod.code, 'Official');
        officialModules.push(entry);
        if (entry.selected) {
          initialValues.push(mod.code);
@ -925,7 +968,7 @@ class UI {
    const communityModules = [];
    for (const mod of externalModules) {
      if (mod.type === 'community') {
-        const entry = buildModuleEntry(mod, mod.code, 'Community');
+        const entry = await buildModuleEntry(mod, mod.code, 'Community');
        communityModules.push(entry);
        if (entry.selected) {
          initialValues.push(mod.code);
--- a/website/astro.config.mjs
+++ b/website/astro.config.mjs
@ -92,33 +92,55 @@ export default defineConfig({
      // Sidebar configuration (Diataxis structure)
      sidebar: [
-        { label: 'Welcome', translations: { 'vi-VN': 'Chào mừng', 'zh-CN': '欢迎', 'fr-FR': 'Bienvenue' }, slug: 'index' },
+        {
-        { label: 'Roadmap', translations: { 'vi-VN': 'Lộ trình', 'zh-CN': '路线图', 'fr-FR': 'Feuille de route' }, slug: 'roadmap' },
+          label: 'Welcome',
          translations: { 'vi-VN': 'Chào mừng', 'zh-CN': '欢迎', 'fr-FR': 'Bienvenue', 'cs-CZ': 'Vítejte' },
          slug: 'index',
        },
        {
          label: 'Roadmap',
          translations: { 'vi-VN': 'Lộ trình', 'zh-CN': '路线图', 'fr-FR': 'Feuille de route', 'cs-CZ': 'Plán rozvoje' },
          slug: 'roadmap',
        },
        {
          label: 'Tutorials',
-          translations: { 'vi-VN': 'Hướng dẫn nhập môn', 'zh-CN': '教程', 'fr-FR': 'Tutoriels' },
+          translations: { 'vi-VN': 'Hướng dẫn nhập môn', 'zh-CN': '教程', 'fr-FR': 'Tutoriels', 'cs-CZ': 'Tutoriály' },
          collapsed: false,
          autogenerate: { directory: 'tutorials' },
        },
        {
          label: 'How-To Guides',
-          translations: { 'vi-VN': 'Hướng dẫn tác vụ', 'zh-CN': '操作指南', 'fr-FR': 'Guides pratiques' },
+          translations: { 'vi-VN': 'Hướng dẫn tác vụ', 'zh-CN': '操作指南', 'fr-FR': 'Guides pratiques', 'cs-CZ': 'Praktické návody' },
          collapsed: true,
          autogenerate: { directory: 'how-to' },
        },
        {
          label: 'Explanation',
-          translations: { 'vi-VN': 'Giải thích', 'zh-CN': '概念说明', 'fr-FR': 'Explications' },
+          translations: { 'vi-VN': 'Giải thích', 'zh-CN': '概念说明', 'fr-FR': 'Explications', 'cs-CZ': 'Vysvětlení' },
          collapsed: true,
          autogenerate: { directory: 'explanation' },
        },
        {
          label: 'Reference',
-          translations: { 'vi-VN': 'Tham chiếu', 'zh-CN': '参考', 'fr-FR': 'Référence' },
+          translations: { 'vi-VN': 'Tham chiếu', 'zh-CN': '参考', 'fr-FR': 'Référence', 'cs-CZ': 'Reference' },
          collapsed: true,
          autogenerate: { directory: 'reference' },
        },
        // TEA docs moved to standalone module site; keep BMM sidebar focused.
        {
          label: 'BMad Ecosystem',
          collapsed: false,
          items: [
            { label: 'BMad Builder', link: 'https://bmad-builder-docs.bmad-method.org/', attrs: { target: '_blank' } },
            { label: 'Creative Intelligence Suite', link: 'https://cis-docs.bmad-method.org/', attrs: { target: '_blank' } },
            { label: 'Game Dev Studio', link: 'https://game-dev-studio-docs.bmad-method.org/', attrs: { target: '_blank' } },
            {
              label: 'Test Architect (TEA)',
              link: 'https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/',
              attrs: { target: '_blank' },
            },
          ],
        },
      ],
      // Credits in footer
--- a/website/src/components/Banner.astro
+++ b/website/src/components/Banner.astro
@ -7,9 +7,13 @@ const llmsFullUrl = `${getSiteUrl()}/llms-full.txt`;
 <div class="ai-banner" role="note" aria-label="AI documentation notice">
  <span>🤖 Consolidated, AI-optimized BMAD docs: <a href={llmsFullUrl}>llms-full.txt</a>. Fetch this plain text file for complete context.</span>
 </div>
 <div class="announce-banner" role="note" aria-label="BMad Builder announcement">
  <span>🚀 Build your own BMad modules and share them with the community! <a href="https://bmad-builder-docs.bmad-method.org/tutorials/build-your-first-module/">Get started</a> or <a href="https://bmad-builder-docs.bmad-method.org/how-to/distribute-your-module/">submit to the marketplace</a>.</span>
 </div>
 <style>
-  .ai-banner {
+  .ai-banner,
  .announce-banner {
    width: 100%;
    height: var(--ai-banner-height, 2.75rem);
    background: #1a1a1a;
@ -25,37 +29,48 @@ const llmsFullUrl = `${getSiteUrl()}/llms-full.txt`;
  }
  /* Truncate text on narrow screens */
-  .ai-banner span {
+  .ai-banner span,
  .announce-banner span {
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    max-width: 100%;
  }
-  .ai-banner a {
+  .ai-banner a,
  .announce-banner a {
    color: #3b82f6;
    text-decoration: none;
    font-weight: 600;
  }
-  .ai-banner a:hover {
+  .ai-banner a:hover,
  .announce-banner a:hover {
    color: #fafafa;
    text-decoration: underline;
  }
-  .ai-banner a:focus-visible {
+  .ai-banner a:focus-visible,
  .announce-banner a:focus-visible {
    outline: 2px solid #3b82f6;
    outline-offset: 2px;
    border-radius: 2px;
  }
  .announce-banner {
    background: #1a2332;
    border-bottom: 1px solid #1e3a5f;
  }
  /* Match navbar padding at breakpoints */
  @media (min-width: 50rem) {
-    .ai-banner {
+    .ai-banner,
    .announce-banner {
      padding-left: 2.5rem;
      padding-right: 2.5rem;
    }
  }
  @media (min-width: 72rem) {
-    .ai-banner {
+    .ai-banner,
    .announce-banner {
      padding-left: 3rem;
      padding-right: 3rem;
    }
--- a/website/src/lib/locales.mjs
+++ b/website/src/lib/locales.mjs
@ -27,6 +27,10 @@ export const locales = {
    label: 'Français',
    lang: 'fr-FR',
  },
  cs: {
    label: 'Čeština',
    lang: 'cs-CZ',
  },
 };
 /**
Author	SHA1	Message	Date
gabadi	075b0279f5	Merge `cb6006686c` into `c46502f640`	2026-04-07 18:59:23 +02:00
Brian	c46502f640	feat(installer): overhaul branding, versioning, and skill cleanup (#2223 ) * feat(installer): overhaul branding, versioning, and skill cleanup Logo and branding: - Responsive logo: full "BMAD METHOD" at >=95 cols, "BMAD" for narrower terminals - Color scheme updated from yellow to blue (matching bmadcode.com brand) - Added copyright notice and tagline in white for contrast - Removed version number from logo (individual module versions shown in summary) - Added ™ to both wide and narrow logo variants Installer start message: - Replaced outdated V6 launch announcement with clean welcome - Consolidated redundant module/platform messaging into single intro - Tightened open source manifesto (same spirit, fewer words) - Merged speaking/media into support section with contact email - Added full social links: Website, Discord, YouTube, X, Facebook - Replaced docs.bmad-method.org and changelog links with bmadcode.com hub Install summary improvements: - Module names now show full display names from module.yaml (not abbreviations) - All module versions sourced from .claude-plugin/marketplace.json exclusively - Summary shows version transitions: "v6.2.2 -> v6.3.0", "v6.3.0, no change", or "v6.3.0, installed" for fresh installs - Switched summary from clack note() to box() for full-brightness text - Removed dim/gray styling that was hard to read on dark terminals - Links styled with color.blue instead of color.dim - Get started section leads with actionable steps (launch agent, run bmad-help) - Removed redundant social links (already shown in start message) Version source unification: - All module versions now come from .claude-plugin/marketplace.json only - Removed package.json as version source for core/bmm modules - Updated manifest.js getModuleVersionInfo() to use marketplace.json - Updated installer.js _getMarketplaceVersion() helper - Updated ui.js getMarketplaceVersion() for module selection display - Quick Update menu no longer shows misleading version (was using package.json) - Module selection list now shows versions next to each module name Skill cleanup overhaul: - Replaced blunt-force bmad-* prefix deletion with surgical removal system - Added removals.txt support: optional per-project file listing skills to remove - Created initial removals.txt with all skills removed since v6.2.0 - Install/update: captures previously installed skill IDs from skill-manifest.csv before manifest regeneration, then removes those + removals.txt entries - Uninstall: removes all installed skills via skill-manifest.csv + removals.txt - Deselecting modules now correctly removes their skills from IDE directories - User-created bmad-* skills in IDE directories are no longer destroyed - Legacy directory cleanup retains prefix matching (those dirs are abandoned) Bug fixes: - Fixed duplicate "CORE module already up to date" during quick update - Fixed version display showing package.json version instead of actual module version - Updated test fixture for bmad-os-* preservation test to use skill-manifest.csv * fix(installer): address Augment review findings - Fix plugins[0] fragility: extract highest version across all plugins in marketplace.json instead of assuming first entry (ui.js, installer.js, manifest.js) - Fix _readMarketplaceVersion ignoring moduleSourcePath: custom modules can now source their own marketplace.json by walking up from source path - Hard-exclude bmad-os-* utility skills in both surgical and legacy cleanup modes, preventing accidental deletion if tracked in manifests - Distinguish missing file vs parse error in skill-manifest.csv reading: warn on corrupt CSV instead of silently skipping cleanup * fix(installer): resolve module source before reading marketplace version Move _readMarketplaceVersion call after source type resolution so custom modules use their own source path instead of falling back to the external module cache, which could match a different module with the same code.	2026-04-07 02:31:36 -05:00
Brian	47991536c5	docs: add Python 3.10+ and uv as prerequisites (#2221 )	2026-04-06 00:30:00 -05:00
Alex Verkhovsky	595746335c	fix(docs): wrap bare email in angle brackets for markdownlint MD034 (#2219 )	2026-04-05 13:14:03 -07:00
Brian	28aa522753	Update community and support links in README (#2215 )	2026-04-05 00:52:39 -05:00
Alex Verkhovsky	aefabc74b0	feat(quick-dev): add previous story continuity to context loading (#2201 ) When quick-dev infers the intent is an epic story, it now scans for completed specs from the same epic and loads the most recent one to extract Code Map, Design Notes, Spec Change Log, and task list as continuity context for planning.	2026-04-04 20:49:55 -07:00
Alex Verkhovsky	aa48f83a65	docs: rewrite get-answers-about-bmad for flow and accuracy (#2213 ) Restructure from two glued-together documents into a single escalation flow (bmad-help → source → community). Remove references to deprecated _bmad folder and closed Discord channels. Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-04 20:44:43 -07:00
JakubStejskalCZ	ac18b195e9	docs(cs): add Czech (Čeština) documentation translation (#2134 ) * docs(cs): add Czech (Čeština) documentation translation Add complete Czech translation of all 29 documentation files mirroring the English source structure. Register cs-CZ locale in Starlight config with sidebar label translations. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(cs): repair corrupted characters and table formatting in Czech docs Fix UTF-8 encoding artifacts in customize-bmad.md and upgrade-to-v6.md, align markdown table formatting, and correct Czech grammar in project-context.md heading. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(cs): address CodeRabbit review feedback - Normalize 64 Czech quotation marks to proper „…" pairs across 14 files - Fix corrupted UTF-8 box-drawing character in upgrade-to-v6.md - Use relative roadmap link (./roadmap) in index.md for locale consistency - Fix typo: Podníková → Podniková in modules.md Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(cs): sync Czech translation with upstream agent consolidation and PRFAQ addition Agents: remove Barry/Quinn/Bob (merged into Developer), add WB trigger and PRFAQ to Analyst. Tutorials/commands/workflow-map: fix SM→DEV references, add PRFAQ workflow entries. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> Co-authored-by: Alex Verkhovsky <alexey.verkhovsky@gmail.com>	2026-04-04 20:42:54 -07:00
Alex Verkhovsky	1050415351	refactor(code-review): harmonize step-01 intent cascade (#2206 ) * refactor(code-review): harmonize step-01 intent cascade with quick-dev and checkpoint-preview Replace keyword-matching entry point with 5-tier priority cascade: explicit argument → recent conversation → sprint tracking → git state → ask. Diff-mode keyword detection preserved as sub-check within tier 1. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(code-review): address review findings in step-01 intent cascade - Set {spec_file} immediately in Tier 1 when spec provided - Add staged/uncommitted handlers to instruction 3 dispatch table - Replace undefined {branch}/{sha} placeholders with angle brackets - Fix {story_key} vs {{story-id}} placeholder mismatch - Correct "wants reviewed" grammar to "wants to be reviewed" --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-04 20:07:15 -07:00
Brian	783601b576	fix: move BMB announcement to custom Banner component (#2210 ) Starlight banner config doesn't render with custom Header. Added announcement row to Banner.astro and removed unused config.	2026-04-04 16:10:37 -05:00
Brian	975aea6e74	docs: add BMad Builder announcement banner to docs site (#2209 )	2026-04-04 16:02:26 -05:00
Alex Verkhovsky	f98083ba75	docs: add contribution guardrails for unsolicited PRs (#2207 ) Add Discord-first callout banner and AI-generated code curation policy. Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-04 12:13:06 -05:00
Brian	3a24d8ffc9	docs: add BMad Ecosystem cross-links to sidebar (#2204 )	2026-04-04 00:34:00 -05:00
Brian	15f49b8bd4	docs: add BMad Ecosystem cross-links to sidebar (#2203 )	2026-04-04 00:27:47 -05:00