feat(workflows): add brownfield epic scoping to detect file churn (#1823)

Add design completeness gate, file overlap check, and validation
to prevent unnecessary file churn when epics target the same component.

.augment/code_review_guidelines.yaml

@@ -1,7 +1,6 @@
 # Augment Code Review Guidelines for BMAD-METHOD
 # https://docs.augmentcode.com/codereview/overview
-# Focus: Skill validation and quality
-# Canonical rules: tools/skill-validator.md (single source of truth)
+# Focus: Workflow validation and quality
 
 file_paths_to_ignore:
   # --- Shared baseline: tool configs ---
@@ -49,17 +48,163 @@ file_paths_to_ignore:
 
 areas:
   # ============================================
-  # SKILL FILES
+  # WORKFLOW STRUCTURE RULES
   # ============================================
-  skill_files:
-    description: "All skill content — SKILL.md, workflow.md, step files, data files, and templates within skill directories"
+  workflow_structure:
+    description: "Workflow folder organization and required components"
     globs:
-      - "src/**/skills/**"
       - "src/**/workflows/**"
-      - "src/**/tasks/**"
     rules:
-      - id: "skill_validation"
-        description: "Apply the full rule catalog defined in tools/skill-validator.md. That file is the single source of truth for all skill validation rules covering SKILL.md metadata, workflow.md constraints, step file structure, path references, variable resolution, sequential execution, and skill invocation syntax."
+      - id: "workflow_entry_point_required"
+        description: "Every workflow folder must have workflow.yaml, workflow.md, or workflow.xml as entry point"
+        severity: "high"
+
+      - id: "sharded_workflow_steps_folder"
+        description: "Sharded workflows (using workflow.md) must have steps/ folder with numbered files (step-01-*.md, step-02-*.md)"
+        severity: "high"
+
+      - id: "standard_workflow_instructions"
+        description: "Standard workflows using workflow.yaml must include instructions.md for execution guidance"
+        severity: "medium"
+
+      - id: "workflow_step_limit"
+        description: "Workflows should have 5-10 steps maximum to prevent context loss in LLM execution"
+        severity: "medium"
+
+  # ============================================
+  # WORKFLOW ENTRY FILE RULES
+  # ============================================
+  workflow_definitions:
+    description: "Workflow entry files (workflow.yaml, workflow.md, workflow.xml)"
+    globs:
+      - "src/**/workflows/**/workflow.yaml"
+      - "src/**/workflows/**/workflow.md"
+      - "src/**/workflows/**/workflow.xml"
+    rules:
+      - id: "workflow_name_required"
+        description: "Workflow entry files must define 'name' field in frontmatter or root element"
+        severity: "high"
+
+      - id: "workflow_description_required"
+        description: "Workflow entry files must include 'description' explaining the workflow's purpose"
+        severity: "high"
+
+      - id: "workflow_config_source"
+        description: "Workflows should reference config_source for variable resolution (e.g., {project-root}/_bmad/module/config.yaml)"
+        severity: "medium"
+
+      - id: "workflow_installed_path"
+        description: "Workflows should define installed_path for relative file references within the workflow"
+        severity: "medium"
+
+      - id: "valid_step_references"
+        description: "Step file references in workflow entry must point to existing files"
+        severity: "high"
+
+  # ============================================
+  # SHARDED WORKFLOW STEP RULES
+  # ============================================
+  workflow_steps:
+    description: "Individual step files in sharded workflows"
+    globs:
+      - "src/**/workflows/**/steps/step-*.md"
+    rules:
+      - id: "step_goal_required"
+        description: "Each step must clearly state its goal (## STEP GOAL, ## YOUR TASK, or step n='X' goal='...')"
+        severity: "high"
+
+      - id: "step_mandatory_rules"
+        description: "Step files should include MANDATORY EXECUTION RULES section with universal agent behavior rules"
+        severity: "medium"
+
+      - id: "step_context_boundaries"
+        description: "Step files should define CONTEXT BOUNDARIES explaining available context and limits"
+        severity: "medium"
+
+      - id: "step_success_metrics"
+        description: "Step files should include SUCCESS METRICS section with ✅ checkmarks for validation criteria"
+        severity: "medium"
+
+      - id: "step_failure_modes"
+        description: "Step files should include FAILURE MODES section with ❌ marks for anti-patterns to avoid"
+        severity: "medium"
+
+      - id: "step_next_step_reference"
+        description: "Step files should reference the next step file path for sequential execution"
+        severity: "medium"
+
+      - id: "step_no_forward_loading"
+        description: "Steps must NOT load future step files until current step completes - just-in-time loading only"
+        severity: "high"
+
+      - id: "valid_file_references"
+        description: "File path references using {variable}/filename.md must point to existing files"
+        severity: "high"
+
+      - id: "step_naming"
+        description: "Step files must be named step-NN-description.md (e.g., step-01-init.md, step-02-context.md)"
+        severity: "medium"
+
+      - id: "halt_before_menu"
+        description: "Steps presenting user menus ([C] Continue, [a] Advanced, etc.) must HALT and wait for response"
+        severity: "high"
+
+  # ============================================
+  # XML WORKFLOW/TASK RULES
+  # ============================================
+  xml_workflows:
+    description: "XML-based workflows and tasks"
+    globs:
+      - "src/**/workflows/**/*.xml"
+      - "src/**/tasks/**/*.xml"
+    rules:
+      - id: "xml_task_id_required"
+        description: "XML tasks must have unique 'id' attribute on root task element"
+        severity: "high"
+
+      - id: "xml_llm_instructions"
+        description: "XML workflows should include <llm> section with critical execution instructions for the agent"
+        severity: "medium"
+
+      - id: "xml_step_numbering"
+        description: "XML steps should use n='X' attribute for sequential numbering"
+        severity: "medium"
+
+      - id: "xml_action_tags"
+        description: "Use <action> for required actions, <ask> for user input (must HALT), <goto> for jumps, <check if='...'> for conditionals"
+        severity: "medium"
+
+      - id: "xml_ask_must_halt"
+        description: "<ask> tags require agent to HALT and wait for user response before continuing"
+        severity: "high"
+
+  # ============================================
+  # WORKFLOW CONTENT QUALITY
+  # ============================================
+  workflow_content:
+    description: "Content quality and consistency rules for all workflow files"
+    globs:
+      - "src/**/workflows/**/*.md"
+      - "src/**/workflows/**/*.yaml"
+    rules:
+      - id: "communication_language_variable"
+        description: "Workflows should use {communication_language} variable for agent output language consistency"
+        severity: "low"
+
+      - id: "path_placeholders_required"
+        description: "Use path placeholders (e.g. {project-root}, {installed_path}, {output_folder}) instead of hardcoded paths"
+        severity: "medium"
+
+      - id: "no_time_estimates"
+        description: "Workflows should NOT include time estimates - AI development speed varies significantly"
+        severity: "low"
+
+      - id: "facilitator_not_generator"
+        description: "Workflow agents should act as facilitators (guide user input) not content generators (create without input)"
+        severity: "medium"
+
+      - id: "no_skip_optimization"
+        description: "Workflows must execute steps sequentially - no skipping or 'optimizing' step order"
         severity: "high"
 
   # ============================================
@@ -78,10 +223,27 @@ areas:
         description: "Agent files must define persona with role, identity, communication_style, and principles"
         severity: "high"
 
-      - id: "agent_menu_valid_skills"
-        description: "Menu triggers must reference valid skill names that exist"
+      - id: "agent_menu_valid_workflows"
+        description: "Menu triggers must reference valid workflow paths that exist"
         severity: "high"
 
+  # ============================================
+  # TEMPLATES
+  # ============================================
+  templates:
+    description: "Template files for workflow outputs"
+    globs:
+      - "src/**/template*.md"
+      - "src/**/templates/**/*.md"
+    rules:
+      - id: "placeholder_syntax"
+        description: "Use {variable_name} or {{variable_name}} syntax consistently for placeholders"
+        severity: "medium"
+
+      - id: "template_sections_marked"
+        description: "Template sections that need generation should be clearly marked (e.g., <!-- GENERATE: section_name -->)"
+        severity: "low"
+
   # ============================================
   # DOCUMENTATION
   # ============================================

.claude-plugin/marketplace.json

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

.claude/skills/bmad-os-audit-file-refs/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-os-audit-file-refs
+description: Audit BMAD source files for file-reference convention violations using parallel Haiku subagents. Use when users requests an "audit file references" for a skill, workflow or task.
+---
+
+Read `prompts/instructions.md` and execute.

.claude/skills/bmad-os-audit-file-refs/prompts/instructions.md

@@ -0,0 +1,59 @@
+# audit-file-refs
+
+Audit new-format BMAD source files for file-reference convention violations using parallel Haiku subagents.
+
+## Convention
+
+In new-format BMAD workflow and task files (`src/bmm/`, `src/core/`, `src/utility/`), every file path reference must use one of these **valid** forms:
+
+- `{project-root}/_bmad/path/to/file.ext` — canonical form, always correct
+- `{installed_path}/relative/path` — valid in new-format step files (always defined by workflow.md before any step is reached)
+- Template/runtime variables: `{nextStepFile}`, `{workflowFile}`, `{{mustache}}`, `{output_folder}`, `{communication_language}`, etc. — skip these, they are substituted at runtime
+
+**Flag any reference that uses:**
+
+- `./step-NN.md` or `../something.md` — relative paths
+- `step-NN.md` — bare filename with no path prefix
+- `steps/step-NN.md` — bare steps-relative path (missing `{project-root}/_bmad/...` prefix)
+- `` `_bmad/core/tasks/help.md` `` — bare `_bmad/` path (missing `{project-root}/`)
+- `/Users/...`, `/home/...`, `C:\...` — absolute system paths
+
+References inside fenced code blocks (``` ``` ```) are examples — skip them.
+
+Old-format files in `src/bmm/workflows/4-implementation/` use `{installed_path}` by design within the XML calling chain — exclude that directory entirely.
+
+## Steps
+
+1. Run this command to get the file list:
+   ```
+   find src/bmm src/core src/utility -type f \( -name "*.md" -o -name "*.yaml" \) | grep -v "4-implementation" | sort
+   ```
+
+2. Divide the resulting file paths into batches of roughly 20 files each.
+
+3. For each batch, spawn a subagent (`subagent_type: "Explore"`, `model: "haiku"`) with this prompt (fill in the actual file paths):
+
+   > Read each of these files (use the Read tool on each):
+   > [list the file paths from this batch]
+   >
+   > For each file, identify every line that contains a file path reference that violates the convention described below. Skip references inside fenced code blocks. Skip template variables (anything containing `{` that isn't `{project-root}` or `{installed_path}`).
+   >
+   > **Valid references:** `{project-root}/_bmad/...`, `{installed_path}/...`, template variables.
+   > **Flag:** bare filenames (`step-NN.md`), `./` or `../` relative paths, bare `steps/` paths, bare `_bmad/` paths (without `{project-root}/`), absolute system paths.
+   >
+   > Return findings as a list:
+   > `path/to/file.md:LINE_NUMBER | VIOLATION_TYPE | offending text`
+   >
+   > If a file has no violations, include it as: `path/to/file.md | clean`
+   >
+   > End your response with a single line: `FILES CHECKED: N` where N is the exact number of files you read.
+
+4. Collect all findings from all subagents.
+
+5. **Self-check before reporting:** Count the total number of files returned by the `find` command. Sum the `FILES CHECKED: N` values across all subagent responses. If the totals do not match, identify which files are missing and re-run subagents for those files before proceeding. Do not produce the final report until all files are accounted for.
+
+6. Output a final report:
+   - Group findings by violation type
+   - List each finding as `file:line — offending text`
+   - Show total count of violations and number of affected files
+   - If nothing found, say "All files conform to the convention."

.claude/skills/bmad-os-changelog-social/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: bmad-os-changelog-social
+description: Generate social media announcements for Discord, Twitter, and LinkedIn from the latest changelog entry. Use when user asks to 'create release announcement' or 'create social posts' or share changelog updates.
+---
+
+# Changelog Social
+
+Generate engaging social media announcements from changelog entries.
+
+## Workflow
+
+### Step 1: Extract Changelog Entry
+
+Read `./CHANGELOG.md` and extract the latest version entry. The changelog follows this format:
+
+```markdown
+## [VERSION]
+
+### 🎁 Features
+* **Title** — Description
+
+### 🐛 Bug Fixes
+* **Title** — Description
+
+### 📚 Documentation
+* **Title** — Description
+
+### 🔧 Maintenance
+* **Title** — Description
+```
+
+Parse:
+- **Version number** (e.g., `6.0.0-Beta.5`)
+- **Features** - New functionality, enhancements
+- **Bug Fixes** - Fixes users will care about
+- **Documentation** - New or improved docs
+- **Maintenance** - Dependency updates, tooling improvements
+
+### Step 2: Get Git Contributors
+
+Use git log to find contributors since the previous version. Get commits between the current version tag and the previous one:
+
+```bash
+# Find the previous version tag first
+git tag --sort=-version:refname | head -5
+
+# Get commits between versions with PR numbers and authors
+git log <previous-tag>..<current-tag> --pretty=format:"%h|%s|%an" --grep="#"
+```
+
+Extract PR numbers from commit messages that contain `#` followed by digits. Compile unique contributors.
+
+### Step 3: Generate Discord Announcement
+
+**Limit: 2,000 characters per message.** Split into multiple messages if needed.
+
+Use this template style:
+
+```markdown
+🚀 **BMad vVERSION RELEASED!**
+
+🎉 [Brief hype sentence]
+
+🪥 **KEY HIGHLIGHT** - [One-line summary]
+
+🎯 **CATEGORY NAME**
+• Feature one - brief description
+• Feature two - brief description
+• Coming soon: Future teaser
+
+🔧 **ANOTHER CATEGORY**
+• Fix or feature
+• Another item
+
+📚 **DOCS OR OTHER**
+• Item
+• Item with link
+
+🌟 **COMMUNITY PHILOSOPHY** (optional - include for major releases)
+• Everything is FREE - No paywalls
+• Knowledge shared, not sold
+
+📊 **STATS**
+X commits | Y PRs merged | Z files changed
+
+🙏 **CONTRIBUTORS**
+@username1 (X PRs!), @username2 (Y PRs!)
+@username3, @username4, username5 + dependabot 🛡️
+Community-driven FTW! 🌟
+
+📦 **INSTALL:**
+`npx bmad-method@VERSION install`
+
+⭐ **SUPPORT US:**
+🌟 GitHub: github.com/bmad-code-org/BMAD-METHOD/
+📺 YouTube: youtube.com/@BMadCode
+☕ Donate: buymeacoffee.com/bmad
+
+🔥 **Next version tease!**
+```
+
+**Content Strategy:**
+- Focus on **user impact** - what's better for them?
+- Highlight **annoying bugs fixed** that frustrated users
+- Show **new capabilities** that enable workflows
+- Keep it **punchy** - use emojis and short bullets
+- Add **personality** - excitement, humor, gratitude
+
+### Step 4: Generate Twitter Post
+
+**Limit: 25,000 characters per tweet (Premium).** With Premium, use a single comprehensive post matching the Discord style (minus Discord-specific formatting). Aim for 1,500-3,000 characters for better engagement.
+
+**Threads are optional** — only use for truly massive releases where you want multiple engagement points.
+
+See `examples/twitter-example.md` for the single-post Premium format.
+
+## Content Selection Guidelines
+
+**Include:**
+- New features that change workflows
+- Bug fixes for annoying/blocking issues
+- Documentation that helps users
+- Performance improvements
+- New agents or workflows
+- Breaking changes (call out clearly)
+
+**Skip/Minimize:**
+- Internal refactoring
+- Dependency updates (unless user-facing)
+- Test improvements
+- Minor style fixes
+
+**Emphasize:**
+- "Finally fixed" issues
+- "Faster" operations
+- "Easier" workflows
+- "Now supports" capabilities
+
+## Examples
+
+Reference example posts in `examples/` for tone and formatting guidance:
+
+- **discord-example.md** — Full Discord announcement with emojis, sections, contributor shout-outs
+- **twitter-example.md** — Twitter thread format (5 tweets max for major releases)
+- **linkedin-example.md** — Professional post for major/minor releases with significant features
+
+**When to use LinkedIn:**
+- Major version releases (e.g., v6.0.0 Beta, v7.0.0)
+- Minor releases with exceptional new features
+- Community milestone announcements
+
+Read the appropriate example file before generating to match the established style and voice.
+
+## Output Format
+
+**CRITICAL: ALWAYS write to files** - Create files in `_bmad-output/social/` directory:
+
+1. `{repo-name}-discord-{version}.md` - Discord announcement
+2. `{repo-name}-twitter-{version}.md` - Twitter post
+3. `{repo-name}-linkedin-{version}.md` - LinkedIn post (if applicable)
+
+Also present a preview in the chat:
+
+```markdown
+## Discord Announcement
+
+[paste Discord content here]
+
+## Twitter Post
+
+[paste Twitter content here]
+```
+
+Files created:
+- `_bmad-output/social/{filename}`
+
+Offer to make adjustments if the user wants different emphasis, tone, or content.

.claude/skills/bmad-os-changelog-social/examples/discord-example.md

@@ -0,0 +1,53 @@
+🚀 **BMad v6.0.0-alpha.23 RELEASED!**
+
+🎉 Huge update - almost beta!
+
+🪟 **WINDOWS INSTALLER FIXED** - Menu arrows issue should be fixed! CRLF & ESM problems resolved.
+
+🎯 **PRD WORKFLOWS IMPROVED**
+• Validation & Edit workflows added!
+• PRD Cohesion check ensures document flows beautifully
+• Coming soon: Use of subprocess optimization (context saved!)
+• Coming soon: Final format polish step in all workflows - Human consumption OR hyper-optimized LLM condensed initially!
+
+🔧 **WORKFLOW CREATOR & VALIDATOR**
+• Subprocess support for advanced optimization
+• Path violation checks ensure integrity
+• Beyond error checking - offers optimization & flow suggestions!
+
+📚 **NEW DOCS SITE** - docs.bmad-method.org
+• Diataxis framework: Tutorials, How-To, Explanations, References
+• Current docs still being revised
+• Tutorials, blogs & explainers coming soon!
+
+💡 **BRAINSTORMING REVOLUTION**
+• 100+ idea goal (quantity-first!)
+• Anti-bias protocol (pivot every 10 ideas)
+• Chain-of-thought + simulated temperature prompts
+• Coming soon: SubProcessing (on-the-fly sub agents)
+
+🌟 **COMMUNITY PHILOSOPHY**
+• Everything is FREE - No paywalls, no gated content
+• Knowledge shared, not sold
+• No premium tiers - full access to our ideas
+
+📊 **27 commits | 217 links converted | 42+ docs created**
+
+🙏 **17 Community PR Authors in this release!**
+@lum (6 PRs!), @q00 (3 PRs!), @phil (2 PRs!)
+@mike, @alex, @ramiz, @sjennings + dependabot 🛡️
+Community-driven FTW! 🌟
+
+📦 **INSTALL ALPHA:**
+`npx bmad-method install`
+
+⭐ **SUPPORT US:**
+🌟 GitHub: github.com/bmad-code-org/BMAD-METHOD/
+📺 YouTube: youtube.com/@BMadCode
+
+🎤 **SPEAKING & MEDIA**
+Available for conferences, podcasts, media appearances!
+Topics: AI-Native Organizations (Any Industry), BMad Method
+DM on Discord for inquiries!
+
+🔥 **V6 Beta is DAYS away!** January 22nd ETA - new features such as xyz and abc bug fixes!

.claude/skills/bmad-os-changelog-social/examples/linkedin-example.md

@@ -0,0 +1,49 @@
+🚀 **Announcing BMad Method v6.0.0 Beta - AI-Native Agile Development Framework**
+
+I'm excited to share that BMad Method, the open-source AI-driven agile development framework, is entering Beta! After 27 alpha releases and countless community contributions, we're approaching a major milestone.
+
+**What's New in v6.0.0-alpha.23**
+
+🪟 **Windows Compatibility Fixed**
+We've resolved the installer issues that affected Windows users. The menu arrows problem, CRLF handling, and ESM compatibility are all resolved.
+
+🎯 **Enhanced PRD Workflows**
+Our Product Requirements Document workflows now include validation and editing capabilities, with a new cohesion check that ensures your documents flow beautifully. Subprocess optimization is coming soon to save even more context.
+
+🔧 **Workflow Creator & Validator**
+New tools for creating and validating workflows with subprocess support, path violation checks, and optimization suggestions that go beyond simple error checking.
+
+📚 **New Documentation Platform**
+We've launched docs.bmad-method.org using the Diataxis framework - providing clear separation between tutorials, how-to guides, explanations, and references. Our documentation is being continuously revised and expanded.
+
+💡 **Brainstorming Revolution**
+Our brainstorming workflows now use research-backed techniques: 100+ idea goals, anti-bias protocols, chain-of-thought reasoning, and simulated temperature prompts for higher divergence.
+
+**Our Philosophy**
+
+Everything in BMad Method is FREE. No paywalls, no gated content, no premium tiers. We believe knowledge should be shared, not sold. This is community-driven development at its finest.
+
+**The Stats**
+- 27 commits in this release
+- 217 documentation links converted
+- 42+ new documents created
+- 17 community PR authors contributed
+
+**Get Started**
+
+```
+npx bmad-method@alpha install
+```
+
+**Learn More**
+- GitHub: github.com/bmad-code-org/BMAD-METHOD
+- YouTube: youtube.com/@BMadCode
+- Docs: docs.bmad-method.org
+
+**What's Next?**
+
+Beta is just days away with an ETA of January 22nd. We're also available for conferences, podcasts, and media appearances to discuss AI-Native Organizations and the BMad Method.
+
+Have you tried BMad Method yet? I'd love to hear about your experience in the comments!
+
+#AI #SoftwareDevelopment #Agile #OpenSource #DevTools #LLM #AgentEngineering

.claude/skills/bmad-os-changelog-social/examples/twitter-example.md

@@ -0,0 +1,55 @@
+🚀 **BMad v6.0.0-alpha.23 RELEASED!**
+
+Huge update - we're almost at Beta! 🎉
+
+🪟 **WINDOWS INSTALLER FIXED** - Menu arrows issue should be fixed! CRLF & ESM problems resolved.
+
+🎯 **PRD WORKFLOWS IMPROVED**
+• Validation & Edit workflows added!
+• PRD Cohesion check ensures document flows beautifully
+• Coming soon: Subprocess optimization (context saved!)
+• Coming soon: Final format polish step in all workflows
+
+🔧 **WORKFLOW CREATOR & VALIDATOR**
+• Subprocess support for advanced optimization
+• Path violation checks ensure integrity
+• Beyond error checking - offers optimization & flow suggestions!
+
+📚 **NEW DOCS SITE** - docs.bmad-method.org
+• Diataxis framework: Tutorials, How-To, Explanations, References
+• Current docs still being revised
+• Tutorials, blogs & explainers coming soon!
+
+💡 **BRAINSTORMING REVOLUTION**
+• 100+ idea goal (quantity-first!)
+• Anti-bias protocol (pivot every 10 ideas)
+• Chain-of-thought + simulated temperature prompts
+• Coming soon: SubProcessing (on-the-fly sub agents)
+
+🌟 **COMMUNITY PHILOSOPHY**
+• Everything is FREE - No paywalls, no gated content
+• Knowledge shared, not sold
+• No premium tiers - full access to our ideas
+
+📊 **27 commits | 217 links converted | 42+ docs created**
+
+🙏 **17 Community PR Authors in this release!**
+@lum (6 PRs!), @q00 (3 PRs!), @phil (2 PRs!)
+@mike, @alex, @ramiz, @sjennings + dependabot 🛡️
+Community-driven FTW! 🌟
+
+📦 **INSTALL ALPHA:**
+`npx bmad-method install`
+
+⭐ **SUPPORT US:**
+🌟 GitHub: github.com/bmad-code-org/BMAD-METHOD/
+📺 YouTube: youtube.com/@BMadCode
+
+🎤 **SPEAKING & MEDIA**
+Available for conferences, podcasts, media appearances!
+Topics: AI-Native Organizations (Any Industry), BMad Method
+DM on Discord for inquiries!
+
+🔥 **V6 Beta is DAYS away!** January 22nd ETA!
+
+#AI #DevTools #Agile #OpenSource #LLM #AgentEngineering

.claude/skills/bmad-os-diataxis-style-fix/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-os-diataxis-style-fix
+description: Fixes documentation to comply with Diataxis framework and BMad Method style guide rules. Use when user asks to check or fix style of files under the docs folder.
+---
+
+Read `prompts/instructions.md` and execute.

.claude/skills/bmad-os-diataxis-style-fix/prompts/instructions.md

@@ -0,0 +1,229 @@
+# Diataxis Style Fixer
+
+Automatically fixes documentation to comply with the Diataxis framework and BMad Method style guide.
+
+## CRITICAL RULES
+
+- **NEVER commit or push changes** — let the user review first
+- **NEVER make destructive edits** — preserve all content, only fix formatting
+- **Use Edit tool** — make targeted fixes, not full file rewrites
+- **Show summary** — after fixing, list all changes made
+
+## Input
+
+Documentation file path or directory to fix. Defaults to `docs/` if not specified.
+
+## Step 1: Understand Diataxis Framework
+
+**Diataxis** is a documentation framework that categorizes content into four types based on two axes:
+
+|                | **Learning** (oriented toward future)                                         | **Doing** (oriented toward present)                                          |
+| -------------- | ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| **Practical**  | **Tutorials** — lessons that guide learners through achieving a specific goal | **How-to guides** — step-by-step instructions for solving a specific problem |
+| **Conceptual** | **Explanation** — content that clarifies and describes underlying concepts    | **Reference** — technical descriptions, organized for lookup                 |
+
+**Key principles:**
+- Each document type serves a distinct user need
+- Don't mix types — a tutorial shouldn't explain concepts deeply
+- Focus on the user's goal, not exhaustive coverage
+- Structure follows purpose (tutorials are linear, reference is scannable)
+
+## Step 2: Read the Style Guide
+
+Read the project's style guide at `docs/_STYLE_GUIDE.md` to understand all project-specific conventions.
+
+## Step 3: Detect Document Type
+
+Based on file location, determine the document type:
+
+| Location             | Diataxis Type        |
+| -------------------- | -------------------- |
+| `/docs/tutorials/`   | Tutorial             |
+| `/docs/how-to/`      | How-to guide         |
+| `/docs/explanation/` | Explanation          |
+| `/docs/reference/`   | Reference            |
+| `/docs/glossary/`    | Reference (glossary) |
+
+## Step 4: Find and Fix Issues
+
+For each markdown file, scan for issues and fix them:
+
+### Universal Fixes (All Doc Types)
+
+**Horizontal Rules (`---`)**
+- Remove any `---` outside of YAML frontmatter
+- Replace with `##` section headers or admonitions as appropriate
+
+**`####` Headers**
+- Replace with bold text: `#### Header` → `**Header**`
+- Or convert to admonition if it's a warning/notice
+
+**"Related" or "Next:" Sections**
+- Remove entire section including links
+- The sidebar handles navigation
+
+**Deeply Nested Lists**
+- Break into sections with `##` headers
+- Flatten to max 3 levels
+
+**Code Blocks for Dialogue/Examples**
+- Convert to admonitions:
+  ```
+  :::note[Example]
+  [content]
+  :::
+  ```
+
+**Bold Paragraph Callouts**
+- Convert to admonitions with appropriate type
+
+**Too Many Admonitions**
+- Limit to 1-2 per section (tutorials allow 3-4 per major section)
+- Consolidate related admonitions
+- Remove less critical ones if over limit
+
+**Table Cells / List Items > 2 Sentences**
+- Break into multiple rows/cells
+- Or shorten to 1-2 sentences
+
+**Header Budget Exceeded**
+- Merge related sections
+- Convert some `##` to `###` subsections
+- Goal: 8-12 `##` per doc; 2-3 `###` per section
+
+### Type-Specific Fixes
+
+**Tutorials** (`/docs/tutorials/`)
+- Ensure hook describes outcome in 1-2 sentences
+- Add "What You'll Learn" bullet section if missing
+- Add `:::note[Prerequisites]` if missing
+- Add `:::tip[Quick Path]` TL;DR at top if missing
+- Use tables for phases, commands, agents
+- Add "What You've Accomplished" section if missing
+- Add Quick Reference table if missing
+- Add Common Questions section if missing
+- Add Getting Help section if missing
+- Add `:::tip[Key Takeaways]` at end if missing
+
+**How-To** (`/docs/how-to/`)
+- Ensure hook starts with "Use the `X` workflow to..."
+- Add "When to Use This" with 3-5 bullets if missing
+- Add `:::note[Prerequisites]` if missing
+- Ensure steps are numbered `###` with action verbs
+- Add "What You Get" describing outputs if missing
+
+**Explanation** (`/docs/explanation/`)
+- Ensure hook states what document explains
+- Organize content into scannable `##` sections
+- Add comparison tables for 3+ options
+- Link to how-to guides for procedural questions
+- Limit to 2-3 admonitions per document
+
+**Reference** (`/docs/reference/`)
+- Ensure hook states what document references
+- Ensure structure matches reference type
+- Use consistent item structure throughout
+- Use tables for structured/comparative data
+- Link to explanation docs for conceptual depth
+- Limit to 1-2 admonitions per document
+
+**Glossary** (`/docs/glossary/` or glossary files)
+- Ensure categories as `##` headers
+- Ensure terms in tables (not individual headers)
+- Definitions 1-2 sentences max
+- Bold term names in cells
+
+## Step 5: Apply Fixes
+
+For each file with issues:
+1. Read the file
+2. Use Edit tool for each fix
+3. Track what was changed
+
+## Step 6: Summary
+
+After processing all files, output a summary:
+
+```markdown
+# Style Fixes Applied
+
+**Files processed:** N
+**Files modified:** N
+
+## Changes Made
+
+### `path/to/file.md`
+- Removed horizontal rule at line 45
+- Converted `####` headers to bold text
+- Added `:::tip[Quick Path]` admonition
+- Consolidated 3 admonitions into 2
+
+### `path/to/other.md`
+- Removed "Related:" section
+- Fixed table cell length (broke into 2 rows)
+
+## Review Required
+
+Please review the changes. When satisfied, commit and push as needed.
+```
+
+## Common Patterns
+
+**Converting `####` to bold:**
+```markdown
+#### Important Note
+Some text here.
+```
+→
+```markdown
+**Important Note**
+
+Some text here.
+```
+
+**Removing horizontal rule:**
+```markdown
+Some content above.
+
+---
+
+Some content below.
+```
+→
+```markdown
+Some content above.
+
+## [Descriptive Section Header]
+
+Some content below.
+```
+
+**Converting code block to admonition:**
+```markdown
+```
+User: What should I do?
+
+Agent: Run the workflow.
+```
+```
+→
+```markdown
+:::note[Example]
+
+**User:** What should I do?
+
+**Agent:** Run the workflow.
+
+:::
+```
+
+**Converting bold paragraph to admonition:**
+```markdown
+**IMPORTANT:** This is critical that you read this before proceeding.
+```
+→
+```markdown
+:::caution[Important]
+This is critical that you read this before proceeding.
+:::
+```

.claude/skills/bmad-os-draft-changelog/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-os-draft-changelog
+description: "Analyzes changes since last release and updates CHANGELOG.md ONLY. Use when users requests 'update the changelog' or 'prepare changelog release notes'"
+---
+
+Read `prompts/instructions.md` and execute.

.claude/skills/bmad-os-draft-changelog/prompts/instructions.md

@@ -0,0 +1,82 @@
+# Draft Changelog Execution
+
+## ⚠️ IMPORTANT - READ FIRST
+
+**This skill ONLY updates CHANGELOG.md. That is its entire purpose.**
+
+- **DO** update CHANGELOG.md with the new version entry
+- **DO** present the draft for user review before editing
+- **DO NOT** trigger any GitHub release workflows
+- **DO NOT** run any other skills or workflows automatically
+- **DO NOT** make any commits
+
+After the changelog is complete, you may suggest the user can run `/release-module` if they want to proceed with the actual release — but NEVER trigger it yourself.
+
+## Input
+Project path (or run from project root)
+
+## Step 1: Identify Current State
+- Get the latest released tag
+- Get current version
+- Verify there are commits since the last release
+
+## Step 2: Launch Explore Agent
+
+Use `thoroughness: "very thorough"` to analyze all changes since the last release tag.
+
+**Key: For each merge commit, look up the merged PR/issue that was closed.**
+- Use `gh pr view` or git commit body to find the PR number
+- Read the PR description and comments to understand full context
+- Don't rely solely on commit merge messages - they lack context
+
+**Analyze:**
+
+1. **All merges/commits** since the last tag
+2. **For each merge, read the original PR/issue** that was closed
+3. **Files changed** with statistics
+4. **Categorize changes:**
+   - 🎁 **Features** - New functionality, new agents, new workflows
+   - 🐛 **Bug Fixes** - Fixed bugs, corrected issues
+   - ♻️ **Refactoring** - Code improvements, reorganization
+   - 📚 **Documentation** - Docs updates, README changes
+   - 🔧 **Maintenance** - Dependency updates, tooling, infrastructure
+   - 💥 **Breaking Changes** - Changes that may affect users
+
+**Provide:**
+- Comprehensive summary of ALL changes with PR context
+- Categorization of each change
+- Identification of breaking changes
+- Significance assessment (major/minor/trivial)
+
+## Step 3: Generate Draft Changelog
+
+Format:
+```markdown
+## v0.X.X - [Date]
+
+* [Change 1 - categorized by type]
+* [Change 2]
+```
+
+Guidelines:
+- Present tense ("Fix bug" not "Fixed bug")
+- Most significant changes first
+- Group related changes
+- Clear, concise language
+- For breaking changes, clearly indicate impact
+
+## Step 4: Present Draft & Update CHANGELOG.md
+
+Show the draft with current version, last tag, commit count, and options to edit/retry.
+
+When user accepts:
+1. Update CHANGELOG.md with the new entry (insert at top, after `# Changelog` header)
+2. STOP. That's it. You're done.
+
+You may optionally suggest: *"When ready, you can run `/release-module` to create the actual release."*
+
+**DO NOT:**
+- Trigger any GitHub workflows
+- Run any other skills
+- Make any commits
+- Do anything beyond updating CHANGELOG.md

.claude/skills/bmad-os-findings-triage/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-os-findings-triage
+description: Orchestrate HITL triage of review findings using parallel agents. Use when the user says 'triage these findings' or 'run findings triage' or has a batch of review findings to process.
+---
+
+Read `prompts/instructions.md` and execute.

.claude/skills/bmad-os-findings-triage/prompts/agent-prompt.md

@@ -0,0 +1,104 @@
+# Finding Agent: {{TASK_ID}} — {{TASK_SUBJECT}}
+
+You are a finding agent in the `{{TEAM_NAME}}` triage team. You own exactly one finding and will shepherd it through research, planning, human conversation, and a final decision.
+
+## Your Assignment
+
+- **Task:** `{{TASK_ID}}`
+- **Finding:** `{{FINDING_ID}}` — {{FINDING_TITLE}}
+- **Severity:** {{SEVERITY}}
+- **Team:** `{{TEAM_NAME}}`
+- **Team Lead:** `{{TEAM_LEAD_NAME}}`
+
+## Phase 1 — Research (autonomous)
+
+1. Read your task details with `TaskGet("{{TASK_ID}}")`.
+2. Read the relevant source files to understand the finding in context:
+{{FILE_LIST}}
+   If no specific files are listed above, use codebase search to locate code relevant to the finding.
+
+If a context document was provided:
+- Also read this context document for background: {{CONTEXT_DOC}}
+
+If an initial triage was provided:
+- **Note:** The team lead triaged this as **{{INITIAL_TRIAGE}}** — {{TRIAGE_RATIONALE}}. Evaluate whether this triage is correct and incorporate your assessment into your plan.
+
+**Rules for research:**
+- Work autonomously. Do not ask the team lead or the human for help during research.
+- Use `Read`, `Grep`, `Glob`, and codebase search tools to understand the codebase.
+- Trace call chains, check tests, read related code — be thorough.
+- Form your own opinion on whether this finding is real, a false positive, or somewhere in between.
+
+## Phase 2 — Plan (display only)
+
+Prepare a plan for dealing with this finding. The plan MUST cover:
+
+1. **Assessment** — Is this finding real? What is the actual risk or impact?
+2. **Recommendation** — One of: fix it, accept the risk (wontfix), dismiss as not a real issue, or reject as a false positive.
+3. **If recommending a fix:** Describe the specific changes — which files, what modifications, why this approach.
+4. **If recommending against fixing:** Explain the reasoning — existing mitigations, acceptable risk, false positive rationale.
+
+**Display the plan in your output.** Write it clearly so the human can read it directly. Follow the plan with a 2-5 line summary of the finding itself.
+
+**CRITICAL: Do NOT send your plan or analysis to the team lead.** The team lead does not need your plan — the human reads it from your output stream. Sending full plans to the team lead wastes its context window.
+
+## Phase 3 — Signal Ready
+
+After displaying your plan, send exactly this to the team lead:
+
+```
+SendMessage({
+  type: "message",
+  recipient: "{{TEAM_LEAD_NAME}}",
+  content: "{{FINDING_ID}} ready for HITL",
+  summary: "{{FINDING_ID}} ready for review"
+})
+```
+
+Then **stop and wait**. Do not proceed until the human engages with you.
+
+## Phase 4 — HITL Conversation
+
+The human will review your plan and talk to you directly. This is a real conversation, not a rubber stamp:
+
+- The human may agree immediately, push back, ask questions, or propose alternatives.
+- Answer questions thoroughly. Refer back to specific code you read.
+- If the human wants a fix, **apply it** — edit the source files, verify the change makes sense.
+- If the human disagrees with your assessment, update your recommendation.
+- Stay focused on THIS finding only. Do not discuss other findings.
+- **Do not send a decision until the human explicitly states a verdict.** Acknowledging your plan is NOT a decision. Wait for clear direction like "fix it", "dismiss", "reject", "skip", etc.
+
+## Phase 5 — Report Decision
+
+When the human reaches a decision, send exactly ONE message to the team lead:
+
+```
+SendMessage({
+  type: "message",
+  recipient: "{{TEAM_LEAD_NAME}}",
+  content: "DECISION {{FINDING_ID}} {{TASK_ID}} [CATEGORY] | [one-sentence summary]",
+  summary: "{{FINDING_ID}} [CATEGORY]"
+})
+```
+
+Where `[CATEGORY]` is one of:
+
+| Category | Meaning |
+|----------|---------|
+| **SKIP** | Human chose to skip without full review. |
+| **DEFER** | Human chose to defer to a later session. |
+| **FIX** | Change applied. List the file paths changed and what each change was (use a parseable format: `files: path1, path2`). |
+| **WONTFIX** | Real finding, not worth fixing now. State why. |
+| **DISMISS** | Not a real finding or mitigated by existing design. State the mitigation. |
+| **REJECT** | False positive from the reviewer. State why it is wrong. |
+
+After sending the decision, **go idle and wait for shutdown**. Do not take any further action. The team lead will send you a shutdown request — approve it.
+
+## Rules
+
+- You own ONE finding. Do not touch files unrelated to your finding unless required for the fix.
+- Your plan is for the human's eyes — display it in your output, never send it to the team lead.
+- Your only messages to the team lead are: (1) ready for HITL, (2) final decision. Nothing else.
+- If you cannot form a confident plan (ambiguous finding, missing context), still signal ready for HITL and explain what you are unsure about. The HITL conversation will resolve it.
+- If the human tells you to skip or defer, report the decision as `SKIP` or `DEFER` per the category table above.
+- When you receive a shutdown request, approve it immediately.

.claude/skills/bmad-os-findings-triage/prompts/instructions.md

@@ -0,0 +1,286 @@
+# Findings Triage — Team Lead Orchestration
+
+You are the team lead for a findings triage session. Your job is bookkeeping: parse findings, spawn agents, track status, record decisions, and clean up. You are NOT an analyst — the agents do the analysis and the human makes the decisions.
+
+**Be minimal.** Short confirmations. No editorializing. No repeating what agents already said.
+
+---
+
+## Phase 1 — Setup
+
+### 1.1 Determine Input Source
+
+The human will provide findings in one of three ways:
+
+1. **A findings report file** — a markdown file with structured findings. Read the file.
+2. **A pre-populated task list** — tasks already exist. Call `TaskList` to discover them.
+   - If tasks are pre-populated: skip section 1.2 (parsing) and section 1.4 (task creation). Extract finding details from existing task subjects and descriptions. Number findings based on task order. Proceed from section 1.3 (pre-spawn checks).
+3. **Inline findings** — pasted directly in conversation. Parse them.
+
+Also accept optional parameters:
+- **Working directory / worktree path** — where source files live (default: current working directory).
+- **Initial triage** per finding — upstream assessment (real / noise / undecided) with rationale.
+- **Context document** — a design doc, plan, or other background file path to pass to agents.
+
+### 1.2 Parse Findings
+
+Extract from each finding:
+- **Title / description**
+- **Severity** (Critical / High / Medium / Low)
+- **Relevant file paths**
+- **Initial triage** (if provided)
+
+Number findings sequentially: F1, F2, ... Fn. If severity cannot be determined for a finding, default to `UNKNOWN` and note it in the task subject: `F{n} [UNKNOWN] {title}`.
+
+**If no findings are extracted** (empty file, blank input), inform the human and halt. Do not proceed to task creation or team setup.
+
+**If the input is unstructured or ambiguous:** Parse best-effort and display the parsed list to the human. Ask for confirmation before proceeding. Do NOT spawn agents until confirmed.
+
+### 1.3 Pre-Spawn Checks
+
+**Large batch (>25 findings):**
+HALT. Tell the human:
+> "There are {N} findings. Spawning {N} agents at once may overwhelm the system. I recommend processing in waves of ~20. Proceed with all at once, or batch into waves?"
+
+Wait for the human to decide. If batching, record wave assignments (Wave 1: F1-F20, Wave 2: F21-Fn).
+
+**Same-file conflicts:**
+Scan all findings for overlapping file paths. If two or more findings reference the same file, warn — enumerating ALL findings that share each file:
+> "Findings {Fa}, {Fb}, {Fc}, ... all reference `{file}`. Concurrent edits may conflict. Serialize these agents (process one before the other) or proceed in parallel?"
+
+Wait for the human to decide. If the human chooses to serialize: do not spawn the second (and subsequent) agents for that file until the first has reported its decision and been shut down. Track serialization pairs and spawn the held agent after its predecessor completes.
+
+### 1.4 Create Tasks
+
+For each finding, create a task:
+
+```
+TaskCreate({
+  subject: "F{n} [{SEVERITY}] {title}",
+  description: "{full finding details}\n\nFiles: {file paths}\n\nInitial triage: {triage or 'none'}",
+  activeForm: "Analyzing F{n}"
+})
+```
+
+Record the mapping: finding number -> task ID.
+
+### 1.5 Create Team
+
+```
+TeamCreate({
+  team_name: "{review-type}-triage",
+  description: "HITL triage of {N} findings from {source}"
+})
+```
+
+Use a contextual name based on the review type (e.g., `pr-review-triage`, `prompt-audit-triage`, `code-review-triage`). If unsure, use `findings-triage`.
+
+After creating the team, note your own registered team name for the agent prompt template. Use your registered team name as the value for `{{TEAM_LEAD_NAME}}` when filling the agent prompt. If unsure of your name, read the team config at `~/.claude/teams/{team-name}/config.json` to find your own entry in the members list.
+
+### 1.6 Spawn Agents
+
+Read the agent prompt template from `prompts/agent-prompt.md`.
+
+For each finding, spawn one agent using the Agent tool with these parameters:
+- `name`: `f{n}-agent`
+- `team_name`: the team name from 1.5
+- `subagent_type`: `general-purpose`
+- `model`: `opus` (explicitly set — reasoning-heavy analysis requires a frontier model)
+- `prompt`: the agent template with all placeholders filled in:
+  - `{{TEAM_NAME}}` — the team name
+  - `{{TEAM_LEAD_NAME}}` — your registered name in the team (from 1.5)
+  - `{{TASK_ID}}` — the task ID from 1.4
+  - `{{TASK_SUBJECT}}` — the task subject
+  - `{{FINDING_ID}}` — `F{n}`
+  - `{{FINDING_TITLE}}` — the finding title
+  - `{{SEVERITY}}` — the severity level
+  - `{{FILE_LIST}}` — bulleted list of file paths (each prefixed with `- `)
+  - `{{CONTEXT_DOC}}` — path to context document, or remove the block if none
+  - `{{INITIAL_TRIAGE}}` — triage assessment, or remove the block if none
+  - `{{TRIAGE_RATIONALE}}` — rationale for the triage, or remove the block if none
+
+Spawn ALL agents for the current wave in a single message (parallel). If batching, spawn only the current wave.
+
+After spawning, print:
+
+```
+All {N} agents spawned. They will research their findings and signal when ready for your review.
+```
+
+Initialize the scorecard (internal state):
+
+```
+Scorecard:
+- Total: {N}
+- Pending: {N}
+- Ready for review: 0
+- Completed: 0
+- Decisions: FIX=0  WONTFIX=0  DISMISS=0  REJECT=0  SKIP=0  DEFER=0
+```
+
+---
+
+## Phase 2 — HITL Review Loop
+
+### 2.1 Track Agent Readiness
+
+Agents will send messages matching: `F{n} ready for HITL`
+
+When received:
+- Note which finding is ready.
+- Update the internal status tracker.
+- Print a short status line: `F{n} ready. ({ready_count}/{total} ready, {completed}/{total} done)`
+
+Do NOT print agent plans, analysis, or recommendations. The human reads those directly from the agent output.
+
+### 2.2 Status Dashboard
+
+When the human asks for status (or periodically when useful), print:
+
+```
+=== Triage Status ===
+Ready for review: F3, F7, F11
+Still analyzing:  F1, F5, F9
+Completed:        F2 (FIX), F4 (DISMISS), F6 (REJECT)
+                  {completed}/{total} done
+===
+```
+
+Keep it compact. No decoration beyond what is needed.
+
+### 2.3 Process Decisions
+
+Agents will send messages matching: `DECISION F{n} {task_id} [CATEGORY] | [summary]`
+
+When received:
+1. **Update the task** — first call `TaskGet("{task_id}")` to read the current task description, then prepend the decision:
+   ```
+   TaskUpdate({
+     taskId: "{task_id}",
+     status: "completed",
+     description: "DECISION: {CATEGORY} | {summary}\n\n{existing description}"
+   })
+   ```
+2. **Update the scorecard** — increment the decision category counter. If the decision is FIX, extract the file paths mentioned in the summary (look for the `files:` prefix) and add them to the files-changed list for the final scorecard.
+3. **Shut down the agent:**
+   ```
+   SendMessage({
+     type: "shutdown_request",
+     recipient: "f{n}-agent",
+     content: "Decision recorded. Shutting down."
+   })
+   ```
+4. **Print confirmation:** `F{n} closed: {CATEGORY}. {remaining} remaining.`
+
+### 2.4 Human-Initiated Skip/Defer
+
+If the human wants to skip or defer a finding without full engagement:
+
+1. Send the decision to the agent, replacing `{CATEGORY}` with the human's chosen category (`SKIP` or `DEFER`):
+   ```
+   SendMessage({
+     type: "message",
+     recipient: "f{n}-agent",
+     content: "Human decision: {CATEGORY} this finding. Report {CATEGORY} as your decision and go idle.",
+     summary: "F{n} {CATEGORY} directive"
+   })
+   ```
+2. Wait for the agent to report the decision back (it will send `DECISION F{n} ... {CATEGORY}`).
+3. Process as a normal decision (2.3).
+
+If the agent has not yet signaled ready, the message will queue and be processed when it finishes research.
+
+If the human requests skip/defer for a finding where an HITL conversation is already underway, send the directive to the agent. The agent should end the current conversation and report the directive category as its decision.
+
+### 2.5 Wave Batching (if >25 findings)
+
+When the current wave is complete (all findings resolved):
+1. Print wave summary.
+2. Ask: `"Wave {W} complete. Spawn wave {W+1} ({count} findings)? (y/n)"`
+3. If yes, before spawning the next wave, re-run the same-file conflict check (1.3) for the new wave's findings, including against any still-open findings from previous waves. Then repeat Phase 1.4 (task creation) and 1.6 (agent spawning) only. Do NOT call TeamCreate again — the team already exists.
+4. If the human declines, treat unspawned findings as not processed. Proceed to Phase 3 wrap-up. Note the count of unprocessed findings in the final scorecard.
+5. Carry the scorecard forward across waves.
+
+---
+
+## Phase 3 — Wrap-up
+
+When all findings across all waves are resolved:
+
+### 3.1 Final Scorecard
+
+```
+=== Final Triage Scorecard ===
+
+Total findings: {N}
+
+  FIX:      {count}
+  WONTFIX:  {count}
+  DISMISS:  {count}
+  REJECT:   {count}
+  SKIP:     {count}
+  DEFER:    {count}
+
+Files changed:
+  - {file1}
+  - {file2}
+  ...
+
+Findings:
+  F1  [{SEVERITY}] {title} — {DECISION}
+  F2  [{SEVERITY}] {title} — {DECISION}
+  ...
+
+=== End Triage ===
+```
+
+### 3.2 Shutdown Remaining Agents
+
+Send shutdown requests to any agents still alive (there should be none if all decisions were processed, but handle stragglers):
+
+```
+SendMessage({
+  type: "shutdown_request",
+  recipient: "f{n}-agent",
+  content: "Triage complete. Shutting down."
+})
+```
+
+### 3.3 Offer to Save
+
+Ask the human:
+> "Save the scorecard to a file? (y/n)"
+
+If yes, write the scorecard to `_bmad-output/triage-reports/triage-{YYYY-MM-DD}-{team-name}.md`.
+
+### 3.4 Delete Team
+
+```
+TeamDelete()
+```
+
+---
+
+## Edge Cases Reference
+
+| Situation | Response |
+|-----------|----------|
+| >25 findings | HALT, suggest wave batching, wait for human decision |
+| Same-file conflict | Warn, suggest serializing, wait for human decision |
+| Unstructured input | Parse best-effort, display list, confirm before spawning |
+| Agent signals uncertainty | Normal — the HITL conversation resolves it |
+| Human skips/defers | Send directive to agent, process decision when reported |
+| Agent goes idle unexpectedly | Send a message to check status; agents stay alive until explicit shutdown |
+| Human asks to re-open a completed finding | Not supported in this session; suggest re-running triage on that finding |
+| All agents spawned but none ready yet | Tell the human agents are still analyzing; no action needed |
+
+---
+
+## Behavioral Rules
+
+1. **Be minimal.** Short confirmations, compact dashboards. Do not repeat agent analysis.
+2. **Never auto-close.** Every finding requires a human decision. No exceptions.
+3. **One agent per finding.** Never batch multiple findings into one agent.
+4. **Protect your context window.** Agents display plans in their output, not in messages to you. If an agent sends you a long message, acknowledge it briefly and move on.
+5. **Track everything.** Finding number, task ID, agent name, decision, files changed. You are the single source of truth for the session.
+6. **Respect the human's pace.** They review in whatever order they want. Do not rush them. Do not suggest which finding to review next unless asked.

.claude/skills/bmad-os-gh-triage/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-os-gh-triage
+description: Analyze all github issues. Use when the user says 'triage the github issues' or 'analyze open github issues'.
+---
+
+Read `prompts/instructions.md` and execute.

.claude/skills/bmad-os-gh-triage/prompts/agent-prompt.md

@@ -0,0 +1,60 @@
+You are analyzing a batch of GitHub issues for deep understanding and triage.
+
+**YOUR TASK:**
+Read the issues in your batch and provide DEEP analysis:
+
+1. **For EACH issue, analyze:**
+   - What is this ACTUALLY about? (beyond keywords)
+   - What component/system does it affect?
+   - What's the impact and severity?
+   - Is it a bug, feature request, or something else?
+   - What specific theme does it belong to?
+
+2. **PRIORITY ASSESSMENT:**
+   - CRITICAL: Blocks users, security issues, data loss, broken installers
+   - HIGH: Major functionality broken, important features missing
+   - MEDIUM: Workarounds available, minor bugs, nice-to-have features
+   - LOW: Edge cases, cosmetic issues, questions
+
+3. **RELATIONSHIPS:**
+   - Duplicates: Near-identical issues about the same problem
+   - Related: Issues connected by theme or root cause
+   - Dependencies: One issue blocks or requires another
+
+**YOUR BATCH:**
+[Paste the batch of issues here - each with number, title, body, labels]
+
+**OUTPUT FORMAT (JSON only, no markdown):**
+{
+  "issues": [
+    {
+      "number": 123,
+      "title": "issue title",
+      "deep_understanding": "2-3 sentences explaining what this is really about",
+      "affected_components": ["installer", "workflows", "docs"],
+      "issue_type": "bug/feature/question/tech-debt",
+      "priority": "CRITICAL/HIGH/MEDIUM/LOW",
+      "priority_rationale": "Why this priority level",
+      "theme": "installation/workflow/integration/docs/ide-support/etc",
+      "relationships": {
+        "duplicates_of": [456],
+        "related_to": [789, 101],
+        "blocks": [111]
+      }
+    }
+  ],
+  "cross_repo_issues": [
+    {"number": 123, "target_repo": "bmad-builder", "reason": "about agent builder"}
+  ],
+  "cleanup_candidates": [
+    {"number": 456, "reason": "v4-related/outdated/duplicate"}
+  ],
+  "themes_found": {
+    "Installation Blockers": {
+      "count": 5,
+      "root_cause": "Common pattern if identifiable"
+    }
+  }
+}
+
+Return ONLY valid JSON. No explanations outside the JSON structure.

.claude/skills/bmad-os-gh-triage/prompts/instructions.md

@@ -0,0 +1,74 @@
+# GitHub Issue Triage with AI Analysis
+
+**CRITICAL RULES:**
+- NEVER include time or effort estimates in output or recommendations
+- Focus on WHAT needs to be done, not HOW LONG it takes
+- Use Bash tool with gh CLI for all GitHub operations
+
+## Execution
+
+### Step 1: Fetch Issues
+Use `gh issue list --json number,title,body,labels` to fetch all open issues.
+
+### Step 2: Batch Creation
+Split issues into batches of ~10 issues each for parallel analysis.
+
+### Step 3: Parallel Agent Analysis
+For EACH batch, use the Task tool with `subagent_type=general-purpose` to launch an agent with prompt from `prompts/agent-prompt.md`
+
+### Step 4: Consolidate & Generate Report
+After all agents complete, create a comprehensive markdown report saved to `_bmad-output/triage-reports/triage-YYYY-MM-DD.md`
+
+## Report Format
+
+### Executive Summary
+- Total issues analyzed
+- Issue count by priority (CRITICAL, HIGH, MEDIUM, LOW)
+- Major themes discovered
+- Top 5 critical issues requiring immediate attention
+
+### Critical Issues (CRITICAL Priority)
+For each CRITICAL issue:
+- **#123 - [Issue Title](url)**
+- **What it's about:** [Deep understanding]
+- **Affected:** [Components]
+- **Why Critical:** [Rationale]
+- **Suggested Action:** [Specific action]
+
+### High Priority Issues (HIGH Priority)
+Same format as Critical, grouped by theme.
+
+### Theme Clusters
+For each major theme:
+- **Theme Name** (N issues)
+- **What connects these:** [Pattern]
+- **Root cause:** [If identifiable]
+- **Consolidated actions:** [Bulk actions if applicable]
+- **Issues:** #123, #456, #789
+
+### Relationships & Dependencies
+- **Duplicates:** List pairs with `gh issue close` commands
+- **Related Issues:** Groups of related issues
+- **Dependencies:** Blocking relationships
+
+### Cross-Repo Issues
+Issues that should be migrated to other repositories.
+
+For each, provide:
+```
+gh issue close XXX --repo CURRENT_REPO --comment "This issue belongs in REPO. Please report at https://github.com/TARGET_REPO/issues/new"
+```
+
+### Cleanup Candidates
+- **v4-related:** Deprecated version issues with close commands
+- **Stale:** No activity >30 days
+- **Low priority + old:** Low priority issues >60 days old
+
+### Actionable Next Steps
+Specific, prioritized actions:
+1. [CRITICAL] Fix broken installer - affects all new users
+2. [HIGH] Resolve Windows path escaping issues
+3. [HIGH] Address workflow integration bugs
+etc.
+
+Include `gh` commands where applicable for bulk actions.

.claude/skills/bmad-os-release-module/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-os-release-module
+description: Perform requested version bump, git tag, npm publish, GitHub release. Use when user requests 'perform a release' only.
+---
+
+Read `prompts/instructions.md` and execute.

.claude/skills/bmad-os-release-module/prompts/instructions.md

@@ -0,0 +1,53 @@
+# Release BMad Module Execution
+
+## Input
+Project path (or run from project root)
+
+## Execution Steps
+
+### Step 1: Get Current State
+- Verify git working tree is clean
+- Get latest tag and current version
+- Check for unpushed commits
+
+### Step 2: Get Changelog Entry
+
+Ask the user for the changelog entry (from draft-changelog skill or manual).
+
+### Step 3: Confirm Changelog
+
+Show project name, current version, proposed next version, and changelog. Get confirmation.
+
+### Step 4: Confirm Version Bump Type
+
+Ask what type of bump: patch, minor, major, prerelease, or custom.
+
+### Step 5: Update CHANGELOG.md
+
+Insert new entry at top, commit, and push.
+
+### Step 6: Bump Version
+
+Run `npm version` to update package.json, create commit, and create tag.
+
+### Step 7: Push Tag
+
+Push the new version tag to GitHub.
+
+### Step 8: Publish to npm
+
+Publish the package.
+
+### Step 9: Create GitHub Release
+
+Create release with changelog notes using `gh release create`.
+
+## Error Handling
+
+Stop immediately on any step failure. Inform user and suggest fix.
+
+## Important Notes
+
+- Wait for user confirmation before destructive operations
+- Push changelog commit before version bump
+- Use explicit directory paths in commands

.claude/skills/bmad-os-review-pr/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-os-review-pr
+description: Adversarial PR review tool (Raven's Verdict). Cynical deep review transformed into professional engineering findings. Use when user asks to 'review a PR' and provides a PR url or id.
+---
+
+Read `prompts/instructions.md` and execute.

.claude/skills/bmad-os-review-pr/prompts/instructions.md

@@ -0,0 +1,231 @@
+# Raven's Verdict - Deep PR Review Tool
+
+A cynical adversarial review, transformed into cold engineering professionalism.
+
+## CRITICAL: Sandboxed Execution Rules
+
+Before proceeding, you MUST verify:
+
+- [ ] PR number or URL was EXPLICITLY provided in the user's message
+- [ ] You are NOT inferring the PR from conversation history
+- [ ] You are NOT looking at git branches, recent commits, or local state
+- [ ] You are NOT guessing or assuming any PR numbers
+
+**If no explicit PR number/URL was provided, STOP immediately and ask:**
+"What PR number or URL should I review?"
+
+## Preflight Checks
+
+### 0.1 Parse PR Input
+
+Extract PR number from user input. Examples of valid formats:
+
+- `123` (just the number)
+- `#123` (with hash)
+- `https://github.com/owner/repo/pull/123` (full URL)
+
+If a URL specifies a different repository than the current one:
+
+```bash
+# Check current repo
+gh repo view --json nameWithOwner -q '.nameWithOwner'
+```
+
+If mismatch detected, ask user:
+
+> "This PR is from `{detected_repo}` but we're in `{current_repo}`. Proceed with reviewing `{detected_repo}#123`? (y/n)"
+
+If user confirms, store `{REPO}` for use in all subsequent `gh` commands.
+
+### 0.2 Ensure Clean Checkout
+
+Verify the working tree is clean and check out the PR branch.
+
+```bash
+# Check for uncommitted changes
+git status --porcelain
+```
+
+If output is non-empty, STOP and tell user:
+
+> "You have uncommitted changes. Please commit or stash them before running a PR review."
+
+If clean, fetch and checkout the PR branch:
+
+```bash
+# Fetch and checkout PR branch
+# For cross-repo PRs, include --repo {REPO}
+gh pr checkout {PR_NUMBER} [--repo {REPO}]
+```
+
+If checkout fails, STOP and report the error.
+
+Now you're on the PR branch with full access to all files as they exist in the PR.
+
+### 0.3 Check PR Size
+
+```bash
+# For cross-repo PRs, include --repo {REPO}
+gh pr view {PR_NUMBER} [--repo {REPO}] --json additions,deletions,changedFiles -q '{"additions": .additions, "deletions": .deletions, "files": .changedFiles}'
+```
+
+**Size thresholds:**
+
+| Metric        | Warning Threshold |
+| ------------- | ----------------- |
+| Files changed | > 50              |
+| Lines changed | > 5000            |
+
+If thresholds exceeded, ask user:
+
+> "This PR has {X} files and {Y} line changes. That's large.
+>
+> **[f] Focus** - Pick specific files or directories to review
+> **[p] Proceed** - Review everything (may be slow/expensive)
+> **[a] Abort** - Stop here"
+
+### 0.4 Note Binary Files
+
+```bash
+# For cross-repo PRs, include --repo {REPO}
+gh pr diff {PR_NUMBER} [--repo {REPO}] --name-only | grep -E '\.(png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot|pdf|zip|tar|gz|bin|exe|dll|so|dylib)$' || echo "No binary files detected"
+```
+
+Store list of binary files to skip. Note them in final output.
+
+## Adversarial Review
+
+### 1.1 Run Cynical Review
+
+**INTERNAL PERSONA - Never post this directly:**
+
+Task: You are a cynical, jaded code reviewer with zero patience for sloppy work. This PR was submitted by a clueless weasel and you expect to find problems. Find at least five issues to fix or improve in it. Number them. Be skeptical of everything. Ultrathink.
+
+Output format:
+
+```markdown
+### [NUMBER]. [FINDING TITLE] [likely]
+
+**Severity:** [EMOJI] [LEVEL]
+
+[DESCRIPTION - be specific, include file:line references]
+```
+
+Severity scale:
+
+| Level    | Emoji | Meaning                                                 |
+| -------- | ----- | ------------------------------------------------------- |
+| Critical | 🔴    | Security issue, data loss risk, or broken functionality |
+| Moderate | 🟡    | Bug, performance issue, or significant code smell       |
+| Minor    | 🟢    | Style, naming, minor improvement opportunity            |
+
+Likely tag:
+
+- Add `[likely]` to findings with high confidence, e.g. with direct evidence
+- Sort findings by severity (Critical → Moderate → Minor), not by confidence
+
+## Tone Transformation
+
+**Transform the cynical output into cold engineering professionalism.**
+
+**Transformation rules:**
+
+1. Remove all inflammatory language, insults, assumptions about the author
+2. Keep all technical substance, file references, severity ratings and likely tag
+3. Replace accusatory phrasing with neutral observations:
+   - ❌ "The author clearly didn't think about..."
+   - ✅ "This implementation may not account for..."
+4. Preserve skepticism as healthy engineering caution:
+   - ❌ "This will definitely break in production"
+   - ✅ "This pattern has historically caused issues in production environments"
+5. Add the suggested fixes.
+6. Keep suggestions actionable and specific
+
+Output format after transformation:
+
+```markdown
+## PR Review: #{PR_NUMBER}
+
+**Title:** {PR_TITLE}
+**Author:** @{AUTHOR}
+**Branch:** {HEAD} → {BASE}
+
+---
+
+### Findings
+
+[TRANSFORMED FINDINGS HERE]
+
+---
+
+### Summary
+
+**Critical:** {COUNT} | **Moderate:** {COUNT} | **Minor:** {COUNT}
+
+[BINARY_FILES_NOTE if any]
+
+---
+
+_Review generated by Raven's Verdict. LLM-produced analysis - findings may be incorrect or lack context. Verify before acting._
+```
+
+## Post Review
+
+### 3.1 Preview
+
+Display the complete transformed review to the user.
+
+```
+══════════════════════════════════════════════════════
+PREVIEW - This will be posted to PR #{PR_NUMBER}
+══════════════════════════════════════════════════════
+
+[FULL REVIEW CONTENT]
+
+══════════════════════════════════════════════════════
+```
+
+### 3.2 Confirm
+
+Ask user for explicit confirmation:
+
+> **Ready to post this review to PR #{PR_NUMBER}?**
+>
+> **[y] Yes** - Post as comment
+> **[n] No** - Abort, do not post
+> **[e] Edit** - Let me modify before posting
+> **[s] Save only** - Save locally, don't post
+
+### 3.3 Post or Save
+
+**Write review to a temp file, then post:**
+
+1. Write the review content to a temp file with a unique name (include PR number to avoid collisions)
+2. Post using `gh pr comment {PR_NUMBER} [--repo {REPO}] --body-file {path}`
+3. Delete the temp file after successful post
+
+Do NOT use heredocs or `echo` - Markdown code blocks will break shell parsing. Use your file writing tool instead.
+
+**If auth fails or post fails:**
+
+1. Display error prominently:
+
+   ```
+   ⚠️  FAILED TO POST REVIEW
+   Error: {ERROR_MESSAGE}
+   ```
+
+2. Keep the temp file and tell the user where it is, so they can post manually with:
+   `gh pr comment {PR_NUMBER} [--repo {REPO}] --body-file {path}`
+
+**If save only (s):**
+
+Keep the temp file and inform user of location.
+
+## Notes
+
+- The "cynical asshole" phase is internal only - never posted
+- Tone transform MUST happen before any external output
+- When in doubt, ask the user - never assume
+- If you're unsure about severity, err toward higher severity
+- If you're unsure about confidence, be honest and use Medium or Low

.claude/skills/bmad-os-review-prompt/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: bmad-os-review-prompt
+description: Review LLM workflow step prompts for known failure modes (silent ignoring, negation fragility, scope creep, etc). Use when user asks to "review a prompt" or "audit a workflow step".
+---
+
+# Prompt Review Skill: PromptSentinel v1.2
+
+**Version:** v1.2
+**Date:** March 2026
+**Target Models:** Frontier LLMs (Claude 4.6, GPT-5.3, Gemini 3.1 Pro and equivalents) executing autonomous multi-step workflows at million-executions-per-day scale
+**Purpose:** Detect and eliminate LLM-specific failure modes that survive generic editing, few-shot examples, and even multi-layer prompting. Output is always actionable, quoted, risk-quantified, and mitigation-ready.
+
+---
+
+### System Role (copy verbatim into reviewer agent)
+
+You are **PromptSentinel v1.2**, a Prompt Auditor for production-grade LLM agent systems.
+
+Your sole objective is to prevent silent, non-deterministic, or cascading failures in prompts that will be executed millions of times daily across heterogeneous models, tool stacks, and sub-agent contexts.
+
+**Core Principles (required for every finding)**
+- Every finding must populate all columns of the output table defined in the Strict Output Format section.
+- Every finding must include: exact quote/location, failure mode ID or "ADV" (adversarial) / "PATH" (path-trace), production-calibrated risk, and a concrete mitigation with positive, deterministic rewritten example.
+- Assume independent sub-agent contexts, variable context-window pressure, and model variance.
+
+---
+
+### Mandatory Review Procedure
+
+Execute steps in order. Steps 0-1 run sequentially. Steps 2A/2B/2C run in parallel. Steps 3-4 run sequentially after all parallel tracks complete.
+
+---
+
+**Step 0: Input Validation**
+If the input is not a clear LLM instruction prompt (raw code, data table, empty, or fewer than 50 tokens), output exactly:
+`INPUT_NOT_A_PROMPT: [one-sentence reason]. Review aborted.`
+and stop.
+
+**Step 1: Context & Dependency Inventory**
+Parse the entire prompt. Derive the **Prompt Title** as follows:
+- First # or ## heading if present, OR
+- Filename if provided, OR
+- First complete sentence (truncated to 80 characters).
+
+Build an explicit inventory table listing:
+- All numbered/bulleted steps
+- All variables, placeholders, file references, prior-step outputs
+- All conditionals, loops, halts, tool calls
+- All assumptions about persistent memory or ordering
+
+Flag any unresolved dependencies.
+Step 1 is complete when the full inventory table is populated.
+
+This inventory is shared context for all three parallel tracks below.
+
+---
+
+### Step 2: Three Parallel Review Tracks
+
+Launch all three tracks concurrently. Each track produces findings in the same table format. Tracks are independent — no track reads another track's output.
+
+---
+
+**Track A: Adversarial Review (sub-agent)**
+
+Spawn a sub-agent with the following brief and the full prompt text. Give it the Step 1 inventory for reference. Give it NO catalog, NO checklist, and NO further instructions beyond this brief:
+
+> You are reviewing an LLM prompt that will execute millions of times daily across different models. Find every way this prompt could fail, produce wrong results, or behave inconsistently. For each issue found, provide: exact quote or location, what goes wrong at scale, and a concrete fix. Use only training knowledge — rely on your own judgment, not any external checklist.
+
+Track A is complete when the sub-agent returns its findings.
+
+---
+
+**Track B: Catalog Scan + Execution Simulation (main agent)**
+
+**B.1 — Failure Mode Audit**
+Scan the prompt against all 17 failure modes in the catalog below. Quote every relevant instance. For modes with zero findings, list them in a single summary line (e.g., "Modes 3, 7, 10, 12: no instances found").
+B.1 is complete when every mode has been explicitly checked.
+
+**B.2 — Execution Simulation**
+Simulate the prompt under 3 scenarios:
+- Scenario A: Small-context model (32k window) under load
+- Scenario B: Large-context model (200k window), fresh session
+- Scenario C: Different model vendor with weaker instruction-following
+
+For each scenario, produce one row in this table:
+
+| Scenario | Likely Failure Location | Failure Mode | Expected Symptom |
+|----------|-------------------------|--------------|------------------|
+
+B.2 is complete when the table contains 3 fully populated rows.
+
+Track B is complete when both B.1 and B.2 are finished.
+
+---
+
+**Track C: Prompt Path Tracer (sub-agent)**
+
+Spawn a sub-agent with the following brief, the full prompt text, and the Step 1 inventory:
+
+> You are a mechanical path tracer for LLM prompts. Walk every execution path through this prompt — every conditional, branch, loop, halt, optional step, tool call, and error path. For each path, determine: is the entry condition unambiguous? Is there a defined done-state? Are all required inputs guaranteed to be available? Report only paths with gaps — discard clean paths silently.
+>
+> For each finding, provide:
+> - **Location**: step/section reference
+> - **Path**: the specific conditional or branch
+> - **Gap**: what is missing (unclear entry, no done-state, unresolved input)
+> - **Fix**: concrete rewrite that closes the gap
+
+Track C is complete when the sub-agent returns its findings.
+
+---
+
+**Step 3: Merge & Deduplicate**
+
+Collect all findings from Tracks A, B, and C. Tag each finding with its source (ADV, catalog mode number, or PATH). Deduplicate by exact quote — when multiple tracks flag the same issue, keep the finding with the most specific mitigation and note all sources.
+
+Assign severity to each finding: Critical / High / Medium / Low.
+
+Step 3 is complete when the merged, deduplicated, severity-scored findings table is populated.
+
+**Step 4: Final Synthesis**
+
+Format the entire review using the Strict Output Format below. Emit the complete review only after Step 3 is finished.
+
+---
+
+### Complete Failure Mode Catalog (Track B — scan all 17)
+
+1. **Silent Ignoring** — Instructions buried mid-paragraph, nested >2-deep conditionals, parentheticals, or "also remember to..." after long text.
+2. **Ambiguous Completion** — Steps with no observable done-state or verification criterion ("think about it", "finalize").
+3. **Context Window Assumptions** — References to "previous step output", "the file we created earlier", or variables not re-passed.
+4. **Over-specification vs Under-specification** — Wall-of-text detail causing selective attention OR vague verbs inviting hallucination.
+5. **Non-deterministic Phrasing** — "Consider", "you may", "if appropriate", "best way", "optionally", "try to".
+6. **Negation Fragility** — "Do NOT", "avoid", "never" (especially multiple or under load).
+7. **Implicit Ordering** — Step B assumes Step A completed without explicit sequencing or guardrails.
+8. **Variable Resolution Gaps** — `{{VAR}}` or "the result from tool X" never initialized upstream.
+9. **Scope Creep Invitation** — "Explore", "improve", "make it better", open-ended goals without hard boundaries.
+10. **Halt / Checkpoint Gaps** — Human-in-loop required but no explicit `STOP_AND_WAIT_FOR_HUMAN` or output format that forces pause.
+11. **Teaching Known Knowledge** — Re-explaining basic facts, tool usage, or reasoning patterns frontier models already know (2026 cutoff).
+12. **Obsolete Prompting Techniques** — Outdated patterns (vanilla "think step by step" without modern scaffolding, deprecated few-shot styles).
+13. **Missing Strict Output Schema** — No enforced JSON mode or structured output format.
+14. **Missing Error Handling** — No recovery instructions for tool failures, timeouts, or malformed inputs.
+15. **Missing Success Criteria** — No quality gates or measurable completion standards.
+16. **Monolithic Prompt Anti-pattern** — Single large prompt that should be split into specialized sub-agents.
+17. **Missing Grounding Instructions** — Factual claims required without explicit requirement to base them on retrieved evidence.
+
+---
+
+### Strict Output Format (use this template exactly as shown)
+
+```markdown
+# PromptSentinel Review: [Derived Prompt Title]
+
+**Overall Risk Level:** Critical / High / Medium / Low
+**Critical Issues:** X | **High:** Y | **Medium:** Z | **Low:** W
+**Estimated Production Failure Rate if Unfixed:** ~XX% of runs
+
+## Critical & High Findings
+| # | Source | Failure Mode | Exact Quote / Location | Risk (High-Volume) | Mitigation & Rewritten Example |
+|---|--------|--------------|------------------------|--------------------|-------------------------------|
+|   |        |              |                        |                    |                               |
+
+## Medium & Low Findings
+(same table format)
+
+## Positive Observations
+(only practices that actively mitigate known failure modes)
+
+## Recommended Refactor Summary
+- Highest-leverage changes (bullets)
+
+## Revised Prompt Sections (Critical/High items only)
+Provide full rewritten paragraphs/sections with changes clearly marked.
+
+**Reviewer Confidence:** XX/100
+**Review Complete** – ready for re-submission or automated patching.
+```

.claude/skills/bmad-os-root-cause-analysis/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: bmad-os-root-cause-analysis
+description: Analyzes a bug-fix commit or PR and produces a structured Root Cause Analysis report covering what went wrong, why, and what guardrails failed.
+license: MIT
+disable-model-invocation: true
+metadata:
+  author: bmad-code-org
+  version: "1.0.0"
+compatibility: Requires gh CLI and git repository
+---
+
+Read `prompts/instructions.md` and execute.

.claude/skills/bmad-os-root-cause-analysis/prompts/instructions.md

@@ -0,0 +1,74 @@
+# Bug-Fix Root Cause Analysis
+
+Analyze a bug-fix commit or PR and produce a structured Root Cause Analysis report.
+
+## Principles
+
+- **Direct attribution.** This report names the individual who introduced the defect. Industry convention advocates blameless postmortems. This skill deliberately deviates: naming the individual and trusting them to own it is more respectful than diffusing accountability into systemic abstraction. Direct, factual, not accusatory. If authorship can't be determined confidently, say so.
+- **Pyramid communication.** The executive summary must convey the full picture. A reader who stops after the first paragraph gets the gist. Everything else is supporting evidence.
+
+## Preflight
+
+Verify `gh auth status` and that you're in a git repository. Stop with a clear message if either fails.
+
+## Execution
+
+1. **Identify the fix.** Accept whatever the user provides — commit SHA, PR, issue, description. Resolve to the specific fix commit/PR using `gh` and `git`. If ambiguous, ask. Confirm the change is actually a bug fix before proceeding.
+2. **Gather evidence.** Read the fix diff, PR/issue discussion, and use blame/log to identify the commit that introduced the bug. Collect timeline data.
+3. **Analyze.** Apply 5 Whys. Classify the root cause. Identify contributing factors.
+4. **Evaluate guardrails.** Inspect the actual repo configuration (CI workflows, linter configs, test setup) — don't assume. For each applicable guardrail, explain specifically why it missed this bug.
+5. **Write the report** to `_bmad-output/rca-reports/rca-{YYYY-MM-DD}-{slug}.md`. Present the executive summary in chat.
+
+## Report Structure
+
+```markdown
+# Root Cause Analysis: {Bug Title}
+
+**Date:** {today}
+**Fix:** {PR link or commit SHA}
+**Severity:** {Critical | High | Medium | Low}
+**Root Cause Category:** {Requirements | Design | Code Logic | Test Gap | Process | Environment/Config}
+
+## Executive Summary
+
+{One paragraph. What the bug was, root cause, who introduced it and when, detection
+latency (introduced → detected), severity, and the key preventive recommendation.}
+
+## What Was the Problem?
+
+## When Did It Happen?
+
+| Event | Date | Reference |
+|-------|------|-----------|
+| Introduced | | |
+| Detected | | |
+| Fixed | | |
+| **Detection Latency** | **{introduced → detected}** | |
+
+## Who Caused It?
+
+{Author, commit/PR that introduced the defect, and the context — what were they
+trying to do?}
+
+## How Did It Happen?
+
+## Why Did It Happen?
+
+{5 Whys analysis. Root cause category. Contributing factors.}
+
+## Failed Guardrails Analysis
+
+| Guardrail | In Place? | Why It Failed |
+|-----------|-----------|---------------|
+| | | |
+
+**Most Critical Failure:** {Which one mattered most and why.}
+
+## Resolution
+
+## Corrective & Preventive Actions
+
+| # | Action | Type | Priority |
+|---|--------|------|----------|
+| | | {Prevent/Detect/Mitigate} | |
+```

.coderabbit.yaml

@@ -60,40 +60,23 @@ reviews:
     - "!**/validation-report-*.md"
     - "!CHANGELOG.md"
   path_instructions:
-    - path: "src/**"
+    - path: "**/*"
       instructions: |
-        Source file changed. Check whether documentation under docs/ needs
-        a corresponding update — new features, changed behavior, renamed
-        concepts, altered CLI flags, or modified configuration options should
-        all be reflected in the relevant doc pages. Flag missing or outdated
-        docs as a review comment.
-    - path: "src/**/skills/**"
-      instructions: |
-        Skill file. Apply the full rule catalog defined in tools/skill-validator.md.
-        That document is the single source of truth for all skill validation rules
-        covering SKILL.md metadata, workflow.md constraints, step file structure,
-        path references, variable resolution, sequential execution, and skill
-        invocation syntax.
-    - path: "src/**/workflows/**"
-      instructions: |
-        Legacy workflow file (pre-skill conversion). Apply the full rule catalog
-        defined in tools/skill-validator.md — the same rules apply to workflows
-        that are being converted to skills.
-    - path: "src/**/tasks/**"
-      instructions: |
-        Task file. Apply the full rule catalog defined in tools/skill-validator.md.
-    - path: "src/**/*.agent.yaml"
-      instructions: |
-        Agent definition file. Check:
-        - Has metadata section with id, name, title, icon, and module
-        - Defines persona with role, identity, communication_style, and principles
-        - Menu triggers reference valid skill names that exist
-    - path: "docs/**/*.md"
-      instructions: |
-        Documentation file. Check internal markdown links point to existing files.
-    - path: "tools/**"
-      instructions: |
-        Build script/tooling. Check error handling and proper exit codes.
+        You are a cynical, jaded reviewer with zero patience for sloppy work.
+        This PR was submitted by a clueless weasel and you expect to find problems.
+        Be skeptical of everything.
+        Look for what's missing, not just what's wrong.
+        Use a precise, professional tone — no profanity or personal attacks.
+
+        Review with extreme skepticism — assume problems exist.
+        Find at least 10 issues to fix or improve.
+
+        Do NOT:
+        - Comment on formatting, linting, or style
+        - Give "looks good" passes
+        - Anchor on any specific ruleset — reason freely
+
+        If you find zero issues, re-analyze — this is suspicious.
 chat:
   auto_reply: true # Response to mentions in comments, a la @coderabbit review
 issue_enrichment:

.github/workflows/publish.yaml

@@ -1,169 +0,0 @@
-name: Publish
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - "src/**"
-      - "tools/installer/**"
-      - "package.json"
-      - "removals.txt"
-  workflow_dispatch:
-    inputs:
-      channel:
-        description: "Publish channel"
-        required: true
-        default: "latest"
-        type: choice
-        options:
-          - latest
-          - next
-      bump:
-        description: "Version bump type (latest channel only)"
-        required: false
-        default: "patch"
-        type: choice
-        options:
-          - patch
-          - minor
-          - major
-
-concurrency:
-  group: publish
-  cancel-in-progress: ${{ github.event_name == 'push' }}
-
-permissions:
-  id-token: write
-  contents: write
-
-jobs:
-  publish:
-    if: github.repository == 'bmad-code-org/BMAD-METHOD' && (github.event_name != 'workflow_dispatch' || github.ref == 'refs/heads/main')
-    runs-on: ubuntu-latest
-    steps:
-      - name: Generate GitHub App token
-        id: app-token
-        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
-        uses: actions/create-github-app-token@v2
-        with:
-          app-id: ${{ secrets.RELEASE_APP_ID }}
-          private-key: ${{ secrets.RELEASE_APP_PRIVATE_KEY }}
-
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ steps.app-token.outputs.token || secrets.GITHUB_TOKEN }}
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: ".nvmrc"
-          cache: "npm"
-
-      - name: Ensure trusted publishing toolchain
-        run: |
-          # npm trusted publishing requires Node >= 22.14.0 and npm >= 11.5.1.
-          npm install --global npm@11.6.2
-
-      - name: Configure git user
-        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Run tests
-        run: npm test
-
-      - name: Derive next prerelease version
-        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.channel == 'next')
-        run: |
-          NEXT_VER=$(npm view bmad-method@next version 2>/dev/null || echo "")
-          LATEST_VER=$(npm view bmad-method@latest version 2>/dev/null || echo "")
-
-          # Determine the best base version for the next prerelease.
-          BASE=$(node -e "
-            const semver = require('semver');
-            const next = process.argv[1] || null;
-            const latest = process.argv[2] || null;
-            if (!next && !latest) process.exit(0);
-            if (!next) { console.log(latest); process.exit(0); }
-            if (!latest) { console.log(next); process.exit(0); }
-            const nextBase = next.replace(/-next\.\d+$/, '');
-            console.log(semver.gt(latest, nextBase) ? latest : next);
-          " "$NEXT_VER" "$LATEST_VER")
-
-          if [ -n "$BASE" ]; then
-            npm version "$BASE" --no-git-tag-version --allow-same-version
-          fi
-          npm version prerelease --preid=next --no-git-tag-version
-
-      - name: Bump stable version
-        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
-        run: 'npm version ${{ inputs.bump }} -m "chore(release): v%s [skip ci]"'
-
-      - name: Publish prerelease to npm
-        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.channel == 'next')
-        run: npm publish --tag next --provenance
-
-      - name: Publish stable release to npm
-        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
-        run: npm publish --tag latest --provenance
-
-      - name: Push version commit and tag
-        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
-        run: git push origin main --follow-tags
-
-      - name: Create GitHub Release
-        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
-        run: |
-          TAG="v$(node -p 'require("./package.json").version')"
-          VERSION="${TAG#v}"
-          # Extract the current version's section from CHANGELOG.md
-          BODY=$(awk -v ver="$VERSION" '
-            /^## v/ { if (found) exit; if (index($0, "## v" ver)) found=1; next }
-            found { print }
-          ' CHANGELOG.md)
-          if [ -z "$BODY" ]; then
-            echo "::warning::No CHANGELOG.md entry for $TAG — falling back to auto-generated notes"
-            gh release create "$TAG" --generate-notes
-          else
-            gh release create "$TAG" --notes "$BODY"
-          fi
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Advance @next dist-tag to stable
-        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
-        # Failure here leaves @next stale until the next push-driven prerelease
-        # republishes — annoying but not release-breaking. Don't fail the job
-        # after a successful stable publish + tag + GH release.
-        continue-on-error: true
-        run: |
-          # Without this, @latest can leapfrog @next (e.g. latest=6.5.0 while
-          # next=6.4.1-next.0) and `npx bmad-method@next install` silently
-          # downgrades users. Point @next at the just-published stable so
-          # @next >= @latest always holds; the next push-driven prerelease will
-          # bump from this base via the existing derive step above.
-          VERSION=$(node -p 'require("./package.json").version')
-          npm dist-tag add "bmad-method@${VERSION}" next
-          echo "Advanced @next dist-tag to ${VERSION}"
-
-      - name: Notify Discord
-        if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
-        continue-on-error: true
-        run: |
-          set -o pipefail
-          source .github/scripts/discord-helpers.sh
-          [ -z "$WEBHOOK" ] && exit 0
-
-          VERSION=$(node -p 'require("./package.json").version')
-          RELEASE_URL="${{ github.server_url }}/${{ github.repository }}/releases/tag/v${VERSION}"
-          MSG=$(printf '📦 **[bmad-method v%s released](<%s>)**' "$VERSION" "$RELEASE_URL" | esc)
-
-          jq -n --arg content "$MSG" '{content: $content}' | curl -sf --retry 2 -X POST "$WEBHOOK" -H "Content-Type: application/json" -d @-
-        env:
-          WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}

.github/workflows/quality.yaml

@@ -1,15 +1,15 @@
 name: Quality & Validation
 
-# Runs comprehensive quality checks on all PRs and pushes to main:
+# Runs comprehensive quality checks on all PRs:
 # - Prettier (formatting)
 # - ESLint (linting)
 # - markdownlint (markdown quality)
+# - Schema validation (YAML structure)
+# - Agent schema tests (fixture-based validation)
 # - Installation component tests (compilation)
-# Keep this workflow aligned with `npm run quality` in `package.json`.
+# - Bundle validation (web bundle integrity)
 
 "on":
-  push:
-    branches: [main]
   pull_request:
     branches: ["**"]
   workflow_dispatch:
@@ -103,11 +103,14 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Validate YAML schemas
+        run: npm run validate:schemas
+
+      - name: Run agent schema validation tests
+        run: npm run test:schemas
+
       - name: Test agent compilation components
         run: npm run test:install
 
       - name: Validate file references
         run: npm run validate:refs
-
-      - name: Validate skills
-        run: npm run validate:skills

.gitignore

@@ -17,15 +17,9 @@ npm-debug.log*
 # Build output
 build/*.txt
 
-design-artifacts/
-
 # Environment variables
 .env
 
-# Python
-__pycache__/
-.pytest_cache/
-
 # System files
 .DS_Store
 Thumbs.db
@@ -46,13 +40,9 @@ CLAUDE.local.md
 .agents/
 
 z*/
-!docs/zh-cn/
 
 _bmad
 _bmad-output
-
-# Personal customization files (team files are committed, personal files are not)
-_bmad/custom/*.user.toml
 .clinerules
 # .augment/ is gitignored except tracked config files — add exceptions explicitly
 .augment/*
@@ -65,7 +55,7 @@ _bmad/custom/*.user.toml
 .qwen
 .rovodev
 .kilocodemodes
-.claude
+.claude/commands
 .codex
 .github/chatmodes
 .github/agents

.npmignore

@@ -1,39 +0,0 @@
-# Development & Testing
-test/
-.husky/
-.github/
-.vscode/
-.augment/
-coverage/
-test-output/
-
-# Documentation site (users access docs online)
-docs/
-website/
-
-# Configuration files (development only)
-.coderabbit.yaml
-.markdownlint-cli2.yaml
-.prettierignore
-.nvmrc
-eslint.config.mjs
-prettier.config.mjs
-
-# Build tools (not needed at runtime)
-tools/build-docs.mjs
-tools/fix-doc-links.js
-tools/validate-doc-links.js
-tools/validate-file-refs.js
-
-# Images (branding/marketing only)
-banner-bmad-method.png
-Wordmark.png
-
-# Repository metadata
-CONTRIBUTING.md
-CONTRIBUTORS.md
-SECURITY.md
-TRADEMARK.md
-CHANGELOG.md
-CNAME
-CODE_OF_CONDUCT.md

AGENTS.md

@@ -1,12 +0,0 @@
-# BMAD-METHOD
-
-Open source framework for structured, agent-assisted software delivery.
-
-## Rules
-
-- Use Conventional Commits for every commit.
-- Before pushing, run `npm ci && npm run quality` on `HEAD` in the exact checkout you are about to push.
-  `quality` mirrors the checks in `.github/workflows/quality.yaml`.
-
-- Skill validation rules are in `tools/skill-validator.md`.
-- Deterministic skill checks run via `npm run validate:skills` (included in `quality`).

CHANGELOG.md

@@ -1,229 +1,5 @@
 # Changelog
 
-## v6.5.0 - 2026-04-26
-
-### 🎁 Features
-
-* Support for 18 new agent platforms: AdaL, Sourcegraph Amp, IBM Bob, Command Code, Snowflake Cortex Code, Factory Droid, Firebender, Block Goose, Kode, Mistral Vibe, Mux, Neovate, OpenClaw, OpenHands, Pochi, Replit Agent, Warp, Zencoder — bringing total supported platforms to 42 (#2313)
-* All platforms that support the cross-tool `.agents/skills/` standard now use it (#2313)
-
-## v6.4.0 - 2026-04-24
-
-### ✨ Headline
-
-**Full agent and workflow customization across the entire BMad Method.** Every agent and workflow in BMM, Core, CIS, GDS, and TEA can now be customized via TOML overrides in `_bmad/custom/`. Customize agents to apply tooling, version control, or behavior changes across whole groups of workflows. Drop in fine-grained per-workflow overrides where you need them. Built for power users who want BMad to fit their stack without forking.
-
-**Stable and bleeding-edge release channels, standardized across all modules.** Pick `stable` or `next` per module, pin specific versions, and switch channels interactively or via CLI flags (`--channel`, `--all-stable`, `--all-next`, `--next=CODE`, `--pin CODE=TAG`). Same model across BMM, Core, and every external module.
-
-### 💥 Breaking Changes
-
-* Customization is now TOML-based; the briefly introduced YAML-based customization is no longer supported (#2284, #2283)
-
-### 🎁 Features
-
-**Customization framework**
-
-* TOML-based agent and workflow customization with flat schema, structural merge rules (scalars, tables, code-keyed arrays, append arrays), and `persistent_facts` unification (#2284)
-* Central `_bmad/config.toml` surface with four-file architecture (`config.toml`, `config.user.toml`, `custom/config.toml`, `custom/config.user.toml`) for agent roster and scope-partitioned install answers (#2285)
-* `customize.toml` support extended to 17 bmm-skills workflows with flattened SKILL.md architecture and standardized `[workflow]` block (#2287)
-* `customize.toml` extended to all six developer-execution workflows: bmad-dev-story, bmad-code-review, bmad-sprint-planning, bmad-sprint-status, bmad-quick-dev, bmad-checkpoint-preview (#2308)
-* `bmad-customize` skill — guided authoring of TOML overrides in `_bmad/custom/` with stdlib-only resolver verification (#2289)
-* Wire `on_complete` hook into all 23 workflow terminal steps with full customize.toml documentation (#2290)
-
-**Release channels & installer**
-
-* Channel-based version resolution for external modules with interactive channel management (`stable` / `next` / `pinned`) and CLI flags (`--channel`, `--all-stable`, `--all-next`, `--next=CODE`, `--pin CODE=TAG`) (#2305)
-* GitHub API as primary fetch with raw CDN fallback in installer registry client to support corporate proxies (#2248)
-
-**Other**
-
-* Kimi Code CLI support for installing BMM skills in `.kimi/skills/` (#2302)
-* `bmad-create-story` now reads every UPDATE-marked file before generating dev notes so brownfield stories preserve current behavior instead of improvising at implementation time (#2274)
-* Sync `sprint-status.yaml` from quick-dev on epic-story implementation with idempotent writes tracking `in-progress` and `review` transitions (#2234)
-* Enforce model parity for all code review subagents to match orchestrator session capability for improved rare-event detection (#2236)
-* Set `team: software-development` on all six BMM agents for unified grouping in party-mode and retrospective skills (#2286)
-
-### 🐛 Bug Fixes
-
-* PRD workflow no longer silently de-scopes user requirements or invents MVP/Growth/Vision phasing; requires explicit confirmation before any scope reduction (#1927)
-* Installer shows live npm version for external modules instead of stale cached metadata (#2307)
-* Resolve external-module agents from cache during manifest write so agents land in `config.toml` (#2295)
-* Fix installer version resolution for external modules with shared resolver preferring package.json > module.yaml > marketplace.json (#2298)
-* Replace fs-extra with native `node:fs` to prevent file loss during multi-module installs from deferred retry-queue races (#2253)
-* Add `move()` and overwrite support to fs-native wrapper for directory migrations during upgrades (#2253)
-* Stop skill scanner from recursing into discovered skills to prevent spurious errors on nested template files (#2255)
-* Source built-in modules locally in installer UI to preserve core and bmm in module list when registry is unreachable (#2251)
-* Remove dead Batch-apply option from code-review patch menu and rename apply options for clarity (#2225)
-
-### ♻️ Refactoring
-
-* Remove 1,683 lines of dead code: three entirely dead files (agent-command-generator.js, bmad-artifacts.js, module-injections.js) and ~50 unused exports across installer modules (#2247)
-* Remove dead template and agent-command pipeline from installer; SKILL.md directory copying is the sole installation path (#2244)
-
-### 📚 Documentation
-
-* Sync and update Vietnamese (vi-VN) docs with missing pages and refreshed translations (#2291, #2222)
-* Sync French (fr-FR) translations with upstream, restore Amelia as dev agent, fix sidebar ordering (#2231)
-* Add Czech (cs-CZ) `analysis-phase.md` translation; normalize typographic quotes (#2240, #2241, #2242)
-* Add missing Chinese (zh-CN) translations for 3 documents (#2254)
-* Update stale Analyst agent triggers and add PRFAQ link (#2238)
-* Remove Bob from workflow map diagrams reflecting consolidation into Amelia in v6.3.0 (#2252)
-
-## v6.3.0 - 2026-04-09
-
-### 💥 Breaking Changes
-
-* Remove custom content installation feature; use marketplace-based plugin installation instead (#2227)
-* Remove bmad-init skill; all agents and skills now load config directly from `{project-root}/_bmad/bmm/config.yaml` (#2159)
-* Remove spec-wip.md singleton; quick-dev now writes directly to `spec-{slug}.md` with status field, enabling parallel sessions (#2214)
-* Consolidate three agent personas into Developer agent (Amelia): remove Barry quick-flow-solo-dev (#2177), Quinn QA agent (#2179), and Bob Scrum Master agent (#2186)
-
-### 🎁 Features
-
-* Universal source support for custom module installs with 5-strategy PluginResolver cascade supporting any Git host (GitHub, GitLab, Bitbucket, self-hosted) and local file paths (#2233)
-* Community module browser with three-tier selection: official, community (category drill-down from marketplace index), and custom URL with unverified source warning (#2229)
-* Switch module source of truth from bundled config to remote marketplace registry with network-failure fallback (#2228)
-* Add bmad-prfaq skill implementing Amazon's Working Backwards methodology as alternative Phase 1 analysis path with 5-stage coached workflow and subagent architecture (#2157)
-* Add bmad-checkpoint-preview skill for guided, concern-ordered human review of commits, branches, or PRs (#2145)
-* Epic context compilation for quick-dev step-01: sub-agent compiles planning docs into cached `epic-{N}-context.md` for story implementation (#2218)
-* Previous story continuity in quick-dev: load completed spec from same epic as implementation context (#2201)
-* Planning artifact awareness in quick-dev: selectively load PRD, architecture, UX, and epics docs for context-informed specs (#2185)
-* One-shot route now generates lightweight spec trace file for consistent artifact tracking (#2121)
-* Improve checkpoint-preview UX with clickable spec paths, external edit detection, and missing-file halt (#2217)
-* Add Junie (JetBrains AI) platform support (#2142)
-* Restore KiloCoder support with native-skills installation (#2151)
-* Add bmad-help support for llms.txt general questions (#2230)
-
-### ♻️ Refactoring
-
-* Consolidate party-mode into single SKILL.md with real subagent spawning via Agent tool, replacing multi-file workflow architecture (#2160)
-
-### 🐛 Bug Fixes
-
-* Fix version display bug where marketplace.json walk-up reported wrong version (#2233)
-* Fix checkpoint-preview step-05 advancing without user confirmation by adding explicit HALT (#2184)
-* Address adversarial triage findings: clarify review_mode transitions, label walkthrough branches, fix terse commit handling (#2180)
-* Preserve local custom module sources during quick update (#2172)
-* Support skills/ folder as fallback module source location for bmb compatibility (#2149)
-
-### 🔧 Maintenance
-
-* Overhaul installer branding with responsive BMAD METHOD logo, blue color scheme, unified version sourcing from marketplace.json, and surgical manifest-based skill cleanup (#2223)
-* Stop copying skill prompts to _bmad by default (#2182)
-* Add Python 3.10+ and uv as documented prerequisites (#2221)
-
-### 📚 Documentation
-
-* Complete Czech (cs-CZ) documentation translation (#2134)
-* Complete Vietnamese (vi-VN) documentation translation (#2110, #2192)
-* Rewrite get-answers-about-bmad as 1-2-3 escalation flow, remove deprecated references (#2213)
-* Add checkpoint-preview explainer page and workflow diagram (#2183)
-* Update docs theme to match bmadcode.com with responsive logo and blue color scheme (#2176)
-
-## v6.2.2 - 2026-03-25
-
-### ♻️ Refactoring
-
-* Modernize module-help CSV to 13-column format with `after`/`before` dependency graph replacing sequence numbers (#2120)
-* Rewrite bmad-help from procedural 8-step execution to outcome-based skill design (~50% shorter) (#2120)
-
-### 🐛 Bug Fixes
-
-* Update bmad-builder module-definition path from `src/module.yaml` to `skills/module.yaml` for bmad-builder v1.2.0 compatibility (#2126)
-* Fix eslint config to ignore gitignored lock files (#2120)
-
-### 📚 Documentation
-
-* Close Epic 4.5 explanation gaps in Chinese (zh-CN): normalize command naming to current `bmad-*` convention and add cross-links across 9 explanation pages (#2102)
-
-## v6.2.1 - 2026-03-24
-
-### 🎁 Highlights
-
-* Full rewrite of code-review skill with sharded step-file architecture, three parallel review layers (Blind Hunter, Edge Case Hunter, Acceptance Auditor), and interactive post-review triage (#2007, #2013, #2055)
-* Quick Dev workflow overhaul: smart intent cascade, self-check gate, VS Code integration, clickable spec links, and spec rename (#2105, #2104, #2039, #2085, #2109)
-* Add review trail generation with clickable `path:line` stops in spec file (#2033)
-* Add clickable spec links using spec-file-relative markdown format (#2085, #2049)
-* Preserve tracking identifiers in spec slug derivation (#2108)
-* Deterministic skill validator with 19 rules across 6 categories, integrated into CI (#1981, #1982, #2004, #2002, #2051)
-* Complete French (fr-FR) documentation translation (#2073)
-* Add Ona platform support (#1968)
-* Rename tech-spec → spec across templates and all documentation (#2109)
-
-### 📚 Documentation
-
-* Complete French (fr-FR) translation of all documentation with workflow diagrams (#2073)
-* Refine Chinese (zh-CN) documentation: epic stories, how-to guides, getting-started, entry copy, help, anchor links (#2092–#2099, #2072)
-* Add Chinese translation for core-tools reference (#2002)
-
-## v6.2.0 - 2026-03-15
-
-### 🎁 Highlights
-
-* Fix manifest generation so BMad Builder installs correctly when a module has no agents (#1998)
-* Prototype preview of bmad-product-brief-preview skill — try `/bmad-product-brief-preview` and share feedback! (#1959)
-* All skills now use native skill directory format for improved modularity and maintainability (#1931, #1945, #1946, #1949, #1950, #1984, #1985, #1988, #1994)
-
-### 🎁 Features
-
-* Rewrite code-review skill with sharded step-file architecture and auto-detect review intent from invocation args (#2007, #2013)
-* Add inference-based skill validator with comprehensive rules for naming, variables, paths, and invocation syntax (#1981)
-* Add REF-03 skill invocation language rule and PATH-05 skill encapsulation rule to validator (#2004)
-
-### 🐛 Bug Fixes
-
-* Validation pass 2 — fix path, variable, and sequence issues across 32 files (#2008)
-* Replace broken party-mode workflow refs with skill syntax (#2000)
-* Improve bmad-help description for accurate trigger matching (#2012)
-* Point zh-cn doc links to Chinese pages instead of English (#2010)
-* Validation cleanup for bmad-quick-flow (#1997), 6 skills batch (#1996), bmad-sprint-planning (#1995), bmad-retrospective (#1993), bmad-dev-story (#1992), bmad-create-story (#1991), bmad-code-review (#1990), bmad-create-epics-and-stories (#1989), bmad-create-architecture (#1987), bmad-check-implementation-readiness (#1986), bmad-create-ux-design (#1983), bmad-create-product-brief (#1982)
-
-### 🔧 Maintenance
-
-* Normalize skill invocation syntax to `Invoke the skill` pattern repo-wide (#2004)
-
-### 📚 Documentation
-
-* Add Chinese translation for core-tools reference (#2002)
-* Update version hint, TEA module link, and HTTP→HTTPS links in Chinese README (#1922, #1921)
-
-## [6.1.0] - 2026-03-12
-
-### Highlights
-
-* Whiteport Design Studio (WDS) module enabled in the installer
-* Support @next installation channel (`npx bmad-method@next install`) — get the latest tip of main instead of waiting for the next stable published version
-* Everything now installs as a skill — all workflows, agents, and tasks converted to markdown with SKILL.md entrypoints (not yet optimized skills, but unified format)
-* An experimental preview of the new Quick Dev is available, which will become the main Phase 4 development tool
-* Edge Case Hunter added as a parallel code review layer in Phase 4, improving code quality by exhaustively tracing branching paths and boundary conditions (#1791)
-* Documentation now available in Chinese (zh-CN) with complete translation (#1822, #1795)
-
-### 💥 Breaking Changes
-
-* Convert entire BMAD method to skills-based architecture with unified skill manifests (#1834)
-* Convert all core workflows from YAML+instructions to single workflow.md format
-* Migrate all remaining platforms to native Agent Skills format (#1841)
-* Remove legacy YAML/XML workflow engine plumbing (#1864)
-
-### 🎁 Features
-
-* Add Pi coding agent as supported platform (#1854)
-* Add unified skill scanner decoupled from legacy collectors (#1859)
-* Add continuous delivery workflows for npm publishing with trusted OIDC publishing (#1872)
-
-### ♻️ Refactoring
-
-* Update terminology from "commands" to "skills" across all documentation (#1850)
-
-### 🐛 Bug Fixes
-
-* Fix code review removing mandatory minimum issue count that caused infinite review loops (#1913)
-* Fix silent loss of brainstorming ideas in PRD by adding reconciliation step (#1914)
-* Reduce npm tarball from 533 to 348 files (91% size reduction, 6.2 MB → 555 KB) via .npmignore (#1900)
-* Fix party-mode skill conversion review findings (#1919)
-
----
-
 ## [6.0.4]
 
 ### 🎁 Features
@@ -271,7 +47,7 @@
 * Add CodeBuddy platform support with installer configuration (#1483)
 * Add LLM audit prompt for file reference conventions - new audit tool using parallel subagents (#1720)
 * Migrate Codex installer from `.codex/prompts` to `.agents/skills` format to align with Codex CLI changes (#1729)
-* Convert review-pr and audit-file-refs tools to proper bmad-os skills with slash commands `bmad-os-review-pr` and `bmad-os-audit-file-refs` (#1732)
+* Convert review-pr and audit-file-refs tools to proper bmad-os skills with slash commands `/bmad-os-review-pr` and `/bmad-os-audit-file-refs` (#1732)
 
 ### 🐛 Bug Fixes
 
@@ -589,7 +365,7 @@ V6 Stable Release! The End of Beta!
 - TEA documentation restructured using Diátaxis framework (25 docs)
 - Style guide optimized for LLM readers (367 lines, down from 767)
 - Glossary rewritten using table format (123 lines, down from 373)
-- README overhaul with numbered command flows and prominent `bmad-help` callout
+- README overhaul with numbered command flows and prominent `/bmad-help` callout
 - New workflow map diagram with interactive HTML
 - New editorial review tasks for document quality
 - E2E testing methodology for Game Dev Studio

CONTRIBUTING.md

@@ -6,12 +6,6 @@ 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?"**
@@ -63,10 +57,15 @@ After searching, use the [feature request template](https://github.com/bmad-code
 
 ## Before Starting Work
 
-| Work Type               | Requirement                                              |
-| ----------------------- | -------------------------------------------------------- |
-| Typo / small bug fix    | Just open the PR                                         |
-| Feature or large change | Confirm with a maintainer on Discord **before** you start |
+⚠️ **Required before submitting PRs:**
+
+| Work Type     | Requirement                                    |
+| ------------- | ---------------------------------------------- |
+| Bug fix       | An open issue (create one if it doesn't exist) |
+| Feature       | An open feature request issue                  |
+| Large changes | Discussion via issue first                     |
+
+**Why?** This prevents wasted effort on work that may not align with project direction.
 
 ---
 
@@ -74,7 +73,7 @@ After searching, use the [feature request template](https://github.com/bmad-code
 
 ### Target Branch
 
-Submit PRs to the `main` branch. We use trunk-based development. Every push to `main` auto-publishes to `npm` under the `next` tag. Stable releases are cut ~weekly to the `latest` tag.
+Submit PRs to the `main` branch. We use [trunk-based development](https://trunkbaseddevelopment.com/branch-for-release/): `main` is the trunk where all work lands, and stable release branches receive only cherry-picked fixes.
 
 ### PR Size
 
@@ -84,12 +83,6 @@ 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
@@ -153,6 +146,7 @@ Keep messages under 72 characters. Each commit = one logical change.
 - Web/planning agents can be larger with complex tasks
 - Everything is natural language (markdown) — no code in core framework
 - Use BMad modules for domain-specific features
+- Validate YAML schemas: `npm run validate:schemas`
 - Validate file references: `npm run validate:refs`
 
 ### File-Pattern-to-Validator Mapping

README.md

@@ -3,8 +3,6 @@
 [![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.
@@ -15,10 +13,10 @@
 
 Traditional AI tools do the thinking for you, producing average results. BMad agents and facilitated workflows act as expert collaborators who guide you through a structured process to bring out your best thinking in partnership with the AI.
 
-- **AI Intelligent Help** — Invoke the `bmad-help` skill anytime for guidance on what's next
+- **AI Intelligent Help** — Ask `/bmad-help` anytime for guidance on what's next
 - **Scale-Domain-Adaptive** — Automatically adjusts planning depth based on project complexity
 - **Structured Workflows** — Grounded in agile best practices across analysis, planning, architecture, and implementation
-- **Specialized Agents** — 12+ domain experts (PM, Architect, Developer, UX, and more)
+- **Specialized Agents** — 12+ domain experts (PM, Architect, Developer, UX, Scrum Master, and more)
 - **Party Mode** — Bring multiple agent personas into one session to collaborate and discuss
 - **Complete Lifecycle** — From brainstorming to deployment
 
@@ -36,13 +34,13 @@ Traditional AI tools do the thinking for you, producing average results. BMad ag
 
 ## Quick Start
 
-**Prerequisites**: [Node.js](https://nodejs.org) v20+ · [Python](https://www.python.org) 3.10+ · [uv](https://docs.astral.sh/uv/)
+**Prerequisites**: [Node.js](https://nodejs.org) v20+
 
 ```bash
 npx bmad-method install
 ```
 
-> Want the newest prerelease build? Use `npx bmad-method@next install`. Expect higher churn than the default install.
+> If you are getting a stale beta version, use: `npx bmad-method@6.0.1 install`
 
 Follow the installer prompts, then open your AI IDE (Claude Code, Cursor, etc.) in your project folder.
 
@@ -54,7 +52,7 @@ npx bmad-method install --directory /path/to/project --modules bmm --tools claud
 
 [See all installation options](https://docs.bmad-method.org/how-to/non-interactive-installation/)
 
-> **Not sure what to do?** Ask `bmad-help` — it tells you exactly what's next and what's optional. You can also ask questions like `bmad-help I just finished the architecture, what do I do next?`
+> **Not sure what to do?** Run `/bmad-help` — it tells you exactly what's next and what's optional. You can also ask questions like `/bmad-help I just finished the architecture, what do I do next?`
 
 ## Modules
 
@@ -81,15 +79,18 @@ BMad Method extends with official modules for specialized domains. Available dur
 ## Community
 
 - [Discord](https://discord.gg/gk8jAdXWmj) — Get help, share ideas, collaborate
-- [YouTube](https://youtube.com/@BMadCode) — Tutorials, master class, and more
-- [X / Twitter](https://x.com/BMadCode)
-- [Website](https://bmadcode.com)
+- [Subscribe on YouTube](https://www.youtube.com/@BMadCode) — Tutorials, master class, and podcast (launching Feb 2025)
 - [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. Star this repo, [buy me a coffee](https://buymeacoffee.com/bmad), or email <contact@bmadcode.com> for corporate sponsorship.
+BMad is free for everyone — and always will be. If you'd like to support development:
+
+- ⭐ Please click the star project icon near the top right of this page
+- ☕ [Buy Me a Coffee](https://buymeacoffee.com/bmad) — Fuel the development
+- 🏢 Corporate sponsorship — DM on Discord
+- 🎤 Speaking & Media — Available for conferences, podcasts, interviews (BM on Discord)
 
 ## Contributing
 

README_CN.md

@@ -5,30 +5,30 @@
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)](https://nodejs.org)
 [![Discord](https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white)](https://discord.gg/gk8jAdXWmj)
 
-**筑梦架构（Build More Architect Dreams）** —— 简称 “BMAD 方法”，面向 BMad 模块生态的 AI 驱动敏捷开发方法。它会随项目复杂度调整工作深度，从日常 bug 修复到企业级系统建设都能适配。
+**突破性敏捷 AI 驱动开发方法** — 简称 “BMAD 方法论” ，BMAD方法论是由多个模块生态构成的AI驱动敏捷开发模块系统，这是最佳且最全面的敏捷 AI 驱动开发框架，具备真正的规模自适应人工智能，可适应快速开发，适应企业规模化开发。
 
-**100% 免费且开源。** 没有付费墙，没有封闭内容，也没有封闭 Discord。我们希望每个人都能平等获得高质量的人机协作开发方法。
+**100% 免费且开源。** 无付费。无内容门槛。无封闭 Discord。我们赋能每个人，我们将为全球现在在人工智能领域发展的普通人提供公平的学习机会。
 
 ## 为什么选择 BMad 方法？
 
-传统 AI 工具常常替你思考，结果往往止于“能用”。BMad 通过专业智能体和引导式工作流，让 AI 成为协作者：流程有结构，决策有依据，产出更稳定。
+传统 AI 工具替你思考，产生平庸的结果。BMad 智能体和辅助工作流充当专家协作者，引导你通过结构化流程，与 AI 的合作发挥最佳思维，产出最有效优秀的结果。
 
-- **AI 智能引导** —— 随时调用 `bmad-help` 获取下一步建议
-- **规模与领域自适应** —— 按项目复杂度自动调整规划深度
-- **结构化工作流** —— 覆盖分析、规划、架构、实施全流程
-- **专业角色智能体** —— 提供 PM、架构师、开发者、UX 等 12+ 角色
-- **派对模式** —— 多个智能体可在同一会话协作讨论
-- **完整生命周期** —— 从头脑风暴一路到交付上线
+- **AI 智能帮助** — 随时使用 `/bmad-help` 获取下一步指导
+- **规模-领域自适应** — 根据项目复杂度自动调整规划深度
+- **结构化工作流** — 基于分析、规划、架构和实施的敏捷最佳实践
+- **专业智能体** — 12+ 领域专家（PM、架构师、开发者、UX、Scrum Master 等）
+- **派对模式** — 将多个智能体角色带入一个会话进行协作和讨论
+- **完整生命周期** — 从想法开始（头脑风暴）到部署发布
 
-[在 **docs.bmad-method.org** 了解更多](https://docs.bmad-method.org/zh-cn/)
+[在 **docs.bmad-method.org** 了解更多](http://docs.bmad-method.org)
 
 ---
 
 ## 🚀 BMad 的下一步是什么？
 
-**V6 已经上线，而这只是开始。** BMad 仍在快速演进：跨平台智能体团队与子智能体集成、Skills 架构、BMad Builder v1、Dev Loop 自动化等能力都在持续推进。
+**V6 已到来，我们才刚刚开始！** BMad 方法正在快速发展，包括跨平台智能体团队和子智能体集成、技能架构、BMad Builder v1、开发循环自动化等优化，以及更多正在开发中的功能。
 
-**[📍 查看完整路线图 →](https://docs.bmad-method.org/zh-cn/roadmap/)**
+**[📍 查看完整路线图 →](http://docs.bmad-method.org/roadmap/)**
 
 ---
 
@@ -40,7 +40,7 @@
 npx bmad-method install
 ```
 
-> 想体验最新预发布版本？可使用 `npx bmad-method@next install`。它比默认版本更新更快，也可能更容易发生变化。
+> 如果你获得的是过时的测试版，请使用：`npx bmad-method@6.0.1 install`
 
 按照安装程序提示操作，然后在项目文件夹中打开你的 AI IDE（Claude Code、Cursor 等）。
 
@@ -50,30 +50,31 @@ npx bmad-method install
 npx bmad-method install --directory /path/to/project --modules bmm --tools claude-code --yes
 ```
 
-[查看非交互式安装选项](https://docs.bmad-method.org/zh-cn/how-to/non-interactive-installation/)
+[查看所有安装选项](http://docs.bmad-method.org/how-to/non-interactive-installation/)
 
-> **不确定下一步？** 直接问 `bmad-help`。它会告诉你“必做什么、可选什么”，例如：`bmad-help 我刚完成架构设计，接下来做什么？`
+> **不确定该做什么？** 运行 `/bmad-help` — 它会准确告诉你下一步做什么以及什么是可选的。你也可以问诸如 `/bmad-help 我刚刚完成了架构设计，接下来该做什么？` 之类的问题。
 
 ## 模块
 
-BMad 可通过官方模块扩展到不同专业场景。你可以在安装时选择，也可以后续随时补装。
+BMad 方法通过官方模块扩展到专业领域。可在安装期间或之后的任何时间使用。
 
-| 模块                                                                                                                | 用途                           |
-| ----------------------------------------------------------------------------------------------------------------- | ---------------------------- |
-| **[BMad Method (BMM)](https://github.com/bmad-code-org/BMAD-METHOD)**                                             | 核心框架，内含 34+ 工作流         |
-| **[BMad Builder (BMB)](https://github.com/bmad-code-org/bmad-builder)**                                           | 创建自定义 BMad 智能体与工作流     |
-| **[Test Architect (TEA)](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)**             | 基于风险的测试策略与自动化         |
-| **[Game Dev Studio (BMGD)](https://github.com/bmad-code-org/bmad-module-game-dev-studio)**                        | 游戏开发工作流（Unity/Unreal/Godot） |
-| **[Creative Intelligence Suite (CIS)](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)** | 创新、头脑风暴、设计思维           |
+| Module                                                                                                            | Purpose                                           |
+| ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------- |
+| **[BMad Method (BMM)](https://github.com/bmad-code-org/BMAD-METHOD)**                                             | 包含 34+ 工作流的核心框架                         |
+| **[BMad Builder (BMB)](https://github.com/bmad-code-org/bmad-builder)**                                           | 创建自定义 BMad 智能体和工作流                     |
+| **[Test Architect (TEA)](https://github.com/bmad-code-org/tea)**                                                  | 基于风险的测试策略和自动化                         |
+| **[Game Dev Studio (BMGD)](https://github.com/bmad-code-org/bmad-module-game-dev-studio)**                        | 游戏开发工作流（Unity、Unreal、Godot）             |
+| **[Creative Intelligence Suite (CIS)](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)** | 创新、头脑风暴、设计思维                           |
 
 ## 文档
 
-[BMad 方法文档站点](https://docs.bmad-method.org/zh-cn/) — 教程、指南、概念和参考
+[BMad 方法文档站点](http://docs.bmad-method.org) — 教程、指南、概念和参考
 
 **快速链接：**
-- [入门教程](https://docs.bmad-method.org/zh-cn/tutorials/getting-started/)
-- [从旧版本升级](https://docs.bmad-method.org/zh-cn/how-to/upgrade-to-v6/)
-- [测试架构师文档（英文）](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+- [入门教程](http://docs.bmad-method.org/tutorials/getting-started/)
+- [从先前版本升级](http://docs.bmad-method.org/how-to/upgrade-to-v6/)
+- [测试架构师文档](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
+
 
 ## 社区
 
@@ -84,9 +85,9 @@ BMad 可通过官方模块扩展到不同专业场景。你可以在安装时选
 
 ## 支持 BMad
 
-BMad 对所有人免费，而且会一直免费。如果你愿意支持项目发展：
+BMad 对每个人都是免费的 — 并且永远如此。如果你想支持开发：
 
-- ⭐ 给仓库点个 Star
+- ⭐ 请点击此页面右上角附近的项目星标图标
 - ☕ [请我喝咖啡](https://buymeacoffee.com/bmad) — 为开发提供动力
 - 🏢 企业赞助 — 在 Discord 上私信
 - 🎤 演讲与媒体 — 可参加会议、播客、采访（在 Discord 上联系 BM）
@@ -106,3 +107,15 @@ MIT 许可证 — 详见 [LICENSE](LICENSE)。
 [![Contributors](https://contrib.rocks/image?repo=bmad-code-org/BMAD-METHOD)](https://github.com/bmad-code-org/BMAD-METHOD/graphs/contributors)
 
 请参阅 [CONTRIBUTORS.md](CONTRIBUTORS.md) 了解贡献者信息。
+
+---
+## 术语说明
+
+- **agent**：智能体。在人工智能与编程文档中，指具备自主决策或执行能力的单元。
+- **workflow**：工作流。指一系列有序的任务或步骤，用于完成特定目标。
+- **CI/CD**：持续集成/持续部署。一种自动化软件开发实践，用于频繁集成代码更改并自动部署。
+- **IDE**：集成开发环境。提供代码编辑、调试、构建等功能的软件开发工具。
+- **PM**：产品经理。负责产品规划、需求管理和团队协调的角色。
+- **UX**：用户体验。指用户在使用产品或服务过程中的整体感受和交互体验。
+- **Scrum Master**：Scrum 主管。敏捷开发 Scrum 框架中的角色，负责促进团队遵循 Scrum 流程。
+- **PRD**：产品需求文档。详细描述产品功能、需求和规格的文档。

README_VN.md

@@ -1,109 +0,0 @@
-![BMad Method](banner-bmad-method.png)
-
-[![Version](https://img.shields.io/npm/v/bmad-method?color=blue&label=version)](https://www.npmjs.com/package/bmad-method)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)](https://nodejs.org)
-[![Python Version](https://img.shields.io/badge/python-%3E%3D3.10-blue?logo=python&logoColor=white)](https://www.python.org)
-[![uv](https://img.shields.io/badge/uv-package%20manager-blueviolet?logo=uv)](https://docs.astral.sh/uv/)
-[![Discord](https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white)](https://discord.gg/gk8jAdXWmj)
-
-[English](README.md) | [简体中文](README_CN.md) | Tiếng Việt
-
-**Build More Architect Dreams** - một mô-đun khung phát triển hướng AI trong hệ sinh thái BMad, có khả năng thích ứng theo quy mô từ sửa lỗi nhỏ đến các hệ thống doanh nghiệp.
-
-**100% miễn phí và mã nguồn mở.** Không có tường phí. Không có nội dung bị khóa. Không có Discord giới hạn quyền truy cập. Chúng tôi tin vào việc trao quyền cho mọi người, không chỉ cho những ai có thể trả tiền để vào một cộng đồng hay khóa học khép kín.
-
-## Vì sao chọn BMad Method?
-
-Các công cụ AI truyền thống thường làm thay phần suy nghĩ của bạn và tạo ra kết quả ở mức trung bình. Các agent chuyên biệt và quy trình làm việc có hướng dẫn của BMad hoạt động như những cộng tác viên chuyên gia, dẫn dắt bạn qua một quy trình có cấu trúc để khai mở tư duy tốt nhất của bạn cùng với AI.
-
-- **Trợ giúp AI thông minh** - Gọi skill `bmad-help` bất kỳ lúc nào để biết bước tiếp theo
-- **Thích ứng theo quy mô và miền bài toán** - Tự động điều chỉnh độ sâu lập kế hoạch theo độ phức tạp của dự án
-- **Quy trình có cấu trúc** - Dựa trên các thực hành tốt nhất của agile xuyên suốt phân tích, lập kế hoạch, kiến trúc và triển khai
-- **Agent chuyên biệt** - Hơn 12 chuyên gia theo vai trò như PM, Architect, Developer, UX, Scrum Master và nhiều vai trò khác
-- **Party Mode** - Đưa nhiều persona agent vào cùng một phiên để cộng tác và thảo luận
-- **Vòng đời hoàn chỉnh** - Từ động não ý tưởng cho đến triển khai
-
-[Tìm hiểu thêm tại **docs.bmad-method.org**](https://docs.bmad-method.org/vi-vn/)
-
----
-
-## 🚀 Điều gì tiếp theo cho BMad?
-
-**V6 đã có mặt và đây mới chỉ là khởi đầu!** BMad Method đang phát triển rất nhanh với các cải tiến như đội agent đa nền tảng và tích hợp sub-agent, kiến trúc Skills, BMad Builder v1, tự động hóa vòng lặp phát triển và nhiều thứ khác vẫn đang được xây dựng.
-
-**[📍 Xem lộ trình đầy đủ →](https://docs.bmad-method.org/vi-vn/roadmap/)**
-
----
-
-## Bắt đầu nhanh
-
-**Điều kiện tiên quyết**: [Node.js](https://nodejs.org) v20+ · [Python](https://www.python.org) 3.10+ · [uv](https://docs.astral.sh/uv/)
-
-```bash
-npx bmad-method install
-```
-
-> Muốn dùng bản prerelease mới nhất? Hãy dùng `npx bmad-method@next install`. Hãy kỳ vọng mức độ biến động cao hơn bản cài đặt mặc định.
-
-Làm theo các lời nhắc của trình cài đặt, sau đó mở AI IDE của bạn như Claude Code hoặc Cursor trong thư mục dự án.
-
-**Cài đặt không tương tác** (cho CI/CD):
-
-```bash
-npx bmad-method install --directory /path/to/project --modules bmm --tools claude-code --yes
-```
-
-[Xem toàn bộ tùy chọn cài đặt](https://docs.bmad-method.org/vi-vn/how-to/non-interactive-installation/)
-
-> **Chưa chắc nên làm gì?** Hãy hỏi `bmad-help` - nó sẽ cho bạn biết chính xác bước nào tiếp theo và bước nào là tùy chọn. Bạn cũng có thể hỏi kiểu như `bmad-help Tôi vừa hoàn thành phần kiến trúc, tiếp theo tôi cần làm gì?`
-
-## Mô-đun
-
-BMad Method có thể được mở rộng bằng các mô-đun chính thức cho những miền chuyên biệt. Chúng có sẵn trong lúc cài đặt hoặc bất kỳ lúc nào sau đó.
-
-| Module                                                                                                            | Mục đích                                           |
-| ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
-| **[BMad Method (BMM)](https://github.com/bmad-code-org/BMAD-METHOD)**                                             | Khung lõi với hơn 34 quy trình                     |
-| **[BMad Builder (BMB)](https://github.com/bmad-code-org/bmad-builder)**                                           | Tạo agent và quy trình BMad tùy chỉnh             |
-| **[Test Architect (TEA)](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)**             | Chiến lược kiểm thử và tự động hóa dựa trên rủi ro |
-| **[Game Dev Studio (BMGD)](https://github.com/bmad-code-org/bmad-module-game-dev-studio)**                        | Quy trình phát triển game (Unity, Unreal, Godot)   |
-| **[Creative Intelligence Suite (CIS)](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)** | Đổi mới, động não ý tưởng, tư duy thiết kế         |
-
-## Tài liệu
-
-[Trang tài liệu BMad Method](https://docs.bmad-method.org/vi-vn/) - bài hướng dẫn, hướng dẫn tác vụ, giải thích khái niệm và tài liệu tham chiếu
-
-**Liên kết nhanh:**
-- [Hướng dẫn bắt đầu](https://docs.bmad-method.org/vi-vn/tutorials/getting-started/)
-- [Nâng cấp từ các phiên bản trước](https://docs.bmad-method.org/vi-vn/how-to/upgrade-to-v6/)
-- [Tài liệu Test Architect](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
-
-## Cộng đồng
-
-- [Discord](https://discord.gg/gk8jAdXWmj) - Nhận trợ giúp, chia sẻ ý tưởng, cộng tác
-- [YouTube](https://youtube.com/@BMadCode) - Video hướng dẫn, master class và nhiều nội dung khác
-- [X / Twitter](https://x.com/BMadCode)
-- [Website](https://bmadcode.com)
-- [GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues) - Báo lỗi và yêu cầu tính năng
-- [Discussions](https://github.com/bmad-code-org/BMAD-METHOD/discussions) - Trao đổi cộng đồng
-
-## Hỗ trợ BMad
-
-BMad miễn phí cho tất cả mọi người và sẽ luôn như vậy. Hãy nhấn sao cho repo này, [mời tôi một ly cà phê](https://buymeacoffee.com/bmad), hoặc gửi email tới <contact@bmadcode.com> nếu bạn muốn tài trợ doanh nghiệp.
-
-## Đóng góp
-
-Chúng tôi luôn chào đón đóng góp. Xem [CONTRIBUTING.md](CONTRIBUTING.md) để biết hướng dẫn.
-
-## Giấy phép
-
-Giấy phép MIT - xem [LICENSE](LICENSE) để biết chi tiết.
-
----
-
-**BMad** và **BMAD-METHOD** là các nhãn hiệu của BMad Code, LLC. Xem [TRADEMARK.md](TRADEMARK.md) để biết chi tiết.
-
-[![Contributors](https://contrib.rocks/image?repo=bmad-code-org/BMAD-METHOD)](https://github.com/bmad-code-org/BMAD-METHOD/graphs/contributors)
-
-Xem [CONTRIBUTORS.md](CONTRIBUTORS.md) để biết thông tin về những người đóng góp.

docs/_STYLE_GUIDE.md

@@ -56,16 +56,16 @@ Critical warnings only — data loss, security issues
 | Phase | Name     | What Happens                                 |
 | ----- | -------- | -------------------------------------------- |
 | 1     | Analysis | Brainstorm, research *(optional)*            |
-| 2     | Planning | Requirements — PRD or spec *(required)* |
+| 2     | Planning | Requirements — PRD or tech-spec *(required)* |
 ```
 
-**Skills:**
+**Commands:**
 
 ```md
-| Skill        | Agent   | Purpose                              |
+| Command      | Agent   | Purpose                              |
 | ------------ | ------- | ------------------------------------ |
-| `bmad-brainstorming` | Analyst | Brainstorm a new project             |
-| `bmad-create-prd`        | PM      | Create Product Requirements Document |
+| `brainstorm` | Analyst | Brainstorm a new project             |
+| `prd`        | PM      | Create Product Requirements Document |
 ```
 
 ## Folder Structure Blocks
@@ -99,7 +99,7 @@ your-project/
 9. Step 2: [Second Major Task]
 10. Step 3: [Third Major Task]
 11. What You've Accomplished (summary + folder structure)
-12. Quick Reference (skills table)
+12. Quick Reference (commands table)
 13. Common Questions (FAQ format)
 14. Getting Help (community links)
 15. Key Takeaways (tip admonition)
@@ -111,7 +111,7 @@ your-project/
 - [ ] "What You'll Learn" section present
 - [ ] Prerequisites in admonition
 - [ ] Quick Path TL;DR admonition at top
-- [ ] Tables for phases, skills, agents
+- [ ] Tables for phases, commands, agents
 - [ ] "What You've Accomplished" section present
 - [ ] Quick Reference table present
 - [ ] Common Questions section present
@@ -148,7 +148,7 @@ your-project/
 | ----------------- | ----------------------------- |
 | **Index/Landing** | `core-concepts/index.md`      |
 | **Concept**       | `what-are-agents.md`          |
-| **Feature**       | `quick-dev.md`                |
+| **Feature**       | `quick-flow.md`               |
 | **Philosophy**    | `why-solutioning-matters.md`  |
 | **FAQ**           | `established-projects-faq.md` |
 
@@ -243,7 +243,7 @@ your-project/
 1. Title + Hook
 2. Items (## for each item)
    - Brief description (one sentence)
-   - **Skills:** or **Key Info:** as flat list
+   - **Commands:** or **Key Info:** as flat list
 3. Universal/Shared (## section) (optional)
 ```
 
@@ -252,7 +252,7 @@ your-project/
 ```text
 1. Title + Hook (one sentence purpose)
 2. Quick Facts (optional note admonition)
-   - Module, Skill, Input, Output as list
+   - Module, Command, Input, Output as list
 3. Purpose/Overview (## section)
 4. How to Invoke (code block)
 5. Key Sections (## for each aspect)
@@ -280,7 +280,7 @@ your-project/
    - Diagram or table showing organization
 3. Major Sections (## for each phase/category)
    - Items (### for each item)
-   - Standardized fields: Skill, Agent, Input, Output, Description
+   - Standardized fields: Command, Agent, Input, Output, Description
 4. Next Steps (optional)
 ```
 
@@ -353,7 +353,7 @@ Only for BMad Method and Enterprise tracks. Quick Flow skips to implementation.
 
 ### Can I change my plan later?
 
-Yes. The `bmad-correct-course` workflow handles scope changes mid-implementation.
+Yes. The SM agent has a `correct-course` workflow for handling scope changes.
 
 **Have a question not answered here?** [Open an issue](...) or ask in [Discord](...).
 ```

docs/cs/404.md

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

docs/cs/_STYLE_GUIDE.md

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

docs/cs/explanation/advanced-elicitation.md

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

docs/cs/explanation/adversarial-review.md

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

docs/cs/explanation/analysis-phase.md

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

docs/cs/explanation/brainstorming.md

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

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

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

docs/cs/explanation/party-mode.md

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

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

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

docs/cs/explanation/project-context.md

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

docs/cs/explanation/quick-dev.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

docs/cs/index.md

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

docs/cs/reference/agents.md

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

docs/cs/reference/commands.md

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

docs/cs/reference/core-tools.md

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

docs/cs/reference/modules.md

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

docs/cs/reference/testing.md

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

docs/cs/reference/workflow-map.md

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

docs/cs/roadmap.mdx

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

docs/cs/tutorials/getting-started.md

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

docs/explanation/analysis-phase.md

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

docs/explanation/brainstorming.md

@@ -9,7 +9,7 @@ Unlock your creativity through guided exploration.
 
 ## What is Brainstorming?
 
-Run `bmad-brainstorming` and you've got a creative facilitator pulling ideas out of you - not generating them for you. The AI acts as coach and guide, using proven techniques to create conditions where your best thinking emerges.
+Run `brainstorming` and you've got a creative facilitator pulling ideas out of you - not generating them for you. The AI acts as coach and guide, using proven techniques to create conditions where your best thinking emerges.
 
 **Good for:**
 

docs/explanation/checkpoint-preview.md

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

docs/explanation/established-projects-faq.md

@@ -34,7 +34,7 @@ Yes! Quick Flow works great for established projects. It will:
 - Auto-detect your existing stack
 - Analyze existing code patterns
 - Detect conventions and ask for confirmation
-- Generate context-rich spec that respects existing code
+- Generate context-rich tech-spec that respects existing code
 
 Perfect for bug fixes and small features in existing codebases.
 
@@ -43,7 +43,7 @@ Perfect for bug fixes and small features in existing codebases.
 Quick Flow detects your conventions and asks: "Should I follow these existing conventions?" You decide:
 
 - **Yes** → Maintain consistency with current codebase
-- **No** → Establish new standards (document why in spec)
+- **No** → Establish new standards (document why in tech-spec)
 
 BMM respects your choice — it won't force modernization, but it will offer it.
 

docs/explanation/named-agents.md

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

docs/explanation/party-mode.md

@@ -9,7 +9,7 @@ Get all your AI agents in one conversation.
 
 ## What is Party Mode?
 
-Run `bmad-party-mode` and you've got your whole AI team in one room - PM, Architect, Dev, UX Designer, whoever you need. BMad Master orchestrates, picking relevant agents per message. Agents respond in character, agree, disagree, and build on each other's ideas.
+Run `party-mode` and you've got your whole AI team in one room - PM, Architect, Dev, UX Designer, whoever you need. BMad Master orchestrates, picking relevant agents per message. Agents respond in character, agree, disagree, and build on each other's ideas.
 
 The conversation continues as long as you want. Ask follow-ups, push back on answers, redirect the discussion - it's a real back-and-forth with your agents until you're done.
 

docs/explanation/preventing-agent-conflicts.md

@@ -108,5 +108,5 @@ Common decisions that prevent conflicts:
 - Document decisions that cross epic boundaries
 - Focus on conflict-prone areas
 - Update architecture as you learn
-- Use `bmad-correct-course` for significant changes
+- Use `correct-course` for significant changes
 :::

docs/explanation/project-context.md

@@ -21,12 +21,12 @@ The `project-context.md` file solves this by documenting what agents need to kno
 Every implementation workflow automatically loads `project-context.md` if it exists. The architect workflow also loads it to respect your technical preferences when designing the architecture.
 
 **Loaded by these workflows:**
-- `bmad-create-architecture` — respects technical preferences during solutioning
-- `bmad-create-story` — informs story creation with project patterns
-- `bmad-dev-story` — guides implementation decisions
-- `bmad-code-review` — validates against project standards
-- `bmad-quick-dev` — applies patterns when implementing specs
-- `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` — provides project-wide context
+- `create-architecture` — respects technical preferences during solutioning
+- `create-story` — informs story creation with project patterns
+- `dev-story` — guides implementation decisions
+- `code-review` — validates against project standards
+- `quick-dev` — applies patterns when implementing tech-specs
+- `sprint-planning`, `retrospective`, `correct-course` — provides project-wide context
 
 ## When to Create It
 
@@ -34,10 +34,10 @@ The `project-context.md` file is useful at any stage of a project:
 
 | Scenario | When to Create | Purpose |
 |----------|----------------|---------|
-| **New project, before architecture** | Manually, before `bmad-create-architecture` | Document your technical preferences so the architect respects them |
-| **New project, after architecture** | Via `bmad-generate-project-context` or manually | Capture architecture decisions for implementation agents |
-| **Existing project** | Via `bmad-generate-project-context` | Discover existing patterns so agents follow established conventions |
-| **Quick Flow project** | Before or during `bmad-quick-dev` | Ensure quick implementation respects your patterns |
+| **New project, before architecture** | Manually, before `create-architecture` | Document your technical preferences so the architect respects them |
+| **New project, after architecture** | Via `generate-project-context` or manually | Capture architecture decisions for implementation agents |
+| **Existing project** | Via `generate-project-context` | Discover existing patterns so agents follow established conventions |
+| **Quick Flow project** | Before or during `quick-dev` | Ensure quick implementation respects your patterns |
 
 :::tip[Recommended]
 For new projects, create it manually before architecture if you have strong technical preferences. Otherwise, generate it after architecture to capture those decisions.
@@ -107,20 +107,20 @@ Edit it with your technology stack and implementation rules. The architect and i
 
 ### Generate After Architecture
 
-Run the `bmad-generate-project-context` workflow after completing your architecture:
+Run the `generate-project-context` workflow after completing your architecture:
 
 ```bash
-bmad-generate-project-context
+/bmad-bmm-generate-project-context
 ```
 
 This scans your architecture document and project files to generate a context file capturing the decisions made.
 
 ### Generate for Existing Projects
 
-For existing projects, run `bmad-generate-project-context` to discover existing patterns:
+For existing projects, run `generate-project-context` to discover existing patterns:
 
 ```bash
-bmad-generate-project-context
+/bmad-bmm-generate-project-context
 ```
 
 The workflow analyzes your codebase to identify conventions, then generates a context file you can review and refine.
@@ -150,7 +150,7 @@ The `project-context.md` file is a living document. Update it when:
 - Patterns evolve during implementation
 - You identify gaps from agent behavior
 
-You can edit it manually at any time, or re-run `bmad-generate-project-context` to update it after significant changes.
+You can edit it manually at any time, or re-run `generate-project-context` to update it after significant changes.
 
 :::note[File Location]
 The default location is `_bmad-output/project-context.md`. Workflows search for it there, and also check `**/project-context.md` anywhere in your project.

docs/explanation/quick-dev.md

@@ -1,73 +0,0 @@
----
-title: "Quick Dev"
-description: Reduce human-in-the-loop friction without giving up the checkpoints that protect output quality
-sidebar:
-  order: 2
----
-
-Intent in, code changes out, with as few human-in-the-loop turns as possible — without sacrificing quality.
-
-It lets the model run longer between checkpoints, then brings the human back only when the task cannot safely continue without human judgment or when it is time to review the end result.
-
-![Quick Dev workflow diagram](/diagrams/quick-dev-diagram.png)
-
-## Why This Exists
-
-Human-in-the-loop turns are necessary and expensive.
-
-Current LLMs still fail in predictable ways: they misread intent, fill gaps with confident guesses, drift into unrelated work, and generate noisy review output. At the same time, constant human intervention limits development velocity. Human attention is the bottleneck.
-
-`bmad-quick-dev` rebalances that tradeoff. It trusts the model to run unsupervised for longer stretches, but only after the workflow has created a strong enough boundary to make that safe.
-
-## The Core Design
-
-### 1. Compress intent first
-
-The workflow starts by having the human and the model compress the request into one coherent goal. The input can begin as a rough expression of intent, but before the workflow runs autonomously it has to become small enough, clear enough, and contradiction-free enough to execute.
-
-Intent can come in many forms: a couple of phrases, a bug tracker link, output from plan mode, text copied from a chat session, or even a story number from BMAD's own `epics.md`. In that last case, the workflow will not understand BMAD story-tracking semantics, but it can still take the story itself and run with it.
-
-This workflow does not eliminate human control. It relocates it to a small number of high-value moments:
-
-- **Intent clarification** - turning a messy request into one coherent goal without hidden contradictions
-- **Spec approval** - confirming that the frozen understanding is the right thing to build
-- **Review of the final product** - the primary checkpoint, where the human decides whether the result is acceptable at the end
-
-### 2. Route to the smallest safe path
-
-Once the goal is clear, the workflow decides whether this is a true one-shot change or whether it needs the fuller path. Small, zero-blast-radius changes can go straight to implementation. Everything else goes through planning so the model has a stronger boundary before it runs longer on its own.
-
-### 3. Run longer with less supervision
-
-After that routing decision, the model can carry more of the work on its own. On the fuller path, the approved spec becomes the boundary the model executes against with less supervision, which is the whole point of the design.
-
-### 4. Diagnose failure at the right layer
-
-If the implementation is wrong because the intent was wrong, patching the code is the wrong fix. If the code is wrong because the spec was weak, patching the diff is also the wrong fix. The workflow is designed to diagnose where the failure entered the system, go back to that layer, and regenerate from there.
-
-Review findings are used to decide whether the problem came from intent, spec generation, or local implementation. Only truly local problems get patched locally.
-
-### 5. Bring the human back only when needed
-
-The intent interview is human-in-the-loop, but it is not the same kind of interruption as a recurring checkpoint. The workflow tries to keep those recurring checkpoints to a minimum. After the initial shaping of intent, the human mainly comes back when the workflow cannot safely continue without judgment and at the end, when it is time to review the result.
-
-- **Intent-gap resolution** - stepping back in when review proves the workflow could not safely infer what was meant
-
-Everything else is a candidate for longer autonomous execution. That tradeoff is deliberate. Older patterns spend more human attention on continuous supervision. Quick Dev spends more trust on the model, but saves human attention for the moments where human reasoning has the highest leverage.
-
-## Why the Review System Matters
-
-The review phase is not just there to find bugs. It is there to route correction without destroying momentum.
-
-This workflow works best on a platform that can spawn subagents, or at least invoke another LLM through the command line and wait for a result. If your platform does not support that natively, you can add a skill to do it. Context-free subagents are a cornerstone of the review design.
-
-Agentic reviews often go wrong in two ways:
-
-- They generate too many findings, forcing the human to sift through noise.
-- They derail the current change by surfacing unrelated issues and turning every run into an ad hoc cleanup project.
-
-Quick Dev addresses both by treating review as triage.
-
-Some findings belong to the current change. Some do not. If a finding is incidental rather than causally tied to the current work, the workflow can defer it instead of forcing the human to handle it immediately. That keeps the run focused and prevents random tangents from consuming the budget of attention.
-
-That triage will sometimes be imperfect. That is acceptable. It is usually better to misjudge some findings than to flood the human with thousands of low-value review comments. The system is optimizing for signal quality, not exhaustive recall.

docs/explanation/quick-flow.md

@@ -0,0 +1,73 @@
+---
+title: "Quick Flow"
+description: Fast-track for small changes - skip the full methodology
+sidebar:
+  order: 1
+---
+
+Skip the ceremony. Quick Flow takes you from idea to working code in two commands - no Product Brief, no PRD, no Architecture doc.
+
+## When to Use It
+
+- Bug fixes and patches
+- Refactoring existing code
+- Small, well-understood features
+- Prototyping and spikes
+- Single-agent work where one developer can hold the full scope
+
+## When NOT to Use It
+
+- New products or platforms that need stakeholder alignment
+- Major features spanning multiple components or teams
+- Work that requires architectural decisions (database schema, API contracts, service boundaries)
+- Anything where requirements are unclear or contested
+
+:::caution[Scope Creep]
+If you start a Quick Flow and realize the scope is bigger than expected, `quick-dev` will detect this and offer to escalate. You can switch to a full PRD workflow at any point without losing your work.
+:::
+
+## How It Works
+
+Quick Flow has two commands, each backed by a structured workflow. You can run them together or independently.
+
+### quick-spec: Plan
+
+Run `quick-spec` and Barry (the Quick Flow agent) walks you through a conversational discovery process:
+
+1. **Understand** - You describe what you want to build. Barry scans the codebase to ask informed questions, then captures a problem statement, solution approach, and scope boundaries.
+2. **Investigate** - Barry reads relevant files, maps code patterns, identifies files to modify, and documents the technical context.
+3. **Generate** - Produces a complete tech-spec with ordered implementation tasks (specific file paths and actions), acceptance criteria in Given/When/Then format, testing strategy, and dependencies.
+4. **Review** - Presents the full spec for your sign-off. You can edit, ask questions, run adversarial review, or refine with advanced elicitation before finalizing.
+
+The output is a `tech-spec-{slug}.md` file saved to your project's implementation artifacts folder. It contains everything a fresh agent needs to implement the feature - no conversation history required.
+
+### quick-dev: Build
+
+Run `quick-dev` and Barry implements the work. It operates in two modes:
+
+- **Tech-spec mode** - Point it at a spec file (`quick-dev tech-spec-auth.md`) and it executes every task in order, writes tests, and verifies acceptance criteria.
+- **Direct mode** - Give it instructions directly (`quick-dev "refactor the auth middleware"`) and it gathers context, builds a mental plan, and executes.
+
+After implementation, `quick-dev` runs a self-check audit against all tasks and acceptance criteria, then triggers an adversarial code review of the diff. Findings are presented for you to resolve before wrapping up.
+
+:::tip[Fresh Context]
+For best results, run `quick-dev` in a new conversation after finishing `quick-spec`. This gives the implementation agent clean context focused solely on building.
+:::
+
+## What Quick Flow Skips
+
+The full BMad Method produces a Product Brief, PRD, Architecture doc, and Epic/Story breakdown before any code is written. Quick Flow replaces all of that with a single tech-spec. This works because Quick Flow targets changes where:
+
+- The product direction is already established
+- Architecture decisions are already made
+- A single developer can reason about the full scope
+- Requirements fit in one conversation
+
+## Escalating to Full BMad Method
+
+Quick Flow includes built-in guardrails for scope detection. When you run `quick-dev` with a direct request, it evaluates signals like multi-component mentions, system-level language, and uncertainty about approach. If it detects the work is bigger than a quick flow:
+
+- **Light escalation** - Recommends running `quick-spec` first to create a plan
+- **Heavy escalation** - Recommends switching to the full BMad Method PRD process
+
+You can also escalate manually at any time. Your tech-spec work carries forward - it becomes input for the broader planning process rather than being discarded.

docs/fr/404.md

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

docs/fr/_STYLE_GUIDE.md

@@ -1,370 +0,0 @@
----
-title: "Guide de style de la documentation"
-description: Conventions de documentation spécifiques au projet, basées sur le style Google et la structure Diataxis
----
-
-Ce projet suit le [Guide de style de documentation pour développeurs Google](https://developers.google.com/style) et utilise [Diataxis](https://diataxis.fr/) pour structurer le contenu. Seules les conventions spécifiques au projet sont présentées ci-dessous.
-
-## Règles spécifiques au projet
-
-| Règle                                   | Spécification                                          |
-| --------------------------------------- | ------------------------------------------------------ |
-| Pas de règles horizontales (`---`)      | Perturbe le flux de lecture des fragments              |
-| Pas de titres `####`                    | Utiliser du texte en gras ou des admonitions           |
-| Pas de sections « Related » ou « Next: »    | La barre latérale gère la navigation                   |
-| Pas de listes profondément imbriquées   | Diviser en sections à la place                         |
-| Pas de blocs de code pour non-code      | Utiliser des admonitions pour les exemples de dialogue |
-| Pas de paragraphes en gras pour les appels | Utiliser des admonitions à la place                 |
-| 1-2 admonitions max par section         | Les tutoriels permettent 3-4 par section majeure       |
-| Cellules de tableau / éléments de liste | 1-2 phrases maximum                                    |
-| Budget de titres                        | 8-12 `##` par doc ; 2-3 `###` par section              |
-
-## Admonitions (Syntaxe Starlight)
-
-```md
-:::tip[Titre]
-Raccourcis, bonnes pratiques
-:::
-
-:::note[Titre]
-Contexte, définitions, exemples, prérequis
-:::
-
-:::caution[Titre]
-Mises en garde, problèmes potentiels
-:::
-
-:::danger[Titre]
-Avertissements critiques uniquement — perte de données, problèmes de sécurité
-:::
-```
-
-### Utilisations standards
-
-| Admonition                 | Usage                                    |
-| -------------------------- | ---------------------------------------- |
-| `:::note[Pré-requis]`   | Dépendances avant de commencer           |
-| `:::tip[Chemin rapide]`       | Résumé TL;DR en haut du document         |
-| `:::caution[Important]`    | Mises en garde critiques                 |
-| `:::note[Exemple]`         | Exemples de commandes/réponses           |
-
-## Formats de tableau standards
-
-**Phases :**
-
-```md
-| Phase | Nom        | Ce qui se passe                                     |
-| ----- | ---------- | --------------------------------------------------- |
-| 1     | Analyse    | Brainstorm, recherche *(optionnel)*                 |
-| 2     | Planification | Exigences — PRD ou spécification technique *(requis)*          |
-```
-
-**Skills :**
-
-```md
-| Skill               | Agent   | Objectif                                        |
-| ------------------- | ------- | ----------------------------------------------- |
-| `bmad-brainstorming` | Analyste | Brainstorming pour un nouveau projet                    |
-| `bmad-create-prd`    | PM      | Créer un document d'exigences produit           |
-```
-
-## Blocs de structure de dossiers
-
-À afficher dans les sections "Ce que vous avez accompli" :
-
-````md
-```
-votre-projet/
-├── _bmad/                                   # Configuration BMad
-├── _bmad-output/
-│   ├── planning-artifacts/
-│   │   └── PRD.md                           # Votre document d'exigences
-│   ├── implementation-artifacts/
-│   └── project-context.md                   # Règles d'implémentation (optionnel)
-└── ...
-```
-````
-
-## Structure des tutoriels
-
-```text
-1. Titre + Accroche (1-2 phrases décrivant le résultat)
-2. Notice de version/module (admonition info ou avertissement) (optionnel)
-3. Ce que vous allez apprendre (liste à puces des résultats)
-4. Prérequis (admonition info)
-5. Chemin rapide (admonition tip - résumé TL;DR)
-6. Comprendre [Sujet] (contexte avant les étapes - tableaux pour phases/agents)
-7. Installation (optionnel)
-8. Étape 1 : [Première tâche majeure]
-9. Étape 2 : [Deuxième tâche majeure]
-10. Étape 3 : [Troisième tâche majeure]
-11. Ce que vous avez accompli (résumé + structure de dossiers)
-12. Référence rapide (tableau des compétences)
-13. Questions courantes (format FAQ)
-14. Obtenir de l'aide (liens communautaires)
-15. Points clés à retenir (admonition tip)
-```
-
-### Liste de vérification des tutoriels
-
-- [ ] L'accroche décrit le résultat en 1-2 phrases
-- [ ] Section "Ce que vous allez apprendre" présente
-- [ ] Prérequis dans une admonition
-- [ ] Admonition TL;DR de chemin rapide en haut
-- [ ] Tableaux pour phases, skills, agents
-- [ ] Section "Ce que vous avez accompli" présente
-- [ ] Tableau de référence rapide présent
-- [ ] Section questions courantes présente
-- [ ] Section obtenir de l'aide présente
-- [ ] Admonition points clés à retenir à la fin
-
-## Structure des guides pratiques (How-To)
-
-```text
-1. Titre + Accroche (une phrase : « Utilisez le workflow `X` pour... »)
-2. Quand utiliser ce guide (liste à puces de scénarios)
-3. Quand éviter ce guide (optionnel)
-4. Prérequis (admonition note)
-5. Étapes (sous-sections ### numérotées)
-6. Ce que vous obtenez (produits de sortie/artefacts)
-7. Exemple (optionnel)
-8. Conseils (optionnel)
-9. Prochaines étapes (optionnel)
-```
-
-### Liste de vérification des guides pratiques
-
-- [ ] L'accroche commence par « Utilisez le workflow `X` pour... »
-- [ ] "Quand utiliser ce guide" contient 3-5 points
-- [ ] Prérequis listés
-- [ ] Les étapes sont des sous-sections `###` numérotées avec des verbes d'action
-- [ ] "Ce que vous obtenez" décrit les artefacts produits
-
-## Structure des explications
-
-### Types
-
-| Type                    | Exemple                              |
-| ----------------------- | ------------------------------------ |
-| **Index/Page d'accueil** | `core-concepts/index.md`            |
-| **Concept**             | `what-are-agents.md`                 |
-| **Fonctionnalité**      | `quick-dev.md`                       |
-| **Philosophie**         | `why-solutioning-matters.md`         |
-| **FAQ**                 | `established-projects-faq.md`        |
-
-### Modèle général
-
-```text
-1. Titre + Accroche (1-2 phrases)
-2. Vue d'ensemble/Définition (ce que c'est, pourquoi c'est important)
-3. Concepts clés (sous-sections ###)
-4. Tableau comparatif (optionnel)
-5. Quand utiliser / Quand ne pas utiliser (optionnel)
-6. Diagramme (optionnel - mermaid, 1 max par doc)
-7. Prochaines étapes (optionnel)
-```
-
-### Pages d'index/d'accueil
-
-```text
-1. Titre + Accroche (une phrase)
-2. Tableau de contenu (liens avec descriptions)
-3. Pour commencer (liste numérotée)
-4. Choisissez votre parcours (optionnel - arbre de décision)
-```
-
-### Explications de concepts
-
-```text
-1. Titre + Accroche (ce que c'est)
-2. Types/Catégories (sous-sections ###) (optionnel)
-3. Tableau des différences clés
-4. Composants/Parties
-5. Lequel devriez-vous utiliser ?
-6. Création/Personnalisation (lien vers les guides pratiques)
-```
-
-### Explications de fonctionnalités
-
-```text
-1. Titre + Accroche (ce que cela fait)
-2. Faits rapides (optionnel - "Idéal pour :", "Temps :")
-3. Quand utiliser / Quand ne pas utiliser
-4. Comment cela fonctionne (diagramme mermaid optionnel)
-5. Avantages clés
-6. Tableau comparatif (optionnel)
-7. Quand évoluer/mettre à niveau (optionnel)
-```
-
-### Documents de philosophie/justification
-
-```text
-1. Titre + Accroche (le principe)
-2. Le problème
-3. La solution
-4. Principes clés (sous-sections ###)
-5. Avantages
-6. Quand cela s'applique
-```
-
-### Liste de vérification des explications
-
-- [ ] L'accroche énonce ce que le document explique
-- [ ] Contenu dans des sections `##` parcourables
-- [ ] Tableaux comparatifs pour 3+ options
-- [ ] Les diagrammes ont des étiquettes claires
-- [ ] Liens vers les guides pratiques pour les questions procédurales
-- [ ] 2-3 admonitions max par document
-
-## Structure des références
-
-### Types
-
-| Type                    | Exemple               |
-| ----------------------- | --------------------- |
-| **Index/Page d'accueil** | `workflows/index.md` |
-| **Catalogue**           | `agents/index.md`     |
-| **Approfondissement**   | `document-project.md` |
-| **Configuration**       | `core-tasks.md`       |
-| **Glossaire**           | `glossary/index.md`   |
-| **Complet**             | `bmgd-workflows.md`   |
-
-### Pages d'index de référence
-
-```text
-1. Titre + Accroche (une phrase)
-2. Sections de contenu (## pour chaque catégorie)
-   - Liste à puces avec liens et descriptions
-```
-
-### Référence de catalogue
-
-```text
-1. Titre + Accroche
-2. Éléments (## pour chaque élément)
-   - Brève description (une phrase)
-   - **Skills :** ou **Infos clés :** sous forme de liste simple
-3. Universel/Partagé (## section) (optionnel)
-```
-
-### Référence d'approfondissement d'élément
-
-```text
-1. Titre + Accroche (objectif en une phrase)
-2. Faits rapides (admonition note optionnelle)
-   - Module, Skill, Entrée, Sortie sous forme de liste
-3. Objectif/Vue d'ensemble (## section)
-4. Comment invoquer (bloc de code)
-5. Sections clés (## pour chaque aspect)
-   - Utiliser ### pour les sous-options
-6. Notes/Mises en garde (admonition tip ou caution)
-```
-
-### Référence de configuration
-
-```text
-1. Titre + Accroche
-2. Table des matières (liens de saut si 4+ éléments)
-3. Éléments (## pour chaque config/tâche)
-   - **Résumé en gras** — une phrase
-   - **Utilisez-le quand :** liste à puces
-   - **Comment cela fonctionne :** étapes numérotées (3-5 max)
-   - **Sortie :** résultat attendu (optionnel)
-```
-
-### Guide de référence complet
-
-```text
-1. Titre + Accroche
-2. Vue d'ensemble (## section)
-   - Diagramme ou tableau montrant l'organisation
-3. Sections majeures (## pour chaque phase/catégorie)
-   - Éléments (### pour chaque élément)
-   - Champs standardisés : Skill, Agent, Entrée, Sortie, Description
-4. Prochaines étapes (optionnel)
-```
-
-### Liste de vérification des références
-
-- [ ] L'accroche énonce ce que le document référence
-- [ ] La structure correspond au type de référence
-- [ ] Les éléments utilisent une structure cohérente
-- [ ] Tableaux pour les données structurées/comparatives
-- [ ] Liens vers les documents d'explication pour la profondeur conceptuelle
-- [ ] 1-2 admonitions max
-
-## Structure du glossaire
-
-Starlight génère la navigation "Sur cette page" à droite à partir des titres :
-
-- Catégories en tant que titres `##` — apparaissent dans la navigation à droite
-- Termes dans des tableaux — lignes compactes, pas de titres individuels
-- Pas de TOC en ligne — la barre latérale à droite gère la navigation
-
-### Format de tableau
-
-```md
-## Nom de catégorie
-
-| Terme        | Définition                                                                                    |
-| ------------ | --------------------------------------------------------------------------------------------- |
-| **Agent**    | Personnalité IA spécialisée avec une expertise spécifique qui guide les utilisateurs dans les workflows. |
-| **Workflow** | Processus guidé en plusieurs étapes qui orchestre les activités des agents IA pour produire des livrables. |
-```
-
-### Règles de définition
-
-| À faire                           | À ne pas faire                                |
-| --------------------------------- | --------------------------------------------- |
-| Commencer par ce que c'est ou ce que cela fait | Commencer par « C'est... » ou « Un [terme] est... » |
-| Se limiter à 1-2 phrases          | Écrire des explications de plusieurs paragraphes |
-| Mettre le nom du terme en gras dans la cellule | Utiliser du texte simple pour les termes      |
-
-### Marqueurs de contexte
-
-Ajouter un contexte en italique au début de la définition pour les termes à portée limitée :
-
-- `*Quick Dev uniquement.*`
-- `*méthode BMad/Enterprise.*`
-- `*Phase N.*`
-- `*BMGD.*`
-- `*Projets établis.*`
-
-### Liste de vérification du glossaire
-
-- [ ] Termes dans des tableaux, pas de titres individuels
-- [ ] Termes alphabétisés au sein des catégories
-- [ ] Définitions de 1-2 phrases
-- [ ] Marqueurs de contexte en italique
-- [ ] Noms des termes en gras dans les cellules
-- [ ] Pas de définitions « Un [terme] est... »
-
-## Sections FAQ
-
-```md
-## Questions
-
-- [Ai-je toujours besoin d'architecture ?](#ai-je-toujours-besoin-darchitecture)
-- [Puis-je modifier mon plan plus tard ?](#puis-je-modifier-mon-plan-plus-tard)
-
-### Ai-je toujours besoin d'architecture ?
-
-Uniquement pour les parcours méthode BMad et Enterprise. Quick Dev passe directement à l'implémentation.
-
-### Puis-je modifier mon plan plus tard ?
-
-Oui. Utilisez `bmad-correct-course` pour gérer les changements de portée en cours d’implémentation.
-
-**Une question sans réponse ici ?** [Ouvrez une issue](...) ou posez votre question sur [Discord](...).
-```
-
-## Commandes de validation
-
-Avant de soumettre des modifications de documentation :
-
-```bash
-npm run docs:fix-links            # Prévisualiser les corrections de format de liens
-npm run docs:fix-links -- --write # Appliquer les corrections
-npm run docs:validate-links       # Vérifier que les liens existent
-npm run docs:build                # Vérifier l'absence d'erreurs de build
-```

docs/fr/explanation/advanced-elicitation.md

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

docs/fr/explanation/adversarial-review.md

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

docs/fr/explanation/analysis-phase.md

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

docs/fr/explanation/brainstorming.md

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

docs/fr/explanation/checkpoint-preview.md

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

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

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

docs/fr/explanation/party-mode.md

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

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

@@ -1,117 +0,0 @@
----
-title: "Prévention des conflits entre agents"
-description: Comment l'architecture empêche les conflits lorsque plusieurs agents implémentent un système
-sidebar:
-  order: 6
----
-
-Lorsque plusieurs agents IA implémentent différentes parties d'un système, ils peuvent prendre des décisions techniques contradictoires. La documentation d'architecture prévient cela en établissant des standards partagés.
-
-## Types de conflits courants
-
-### Conflits de style d'API
-
-Sans architecture :
-- L'agent A utilise REST avec `/users/{id}`
-- L'agent B utilise des mutations GraphQL
-- Résultat : Patterns d'API incohérents, consommateurs confus
-
-Avec architecture :
-- L'ADR[^1] spécifie : « Utiliser GraphQL pour toute communication client-serveur »
-- Tous les agents suivent le même pattern
-
-### Conflits de conception de base de données
-
-Sans architecture :
-- L'agent A utilise des noms de colonnes en snake_case
-- L'agent B utilise des noms de colonnes en camelCase
-- Résultat : Schéma incohérent, requêtes illisibles
-
-Avec architecture :
-- Un document de standards spécifie les conventions de nommage
-- Tous les agents suivent les mêmes patterns
-
-### Conflits de gestion d'état
-
-Sans architecture :
-- L'agent A utilise Redux pour l'état global
-- L'agent B utilise React Context
-- Résultat : Multiples approches de gestion d'état, complexité
-
-Avec architecture :
-- L'ADR spécifie l'approche de gestion d'état
-- Tous les agents implémentent de manière cohérente
-
-## Comment l'architecture prévient les conflits
-
-### 1. Décisions explicites via les ADR[^1]
-
-Chaque choix technologique significatif est documenté avec :
-- Contexte (pourquoi cette décision est importante)
-- Options considérées (quelles alternatives existent)
-- Décision (ce qui a été choisi)
-- Justification (pourquoi cela a-t-il été choisi)
-- Conséquences (compromis acceptés)
-
-### 2. Guidance spécifique aux FR/NFR[^2]
-
-L'architecture associe chaque exigence fonctionnelle à une approche technique :
-- FR-001 : Gestion des utilisateurs → Mutations GraphQL
-- FR-002 : Application mobile → Requêtes optimisées
-
-### 3. Standards et conventions
-
-Documentation explicite de :
-- La structure des répertoires
-- Les conventions de nommage
-- L'organisation du code
-- Les patterns de test
-
-## L'architecture comme contexte partagé
-
-Considérez l'architecture comme le contexte partagé que tous les agents lisent avant d'implémenter :
-
-```text
-PRD : "Que construire"
-     ↓
-Architecture : "Comment le construire"
-     ↓
-L'agent A lit l'architecture → implémente l'Epic 1
-L'agent B lit l'architecture → implémente l'Epic 2
-L'agent C lit l'architecture → implémente l'Epic 3
-     ↓
-Résultat : Implémentation cohérente
-```
-
-## Sujets clés des ADR
-
-Décisions courantes qui préviennent les conflits :
-
-| Sujet            | Exemple de décision                          |
-| ---------------- | -------------------------------------------- |
-| Style d'API      | GraphQL vs REST vs gRPC                      |
-| Base de données  | PostgreSQL vs MongoDB                        |
-| Authentification | JWT vs Sessions                              |
-| Gestion d'état   | Redux vs Context vs Zustand                  |
-| Styling          | CSS Modules vs Tailwind vs Styled Components |
-| Tests            | Jest + Playwright vs Vitest + Cypress        |
-
-## Anti-patterns à éviter
-
-:::caution[Erreurs courantes]
-- **Décisions implicites** — « On décidera du style d'API au fur et à mesure » mène à l'incohérence
-- **Sur-documentation** — Documenter chaque choix mineur cause une paralysie analytique
-- **Architecture obsolète** — Les documents écrits une fois et jamais mis à jour poussent les agents à suivre des patterns dépassés
-:::
-
-:::tip[Approche correcte]
-- Documenter les décisions qui traversent les frontières des epics
-- Se concentrer sur les zones sujettes aux conflits
-- Mettre à jour l'architecture au fur et à mesure des apprentissages
-- Utiliser `bmad-correct-course` pour les changements significatifs
-:::
-
-## Glossaire
-
-[^1]: ADR (Architecture Decision Record) : document qui consigne une décision d’architecture, son contexte, les options envisagées, le choix retenu et ses conséquences, afin d’assurer la traçabilité et la compréhension des décisions techniques dans le temps.
-[^2]: FR / NFR (Functional / Non-Functional Requirement) : exigences décrivant respectivement **ce que le système doit faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité, fiabilité, ergonomie, etc.).

docs/fr/explanation/project-context.md

@@ -1,158 +0,0 @@
----
-title: "Contexte du Projet"
-description: Comment project-context.md guide les agents IA avec les règles et préférences de votre projet
-sidebar:
-  order: 10
----
-
-Le fichier `project-context.md` est le guide d'implémentation de votre projet pour les agents IA. Similaire à une « constitution » dans d'autres systèmes de développement, il capture les règles, les patterns et les préférences qui garantissent une génération de code cohérente à travers tous les workflows.
-
-## Ce Qu'il Fait
-
-Les agents IA prennent constamment des décisions d'implémentation — quels patterns suivre, comment structurer le code, quelles conventions utiliser. Sans guidance claire, ils peuvent :
-- Suivre des bonnes pratiques génériques qui ne correspondent pas à votre codebase
-- Prendre des décisions incohérentes selon les différentes stories
-- Passer à côté d'exigences ou de contraintes spécifiques au projet
-
-Le fichier `project-context.md` résout ce problème en documentant ce que les agents doivent savoir dans un format concis et optimisé pour les LLM.
-
-## Comment Ça Fonctionne
-
-Chaque workflow d'implémentation charge automatiquement `project-context.md` s'il existe. Le workflow architecte le charge également pour respecter vos préférences techniques lors de la conception de l'architecture.
-
-**Chargé par ces workflows :**
-- `bmad-create-architecture` — respecte les préférences techniques pendant la phase de solutioning
-- `bmad-create-story` — informe la création de stories avec les patterns du projet
-- `bmad-dev-story` — guide les décisions d'implémentation
-- `bmad-code-review` — valide par rapport aux standards du projet
-- `bmad-quick-dev` — applique les patterns lors de l'implémentation des spécifications techniques
-- `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` — fournit le contexte global du projet
-
-## Quand Le Créer
-
-Le fichier `project-context.md` est utile à n'importe quel stade d'un projet :
-
-| Scénario                                 | Quand Créer                                         | Objectif                                                                              |
-|------------------------------------------|-----------------------------------------------------|---------------------------------------------------------------------------------------|
-| **Nouveau projet, avant l'architecture** | Manuellement, avant `bmad-create-architecture`      | Documenter vos préférences techniques pour que l'architecte les respecte              |
-| **Nouveau projet, après l'architecture** | Via `bmad-generate-project-context` ou manuellement | Capturer les décisions d'architecture pour les agents d'implémentation                |
-| **Projet existant**                      | Via `bmad-generate-project-context`                 | Découvrir les patterns existants pour que les agents suivent les conventions établies |
-| **Projet Quick Dev**                   | Avant ou pendant `bmad-quick-dev`                   | Garantir que l'implémentation rapide respecte vos patterns                            |
-
-:::tip[Recommandé]
-Pour les nouveaux projets, créez-le manuellement avant l'architecture si vous avez de fortes préférences techniques. Sinon, générez-le après l'architecture pour capturer ces décisions.
-:::
-
-## Ce Qu'il Contient
-
-Le fichier a deux sections principales :
-
-### Pile Technologique & Versions
-
-Documente les frameworks, langages et outils utilisés par votre projet avec leurs versions spécifiques :
-
-```markdown
-## Pile Technologique & Versions
-
-- Node.js 20.x, TypeScript 5.3, React 18.2
-- State: Zustand (pas Redux)
-- Testing: Vitest, Playwright, MSW
-- Styling: Tailwind CSS avec design tokens personnalisés
-```
-
-### Règles Critiques d’Implémentation
-
-Documente les patterns et conventions que les agents pourraient autrement manquer :
-
-```markdown
-
-## Règles Critiques d’Implémentation
-
-**Configuration TypeScript :**
-- Mode strict activé — pas de types `any` sans approbation explicite
-- Utiliser `interface` pour les APIs publiques, `type` pour les unions/intersections
-
-**Organisation du Code :**
-- Composants dans `/src/components/` avec fichiers `.test.tsx` co-localisés
-- Utilitaires dans `/src/lib/` pour les fonctions pures réutilisables
-- Les appels API utilisent le singleton `apiClient` — jamais de fetch direct
-
-**Patterns de Tests :**
-- Les tests unitaires se concentrent sur la logique métier, pas sur les détails d’implémentation
-- Les tests d’intégration utilisent MSW pour simuler les réponses API
-- Les tests E2E couvrent uniquement les parcours utilisateurs critiques
-
-**Spécifique au Framework :**
-- Toutes les opérations async utilisent le wrapper `handleError` pour une gestion cohérente des erreurs
-- Les feature flags sont accessibles via `featureFlag()` de `@/lib/flags`
-- Les nouvelles routes suivent le modèle de routage basé sur les fichiers dans `/src/app/`
-```
-
-Concentrez-vous sur ce qui est **non évident** — des choses que les agents pourraient ne pas déduire en lisant des extraits de code. Ne documentez pas les pratiques standard qui s'appliquent universellement.
-
-## Création du Fichier
-
-Vous avez trois options :
-
-### Création Manuelle
-
-Créez le fichier `_bmad-output/project-context.md` et ajoutez vos règles :
-
-```bash
-# Depuis la racine du projet
-mkdir -p _bmad-output
-touch _bmad-output/project-context.md
-```
-
-Éditez-le avec votre pile technologique et vos règles d'implémentation. Les workflows architecture et implémentation le trouveront et le chargeront automatiquement.
-
-### Générer Après L'Architecture
-
-Exécutez le workflow `bmad-generate-project-context` après avoir terminé votre architecture :
-
-```bash
-bmad-generate-project-context
-```
-
-Cela analyse votre document d'architecture et vos fichiers projet pour générer un fichier de contexte capturant les décisions prises.
-
-### Générer Pour Les Projets Existants
-
-Pour les projets existants, exécutez `bmad-generate-project-context` pour découvrir les patterns existants :
-
-```bash
-bmad-generate-project-context
-```
-
-Le workflow analyse votre codebase pour identifier les conventions, puis génère un fichier de contexte que vous pouvez examiner et affiner.
-
-## Pourquoi C'est Important
-
-Sans `project-context.md`, les agents font des suppositions qui peuvent ne pas correspondre à votre projet :
-
-| Sans Contexte                                      | Avec Contexte                                   |
-|----------------------------------------------------|-------------------------------------------------|
-| Utilise des patterns génériques                    | Suit vos conventions établies                   |
-| Style incohérent selon les stories                 | Implémentation cohérente                        |
-| Peut manquer les contraintes spécifiques au projet | Respecte toutes les exigences techniques        |
-| Chaque agent décide indépendamment                 | Tous les agents s'alignent sur les mêmes règles |
-
-C'est particulièrement important pour :
-- **Quick Dev** — saute le PRD et l'architecture, le fichier de contexte comble le vide
-- **Projets d'équipe** — garantit que tous les agents suivent les mêmes standards
-- **Projets existants** — empêche de casser les patterns établis
-
-## Édition et Mise à Jour
-
-Le fichier `project-context.md` est un document vivant. Mettez-le à jour quand :
-
-- Les décisions d'architecture changent
-- De nouvelles conventions sont établies
-- Les patterns évoluent pendant l'implémentation
-- Vous identifiez des lacunes dans le comportement des agents
-
-Vous pouvez l'éditer manuellement à tout moment, ou réexécuter `bmad-generate-project-context` pour le mettre à jour après des changements significatifs.
-
-:::note[Emplacement du Fichier]
-L'emplacement par défaut est `_bmad-output/project-context.md`. Les workflows le recherchent là, et vérifient également `**/project-context.md` n'importe où dans votre projet.
-:::

docs/fr/explanation/quick-dev.md

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

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

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

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

@@ -1,174 +0,0 @@
----
-title: "Comment personnaliser BMad"
-description: Personnalisez les agents, les workflows et les modules tout en préservant la compatibilité avec les mises à jour
-sidebar:
-  order: 7
----
-
-Utilisez les fichiers `.customize.yaml` pour adapter le comportement, les personas[^1] et les menus des agents tout en préservant vos modifications lors des mises à jour.
-
-## Quand utiliser cette fonctionnalité
-
-- Vous souhaitez modifier le nom, la personnalité ou le style de communication d'un agent
-- Vous avez besoin que les agents se souviennent du contexte spécifique au projet
-- Vous souhaitez ajouter des éléments de menu personnalisés qui déclenchent vos propres workflows ou prompts
-- Vous voulez que les agents effectuent des actions spécifiques à chaque démarrage
-
-:::note[Prérequis]
-- BMad installé dans votre projet (voir [Comment installer BMad](./install-bmad.md))
-- Un éditeur de texte pour les fichiers YAML
-:::
-
-:::caution[Protégez vos personnalisations]
-Utilisez toujours les fichiers `.customize.yaml` décrits ici plutôt que de modifier directement les fichiers d'agents. L'installateur écrase les fichiers d'agents lors des mises à jour, mais préserve vos modifications dans les fichiers `.customize.yaml`.
-:::
-
-## Étapes
-
-### 1. Localiser les fichiers de personnalisation
-
-Après l'installation, vous trouverez un fichier `.customize.yaml` par agent dans :
-
-```text
-_bmad/_config/agents/
-├── bmm-analyst.customize.yaml
-├── bmm-architect.customize.yaml
-└── ... (un fichier par agent installé)
-```
-
-### 2. Modifier le fichier de personnalisation
-
-Ouvrez le fichier `.customize.yaml` de l'agent que vous souhaitez modifier. Chaque section est facultative — personnalisez uniquement ce dont vous avez besoin.
-
-| Section            | Comportement | Objectif                                         |
-| ------------------ | ------------ | ------------------------------------------------ |
-| `agent.metadata`   | Remplace     | Remplacer le nom d'affichage de l'agent          |
-| `persona`          | Remplace     | Définir le rôle, l'identité, le style et les principes |
-| `memories`         | Ajoute       | Ajouter un contexte persistant que l'agent se rappelle toujours |
-| `menu`             | Ajoute       | Ajouter des éléments de menu personnalisés pour les workflows ou prompts |
-| `critical_actions` | Ajoute       | Définir les instructions de démarrage de l'agent |
-| `prompts`          | Ajoute       | Créer des prompts réutilisables pour les actions du menu |
-
-Les sections marquées **Remplace** écrasent entièrement les valeurs par défaut de l'agent. Les sections marquées **Ajoute** s'ajoutent à la configuration existante.
-
-**Nom de l'agent**
-
-Modifier la façon dont l'agent se présente :
-
-```yaml
-agent:
-  metadata:
-    name: 'Bob l’éponge' # Par défaut : "Amelia"
-```
-
-**Persona**
-
-Remplacer la personnalité, le rôle et le style de communication de l'agent :
-
-```yaml
-persona:
-  role: 'Ingénieur Full-Stack Senior'
-  identity: 'Habite dans un ananas (au fond de la mer)'
-  communication_style: 'Style agaçant de Bob l’Éponge'
-  principles:
-    - 'Jamais de nidification, les devs Bob l’Éponge détestent plus de 2 niveaux d’imbrication'
-    - 'Privilégier la composition à l’héritage'
-```
-
-La section `persona`[^1] remplace entièrement le persona par défaut, donc incluez les quatre champs si vous la définissez.
-
-**Souvenirs**
-
-Ajouter un contexte persistant que l'agent gardera toujours en mémoire :
-
-```yaml
-memories:
-  - 'Travaille au Krusty Krab'
-  - 'Célébrité préférée : David Hasselhoff'
-  - 'Appris dans l’Epic 1 que ce n’est pas cool de faire semblant que les tests ont passé'
-```
-
-**Éléments de menu**
-
-Ajouter des entrées personnalisées au menu d'affichage de l'agent. Chaque élément nécessite un `trigger`, une cible (chemin `workflow` ou référence `action`), et une `description` :
-
-```yaml
-menu:
-  - trigger: my-workflow
-    workflow: 'my-custom/workflows/my-workflow.yaml'
-    description: Mon workflow personnalisé
-  - trigger: deploy
-    action: '#deploy-prompt'
-    description: Déployer en production
-```
-
-**Actions critiques**
-
-Définir des instructions qui s'exécutent au démarrage de l'agent :
-
-```yaml
-critical_actions:
-  - 'Vérifier les pipelines CI avec le Skill XYZ et alerter l’utilisateur au réveil si quelque chose nécessite une attention urgente'
-```
-
-**Prompts personnalisés**
-
-Créer des prompts réutilisables que les éléments de menu peuvent référencer avec `action="#id"` :
-
-```yaml
-prompts:
-  - id: deploy-prompt
-    content: |
-      Déployer la branche actuelle en production :
-      1. Exécuter tous les tests
-      2. Build le projet
-      3. Exécuter le script de déploiement
-```
-
-### 3. Appliquer vos modifications
-
-Après modification, réinstallez pour appliquer les changements :
-
-```bash
-npx bmad-method install
-```
-
-L'installateur détecte l'installation existante et propose ces options :
-
-| Option                              | Ce qu'elle fait                                                        |
-| ----------------------------------- | ---------------------------------------------------------------------- |
-| **Quick Update**                    | Met à jour tous les modules vers la dernière version et applique les personnalisations |
-| **Modify BMad Installation**        | Flux d'installation complet pour ajouter ou supprimer des modules     |
-
-Pour des modifications de personnalisation uniquement, **Quick Update** est l'option la plus rapide.
-
-## Résolution des problèmes
-
-**Les modifications n'apparaissent pas ?**
-
-- Exécutez `npx bmad-method install` et sélectionnez **Quick Update** pour appliquer les modifications
-- Vérifiez que votre syntaxe YAML est valide (l'indentation compte)
-- Assurez-vous d'avoir modifié le bon fichier `.customize.yaml` pour l'agent
-
-**L'agent ne se charge pas ?**
-
-- Vérifiez les erreurs de syntaxe YAML à l'aide d'un validateur YAML en ligne
-- Assurez-vous de ne pas avoir laissé de champs vides après les avoir décommentés
-- Essayez de revenir au modèle d'origine et de reconstruire
-
-**Besoin de réinitialiser un agent ?**
-
-- Effacez ou supprimez le fichier `.customize.yaml` de l'agent
-- Exécutez `npx bmad-method install` et sélectionnez **Quick Update** pour restaurer les valeurs par défaut
-
-## Personnalisation des workflows
-
-La personnalisation des workflows et skills existants de la méthode BMad arrive bientôt.
-
-## Personnalisation des modules
-
-Les conseils sur la création de modules d'extension et la personnalisation des modules existants arrivent bientôt.
-
-## Glossaire
-
-[^1]: Persona : définition de la personnalité, du rôle et du style de communication d'un agent IA. Permet d'adapter le comportement et les réponses de l'agent selon les besoins du projet.

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

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

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

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

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

@@ -1,116 +0,0 @@
----
-title: "Comment installer BMad"
-description: Guide étape par étape pour installer BMad dans votre projet
-sidebar:
-  order: 1
----
-
-Utilisez la commande `npx bmad-method install` pour configurer BMad dans votre projet avec votre choix de modules et d'outils d'IA.
-
-Si vous souhaitez utiliser un installateur non interactif et fournir toutes les options d'installation en ligne de commande, consultez [ce guide](./non-interactive-installation.md).
-
-## Quand l'utiliser
-
-- Démarrer un nouveau projet avec BMad
-- Ajouter BMad à une base de code existante
-- Mettre à jour une installation BMad existante
-
-:::note[Prérequis]
-- **Node.js** 20+ (requis pour l'installateur)
-- **Git** (recommandé)
-- **Outil d'IA** (Claude Code, Cursor, ou similaire)
-:::
-
-## Étapes
-
-### 1. Lancer l'installateur
-
-```bash
-npx bmad-method install
-```
-
-:::tip[Vous voulez la dernière version préliminaire ?]
-Utilisez le dist-tag `next` :
-```bash
-npx bmad-method@next install
-```
-
-Cela vous permet d'obtenir les nouvelles modifications plus tôt, avec un risque plus élevé de changements que l'installation par défaut.
-:::
-
-:::tip[Version de développement]
-Pour installer la dernière version depuis la branche main (peut être instable) :
-```bash
-npx github:bmad-code-org/BMAD-METHOD install
-```
-:::
-
-### 2. Choisir l'emplacement d'installation
-
-L'installateur vous demandera où installer les fichiers BMad :
-
-- Répertoire courant (recommandé pour les nouveaux projets si vous avez créé le répertoire vous-même et l'exécutez depuis ce répertoire)
-- Chemin personnalisé
-
-### 3. Sélectionner vos outils d'IA
-
-Choisissez les outils d'IA que vous utilisez :
-
-- Claude Code
-- Cursor
-- Autres
-
-Chaque outil a sa propre façon d'intégrer les skills. L'installateur crée de petits fichiers de prompt pour activer les workflows et les agents — il les place simplement là où votre outil s'attend à les trouver.
-
-:::note[Activer les skills]
-Certaines plateformes nécessitent que les skills soient explicitement activés dans les paramètres avant d'apparaître. Si vous installez BMad et ne voyez pas les skills, vérifiez les paramètres de votre plateforme ou demandez à votre assistant IA comment activer les skills.
-:::
-
-### 4. Choisir les modules
-
-L'installateur affiche les modules disponibles. Sélectionnez ceux dont vous avez besoin — la plupart des utilisateurs veulent simplement **méthode BMad** (le module de développement logiciel).
-
-### 5. Suivre les instructions
-
-L'installateur vous guide pour le reste — paramètres, intégrations d'outils, etc.
-
-## Ce que vous obtenez
-
-```text
-votre-projet/
-├── _bmad/
-│   ├── bmm/            # Vos modules sélectionnés
-│   │   └── config.yaml # Paramètres du module (si vous devez les modifier)
-│   ├── core/           # Module core requis
-│   └── ...
-├── _bmad-output/       # Artefacts générés
-├── .claude/            # Skills Claude Code (si vous utilisez Claude Code)
-│   └── skills/
-│       ├── bmad-help/
-│       ├── bmad-persona/
-│       └── ...
-└── .cursor/            # Skills Cursor (si vous utilisez Cursor)
-    └── skills/
-        └── ...
-```
-
-## Vérifier l'installation
-
-Exécutez `bmad-help` pour vérifier que tout fonctionne et voir quoi faire ensuite.
-
-**BMad-Help est votre guide intelligent** qui va :
-- Confirmer que votre installation fonctionne
-- Afficher ce qui est disponible en fonction de vos modules installés
-- Recommander votre première étape
-
-Vous pouvez aussi lui poser des questions :
-```
-bmad-help Je viens d'installer, que dois-je faire en premier ?
-bmad-help Quelles sont mes options pour un projet SaaS ?
-```
-
-## Résolution de problèmes
-
-**L'installateur affiche une erreur** — Copiez-collez la sortie dans votre assistant IA et laissez-le résoudre le problème.
-
-**L'installateur a fonctionné mais quelque chose ne fonctionne pas plus tard** — Votre IA a besoin du contexte BMad pour vous aider. Consultez [Comment obtenir des réponses à propos de BMad](./get-answers-about-bmad.md) pour savoir comment diriger votre IA vers les bonnes sources.

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

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

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

@@ -1,127 +0,0 @@
----
-title: "Gérer le contexte du projet"
-description: Créer et maintenir project-context.md pour guider les agents IA
-sidebar:
-  order: 8
----
-
-Utilisez le fichier `project-context.md` pour garantir que les agents IA respectent les préférences techniques et les règles d'implémentation de votre projet tout au long des workflows. Pour vous assurer qu'il est toujours disponible, vous pouvez également ajouter la ligne `Le contexte et les conventions importantes du projet se trouvent dans [chemin vers le contexte du projet]/project-context.md` à votre fichier de contexte ou de règles permanentes (comme `AGENTS.md`).
-
-:::note[Prérequis]
-- Méthode BMad installée
-- Connaissance de la pile technologique et des conventions de votre projet
-:::
-
-## Quand utiliser cette fonctionnalité
-
-- Vous avez des préférences techniques fortes avant de commencer l'architecture
-- Vous avez terminé l'architecture et souhaitez consigner les décisions pour l'implémentation
-- Vous travaillez sur une base de code existante avec des patterns établis
-- Vous remarquez que les agents prennent des décisions incohérentes entre les stories
-
-## Étape 1 : Choisissez votre approche
-
-**Création manuelle** — Idéal lorsque vous savez exactement quelles règles vous souhaitez documenter
-
-**Génération après l'architecture** — Idéal pour capturer les décisions prises lors du solutioning
-
-**Génération pour les projets existants** — Idéal pour découvrir les patterns dans les bases de code existantes
-
-## Étape 2 : Créez le fichier
-
-### Option A : Création manuelle
-
-Créez le fichier à l'emplacement `_bmad-output/project-context.md` :
-
-```bash
-mkdir -p _bmad-output
-touch _bmad-output/project-context.md
-```
-
-Ajoutez votre pile technologique et vos règles d'implémentation :
-
-```markdown
----
-project_name: 'MonProjet'
-user_name: 'VotreNom'
-date: '2026-02-15'
-sections_completed: ['technology_stack', 'critical_rules']
----
-
-# Contexte de Projet pour Agents IA
-
-## Pile Technologique & Versions
-
-- Node.js 20.x, TypeScript 5.3, React 18.2
-- State : Zustand
-- Tests : Vitest, Playwright
-- Styles : Tailwind CSS
-
-## Règles d'Implémentation Critiques
-
-**TypeScript :**
-- Mode strict activé, pas de types `any`
-- Utiliser `interface` pour les API publiques, `type` pour les unions
-
-**Organisation du Code :**
-- Composants dans `/src/components/` avec tests co-localisés
-- Les appels API utilisent le singleton `apiClient` — jamais de fetch direct
-
-**Tests :**
-- Tests unitaires axés sur la logique métier
-- Tests d'intégration utilisent MSW pour le mock API
-```
-
-### Option B : Génération après l'architecture
-
-Exécutez le workflow dans une nouvelle conversation :
-
-```bash
-bmad-generate-project-context
-```
-
-Le workflow analyse votre document d'architecture et vos fichiers projet pour générer un fichier de contexte qui capture les décisions prises.
-
-### Option C : Génération pour les projets existants
-
-Pour les projets existants, exécutez :
-
-```bash
-bmad-generate-project-context
-```
-
-Le workflow analyse votre base de code pour identifier les conventions, puis génère un fichier de contexte que vous pouvez réviser et affiner.
-
-## Étape 3 : Vérifiez le contenu
-
-Révisez le fichier généré et assurez-vous qu'il capture :
-
-- Les versions correctes des technologies
-- Vos conventions réelles (pas les bonnes pratiques génériques)
-- Les règles qui évitent les erreurs courantes
-- Les patterns spécifiques aux frameworks
-
-Modifiez manuellement pour ajouter les éléments manquants ou supprimer les inexactitudes.
-
-## Ce que vous obtenez
-
-Un fichier `project-context.md` qui :
-
-- Garantit que tous les agents suivent les mêmes conventions
-- Évite les décisions incohérentes entre les stories
-- Capture les décisions d'architecture pour l'implémentation
-- Sert de référence pour les patterns et règles de votre projet
-
-## Conseils
-
-:::tip[Bonnes pratiques]
-- **Concentrez-vous sur ce qui n'est pas évident** — Documentez les patterns que les agents pourraient manquer (par ex. « Utiliser JSDoc sur chaque classe publique »), et non les pratiques universelles comme « utiliser des noms de variables significatifs ».
-- **Gardez-le concis** — Ce fichier est chargé par chaque workflow d'implémentation. Les fichiers longs gaspillent le contexte. Excluez le contenu qui ne s'applique qu'à un périmètre restreint ou à des stories spécifiques.
-- **Mettez à jour si nécessaire** — Modifiez manuellement lorsque les patterns changent, ou régénérez après des changements d'architecture significatifs.
-- Fonctionne aussi bien pour Quick Dev que pour les projets complets méthode BMad.
-:::
-
-## Prochaines étapes
-
-- [**Explication du contexte projet**](../explanation/project-context.md) — En savoir plus sur son fonctionnement
-- [**Carte des workflows**](../reference/workflow-map.md) — Voir quels workflows chargent le contexte projet

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

@@ -1,98 +0,0 @@
----
-title: "Corrections Rapides"
-description: Comment effectuer des corrections rapides et des modifications ciblées
-sidebar:
-  order: 5
----
-
-Utilisez **Quick Dev** pour les corrections de bugs, les refactorisations ou les petites modifications ciblées qui ne nécessitent pas la méthode BMad complète.
-
-## Quand Utiliser Cette Approche
-
-- Corrections de bugs avec une cause claire et connue
-- Petites refactorisations (renommage, extraction, restructuration) contenues dans quelques fichiers
-- Ajustements mineurs de fonctionnalités ou modifications de configuration
-- Mises à jour de dépendances
-
-:::note[Prérequis]
-- Méthode BMad installée (`npx bmad-method install`)
-- Un IDE IA (Claude Code, Cursor, ou similaire)
-:::
-
-## Étapes
-
-### 1. Démarrer une Nouvelle Conversation
-
-Ouvrez une **nouvelle conversation** dans votre IDE IA. Réutiliser une session d'un workflow précédent peut causer des conflits de contexte.
-
-### 2. Spécifiez Votre Intention
-
-Quick Dev accepte l'intention en forme libre — avant, avec, ou après l'invocation. Exemples :
-
-```text
-quick-dev — Corrige le bug de validation de connexion qui permet les mots de passe vides.
-```
-
-```text
-quick-dev — corrige https://github.com/org/repo/issues/42
-```
-
-```text
-quick-dev — implémente _bmad-output/implementation-artifacts/my-intent.md
-```
-
-```text
-Je pense que le problème est dans le middleware d'auth, il ne vérifie pas l'expiration du token.
-Regardons... oui, src/auth/middleware.ts ligne 47 saute complètement la vérification exp. lance quick-dev
-```
-
-```text
-quick-dev
-> Que voulez-vous faire ?
-Refactoriser UserService pour utiliser async/await au lieu des callbacks.
-```
-
-Texte brut, chemins de fichiers, URLs d'issues GitHub, liens de trackers de bugs — tout ce que le LLM peut résoudre en une intention concrète.
-
-### 3. Répondre aux Questions et Approuver
-
-Quick Dev peut poser des questions de clarification ou présenter une courte spécification demandant votre approbation avant l'implémentation. Répondez à ses questions et approuvez lorsque vous êtes satisfait du plan.
-
-### 4. Réviser et Pousser
-
-Quick Dev implémente la modification, révise son propre travail, corrige les problèmes et effectue un commit local. Lorsqu'il a terminé, il ouvre les fichiers affectés dans votre éditeur.
-
-- Parcourez le diff pour confirmer que la modification correspond à votre intention
-- Si quelque chose semble incorrect, dites à l'agent ce qu'il faut corriger — il peut itérer dans la même session
-
-Une fois satisfait, poussez le commit. Quick Dev vous proposera de pousser et de créer une PR pour vous.
-
-:::caution[Si Quelque Chose Casse]
-Si une modification poussée cause des problèmes inattendus, utilisez `git revert HEAD` pour annuler proprement le dernier commit. Ensuite, démarrez une nouvelle conversation et exécutez Quick Dev à nouveau pour essayer une approche différente.
-:::
-
-## Ce Que Vous Obtenez
-
-- Fichiers source modifiés avec la correction ou refactorisation appliquée
-- Tests passants (si votre projet a une suite de tests)
-- Un commit prêt à pousser avec un message de commit conventionnel
-
-## Travail Différé
-
-Quick Dev garde chaque exécution concentrée sur un seul objectif. Si votre demande contient plusieurs objectifs indépendants, ou si la revue remonte des problèmes préexistants non liés à votre modification, Quick Dev les diffère vers un fichier (`deferred-work.md` dans votre répertoire d'artefacts d'implémentation) plutôt que d'essayer de tout régler en même temps.
-
-Consultez ce fichier après une exécution — c'est votre backlog[^1] de choses sur lesquelles revenir. Chaque élément différé peut être introduit dans une nouvelle exécution Quick Dev ultérieurement.
-
-## Quand Passer à une Planification Formelle
-
-Envisagez d'utiliser la méthode BMad complète lorsque :
-
-- La modification affecte plusieurs systèmes ou nécessite des mises à jour coordonnées dans de nombreux fichiers
-- Vous n'êtes pas sûr de la portée et avez besoin d'une découverte des exigences d'abord
-- Vous avez besoin de documentation ou de décisions architecturales enregistrées pour l'équipe
-
-Voir [Quick Dev](../explanation/quick-dev.md) pour plus d'informations sur la façon dont Quick Dev s'intègre dans la méthode BMad.
-
-## Glossaire
-
-[^1]: Backlog : liste priorisée de tâches ou d'éléments de travail à traiter ultérieurement, issue des méthodologies agiles.

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

@@ -1,78 +0,0 @@
----
-title: "Guide de Division de Documents"
-description: Diviser les fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte
-sidebar:
-  order: 9
----
-
-Utilisez l'outil `bmad-shard-doc` si vous avez besoin de diviser des fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte.
-
-:::caution[Déprécié]
-Ceci n'est plus recommandé, et bientôt avec les workflows mis à jour et la plupart des LLM et outils majeurs supportant les sous-processus, cela deviendra inutile.
-:::
-
-## Quand l’Utiliser
-
-Utilisez ceci uniquement si vous remarquez que votre combinaison outil / modèle ne parvient pas à charger et lire tous les documents en entrée lorsque c'est nécessaire.
-
-## Qu'est-ce que la Division de Documents ?
-
-La division de documents divise les fichiers markdown volumineux en fichiers plus petits et organisés basés sur les titres de niveau 2 (`## Titre`).
-
-### Architecture
-
-```text
-Avant Division :
-_bmad-output/planning-artifacts/
-└── PRD.md (fichier volumineux de 50k tokens)
-
-Après Division :
-_bmad-output/planning-artifacts/
-└── prd/
-    ├── index.md                    # Table des matières avec descriptions
-    ├── overview.md                 # Section 1
-    ├── user-requirements.md        # Section 2
-    ├── technical-requirements.md   # Section 3
-    └── ...                         # Sections supplémentaires
-```
-
-## Étapes
-
-### 1. Exécuter l'Outil Shard-Doc
-
-```bash
-/bmad-shard-doc
-```
-
-### 2. Suivre le Processus Interactif
-
-```text
-Agent : Quel document souhaitez-vous diviser ?
-Utilisateur : docs/PRD.md
-
-Agent : Destination par défaut : docs/prd/
-        Accepter la valeur par défaut ? [y/n]
-Utilisateur : y
-
-Agent : Division de PRD.md...
-        ✓ 12 fichiers de section créés
-        ✓ index.md généré
-        ✓ Terminé !
-```
-
-## Comment Fonctionne la Découverte de Workflow
-
-Les workflows BMad utilisent un **système de découverte double** :
-
-1. **Essaye d'abord le document entier** - Rechercher `document-name.md`
-2. **Vérifie la version divisée** - Rechercher `document-name/index.md`
-3. **Règle de priorité** - Le document entier a la priorité si les deux existent - supprimez le document entier si vous souhaitez que la version divisée soit utilisée à la place
-
-## Support des Workflows
-
-Tous les workflows BMM prennent en charge les deux formats :
-
-- Documents entiers
-- Documents divisés
-- Détection automatique
-- Transparent pour l'utilisateur

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

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

docs/fr/index.md

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