bmad-fh 6.0.0-alpha.23

package/docs/explanation/architecture/why-solutioning-matters.md

@@ -0,0 +1,75 @@
+---
+title: "Why Solutioning Matters"
+description: Understanding why the solutioning phase is critical for multi-epic projects
+---
+
+
+Phase 3 (Solutioning) translates **what** to build (from Planning) into **how** to build it (technical design). This phase prevents agent conflicts in multi-epic projects by documenting architectural decisions before implementation begins.
+
+## The Problem Without Solutioning
+
+```
+Agent 1 implements Epic 1 using REST API
+Agent 2 implements Epic 2 using GraphQL
+Result: Inconsistent API design, integration nightmare
+```
+
+When multiple agents implement different parts of a system without shared architectural guidance, they make independent technical decisions that may conflict.
+
+## The Solution With Solutioning
+
+```
+architecture workflow decides: "Use GraphQL for all APIs"
+All agents follow architecture decisions
+Result: Consistent implementation, no conflicts
+```
+
+By documenting technical decisions explicitly, all agents implement consistently and integration becomes straightforward.
+
+## Solutioning vs Planning
+
+| Aspect   | Planning (Phase 2)      | Solutioning (Phase 3)             |
+| -------- | ----------------------- | --------------------------------- |
+| Question | What and Why?           | How? Then What units of work?     |
+| Output   | FRs/NFRs (Requirements) | Architecture + Epics/Stories      |
+| Agent    | PM                      | Architect → PM                    |
+| Audience | Stakeholders            | Developers                        |
+| Document | PRD (FRs/NFRs)          | Architecture + Epic Files         |
+| Level    | Business logic          | Technical design + Work breakdown |
+
+## Key Principle
+
+**Make technical decisions explicit and documented** so all agents implement consistently.
+
+This prevents:
+- API style conflicts (REST vs GraphQL)
+- Database design inconsistencies
+- State management disagreements
+- Naming convention mismatches
+- Security approach variations
+
+## When Solutioning is Required
+
+| Track | Solutioning Required? |
+|-------|----------------------|
+| Quick Flow | No - skip entirely |
+| BMad Method Simple | Optional |
+| BMad Method Complex | Yes |
+| Enterprise | Yes |
+
+:::tip[Rule of Thumb]
+If you have multiple epics that could be implemented by different agents, you need solutioning.
+:::
+
+## The Cost of Skipping
+
+Skipping solutioning on complex projects leads to:
+
+- **Integration issues** discovered mid-sprint
+- **Rework** due to conflicting implementations
+- **Longer development time** overall
+- **Technical debt** from inconsistent patterns
+
+:::caution[Cost Multiplier]
+Catching alignment issues in solutioning is 10× faster than discovering them during implementation.
+:::

package/docs/explanation/bmm/index.md

@@ -0,0 +1,131 @@
+---
+title: "BMM Documentation"
+---
+
+Complete guides for the BMad Method Module (BMM) — AI-powered agile development workflows that adapt to your project's complexity.
+
+## Getting Started
+
+:::tip[Quick Path]
+Install → workflow-init → Follow agent guidance
+:::
+
+**New to BMM?** Start here:
+
+| Resource | Description |
+|----------|-------------|
+| **[Quick Start Guide](/docs/tutorials/getting-started/getting-started-bmadv6.md)** | Step-by-step guide to building your first project |
+| **[Complete Workflow Diagram](../../tutorials/getting-started/images/workflow-method-greenfield.svg)** | Visual flowchart showing all phases, agents, and decision points |
+
+## Core Concepts
+
+The BMad Method is meant to be adapted and customized to your specific needs. In this realm there is no one size fits all - your needs are unique, and BMad Method is meant to support this (and if it does not, can be further customized or extended with new modules).
+
+First know there is the full BMad Method Process and then there is a Quick Flow for those quicker smaller efforts.
+
+- **[Full Adaptive BMad Method](#workflow-guides)** - Full planning and scope support through extensive development and testing.
+  - Broken down into 4 phases, all of which are comprised of both required and optional phases
+    - Phases 1-3 are all about progressive idea development through planning and preparations to build your project.
+    - Phase 4 is the implementation cycle where you will Just In Time (JIT) produce the contextual stories needed for the dev agent based on the extensive planning completed
+    - All 4 phases have optional steps in them, depending on how rigorous you want to go with planning, research ideation, validation, testing and traceability.
+  - While there is a lot here, know that even this can be distilled down to a simple PRD, Epic and Story list and then jump into the dev cycle. But if that is all you want, you might be better off with the BMad Quick Flow described next
+
+- **[BMad Quick Flow](/docs/explanation/features/quick-flow.md)** - Fast-track development workflow
+  - 3-step process: spec → dev → optional review
+  - Perfect for bug fixes and small features
+  - Rapid prototyping with production quality
+  - Implementation in minutes, not days
+  - Has a specialized single agent that does all of this: **[Quick Flow Solo Dev Agent](/docs/explanation/agents/barry-quick-flow.md)**
+
+- **TEA engagement (optional)** - Choose TEA engagement: none, TEA-only (standalone), or integrated by track. See **[Test Architect Guide](/docs/explanation/features/tea-overview.md)**.
+
+## Agents and Collaboration
+
+Complete guide to BMM's AI agent team:
+
+- **[Agents Guide](/docs/explanation/core-concepts/agent-roles.md)** - Comprehensive agent reference
+  - 12 specialized BMM agents + BMad Master
+  - Agent roles, workflows, and when to use them
+  - Agent customization system
+  - Best practices and common patterns
+
+- **[Party Mode Guide](/docs/explanation/features/party-mode.md)** - Multi-agent collaboration
+  - How party mode works (19+ agents collaborate in real-time)
+  - When to use it (strategic, creative, cross-functional, complex)
+  - Example party compositions
+  - Multi-module integration (BMM + CIS + BMB + custom)
+  - Agent customization in party mode
+  - Best practices
+
+## Working with Existing Code
+
+Comprehensive guide for brownfield development:
+
+- **[Brownfield Development Guide](/docs/how-to/brownfield/index.md)** - Complete guide for existing codebases
+  - Documentation phase strategies
+  - Track selection for brownfield
+  - Integration with existing patterns
+  - Phase-by-phase workflow guidance
+  - Common scenarios
+
+## Quick References
+
+Essential reference materials:
+
+- **[Glossary](/docs/reference/glossary/index.md)** - Key terminology and concepts
+- **[FAQ](/docs/explanation/faq/index.md)** - Frequently asked questions across all topics
+
+## Choose Your Path
+
+### I need to...
+
+**Build something new (greenfield)**
+→ Start with [Quick Start Guide](/docs/tutorials/getting-started/getting-started-bmadv6.md)
+
+**Fix a bug or add small feature**
+→ Use the [Quick Flow Solo Dev](/docs/explanation/agents/barry-quick-flow.md) directly with its dedicated stand alone [Quick Bmad Spec Flow](/docs/explanation/features/quick-flow.md) process
+
+**Work with existing codebase (brownfield)**
+→ Read [Brownfield Development Guide](/docs/how-to/brownfield/index.md)
+→ Pay special attention to documentation requirements for brownfield projects
+
+## Workflow Guides
+
+Comprehensive documentation for all BMM workflows organized by phase:
+
+- **[Phase 1: Analysis Workflows](/docs/how-to/workflows/run-brainstorming-session.md)** - Optional exploration and research workflows (595 lines)
+  - brainstorm-project, product-brief, research, and more
+  - When to use analysis workflows
+  - Creative and strategic tools
+
+- **[Phase 2: Planning Workflows](/docs/how-to/workflows/create-prd.md)** - Scale-adaptive planning (967 lines)
+  - prd, tech-spec, gdd, narrative, ux
+  - Track-based planning approach (Quick Flow, BMad Method, Enterprise Method)
+  - Which planning workflow to use
+
+- **[Phase 3: Solutioning Workflows](/docs/how-to/workflows/create-architecture.md)** - Architecture and validation (638 lines)
+  - architecture, create-epics-and-stories, implementation-readiness
+  - V6: Epics created AFTER architecture for better quality
+  - Required for BMad Method and Enterprise Method tracks
+  - Preventing agent conflicts
+
+- **[Phase 4: Implementation Workflows](/docs/how-to/workflows/run-sprint-planning.md)** - Sprint-based development (1,634 lines)
+  - sprint-planning, create-story, dev-story, code-review
+  - Complete story lifecycle
+  - One-story-at-a-time discipline
+
+- **[Testing & QA Workflows](/docs/explanation/features/tea-overview.md)** - Comprehensive quality assurance (1,420 lines)
+  - Test strategy, automation, quality gates
+  - TEA agent and test healing
+
+## External Resources
+
+### Community and Support
+
+- **[Discord Community](https://discord.gg/gk8jAdXWmj)** - Get help from the community (#bmad-method-help, #report-bugs-and-issues)
+- **[GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)** - Report bugs or request features
+- **[YouTube Channel](https://www.youtube.com/@BMadCode)** - Video tutorials and walkthroughs
+
+:::tip[Ready to Begin?]
+[Start with the Quick Start Guide](/docs/tutorials/getting-started/getting-started-bmadv6.md)
+:::

package/docs/explanation/core/index.md

@@ -0,0 +1,18 @@
+---
+title: "Core Module"
+---
+
+
+The Core Module is installed with all installations of BMad modules and provides common functionality that any module, workflow, or agent can take advantage of.
+
+## Core Module Components
+
+- **[Global Core Config](/docs/reference/configuration/global-config.md)** — Inheritable configuration that impacts all modules and custom content
+- **[Core Workflows](/docs/reference/workflows/core-workflows.md)** — Domain-agnostic workflows usable by any module
+  - [Party Mode](/docs/explanation/features/party-mode.md) — Multi-agent conversation orchestration
+  - [Brainstorming](/docs/explanation/features/brainstorming-techniques.md) — Structured creative sessions with 60+ techniques
+  - [Advanced Elicitation](/docs/explanation/features/advanced-elicitation.md) — LLM rethinking with 50+ reasoning methods
+- **[Core Tasks](/docs/reference/configuration/core-tasks.md)** — Common tasks available across modules
+  - [Index Docs](/docs/reference/configuration/core-tasks.md#index-docs) — Generate directory index files
+  - [Adversarial Review](/docs/reference/configuration/core-tasks.md#adversarial-review) — Critical content review
+  - [Shard Document](/docs/reference/configuration/core-tasks.md#shard-document) — Split large documents into sections

package/docs/explanation/core-concepts/agent-roles.md

@@ -0,0 +1,179 @@
+---
+title: "Agent Roles in BMad Method"
+description: Understanding the different agent roles in BMad Method
+---
+
+BMad Method uses specialized AI agents, each with a distinct role, expertise, and personality. Understanding these roles helps you know which agent to use for each task.
+
+## Core Agents Overview
+
+| Agent | Role | Primary Phase |
+|-------|------|---------------|
+| **Analyst** | Research and discovery | Phase 1 (Analysis) |
+| **PM** | Requirements and planning | Phase 2 (Planning) |
+| **Architect** | Technical design | Phase 3 (Solutioning) |
+| **SM** | Sprint orchestration | Phase 4 (Implementation) |
+| **DEV** | Code implementation | Phase 4 (Implementation) |
+| **TEA** | Test architecture | Phases 3-4 (Cross-phase) |
+| **UX Designer** | User experience | Phase 2-3 |
+| **Quick Flow Solo Dev** | Fast solo development | All phases (Quick Flow) |
+
+## Phase 1: Analysis
+
+### Analyst (Mary)
+
+Business analysis and research specialist.
+
+**Responsibilities:**
+- Brainstorming and ideation
+- Market, domain, and competitive research
+- Product brief creation
+- Brownfield project documentation
+
+**Key Workflows:**
+- `*brainstorm-project`
+- `*research`
+- `*product-brief`
+- `*document-project`
+
+**When to use:** Starting new projects, exploring ideas, validating market fit, documenting existing codebases.
+
+## Phase 2: Planning
+
+### PM (John)
+
+Product requirements and planning expert.
+
+**Responsibilities:**
+- Creating Product Requirements Documents
+- Defining functional and non-functional requirements
+- Breaking requirements into epics and stories
+- Validating implementation readiness
+
+**Key Workflows:**
+- `*create-prd`
+- `*create-epics-and-stories`
+- `*implementation-readiness`
+
+**When to use:** Defining what to build, creating PRDs, organizing work into stories.
+
+### UX Designer (Sally)
+
+User experience and UI design specialist.
+
+**Responsibilities:**
+- UX specification creation
+- User journey mapping
+- Wireframe and mockup design
+- Design system documentation
+
+**Key Workflows:**
+- `*create-ux-design`
+- `*validate-design`
+
+**When to use:** When UX is a primary differentiator, complex user workflows, design system creation.
+
+## Phase 3: Solutioning
+
+### Architect (Winston)
+
+System architecture and technical design expert.
+
+**Responsibilities:**
+- System architecture design
+- Architecture Decision Records (ADRs)
+- Technical standards definition
+- Implementation readiness validation
+
+**Key Workflows:**
+- `*create-architecture`
+- `*implementation-readiness`
+
+**When to use:** Multi-epic projects, cross-cutting technical decisions, preventing agent conflicts.
+
+## Phase 4: Implementation
+
+### SM (Bob)
+
+Sprint planning and story preparation orchestrator.
+
+**Responsibilities:**
+- Sprint planning and tracking
+- Story preparation for development
+- Course correction handling
+- Epic retrospectives
+
+**Key Workflows:**
+- `*sprint-planning`
+- `*create-story`
+- `*correct-course`
+- `*epic-retrospective`
+
+**When to use:** Organizing work, preparing stories, tracking progress.
+
+### DEV (Amelia)
+
+Story implementation and code review specialist.
+
+**Responsibilities:**
+- Story implementation with tests
+- Code review
+- Following architecture patterns
+- Quality assurance
+
+**Key Workflows:**
+- `*dev-story`
+- `*code-review`
+
+**When to use:** Writing code, implementing stories, reviewing quality.
+
+## Cross-Phase Agents
+
+### TEA (Murat)
+
+Test architecture and quality strategy expert.
+
+**Responsibilities:**
+- Test framework setup
+- Test design and planning
+- ATDD and automation
+- Quality gate decisions
+
+**Key Workflows:**
+- `*framework`, `*ci`
+- `*test-design`, `*atdd`, `*automate`
+- `*test-review`, `*trace`, `*nfr-assess`
+
+**When to use:** Setting up testing, creating test plans, quality gates.
+
+## Quick Flow
+
+### Quick Flow Solo Dev (Barry)
+
+Fast solo development without handoffs.
+
+**Responsibilities:**
+- Technical specification
+- End-to-end implementation
+- Code review
+
+**Key Workflows:**
+- `*quick-spec`
+- `*quick-dev`
+- `*code-review`
+
+**When to use:** Bug fixes, small features, rapid prototyping.
+
+## Choosing the Right Agent
+
+| Task | Agent |
+|------|-------|
+| Brainstorming ideas | Analyst |
+| Market research | Analyst |
+| Creating PRD | PM |
+| Designing UX | UX Designer |
+| System architecture | Architect |
+| Preparing stories | SM |
+| Writing code | DEV |
+| Setting up tests | TEA |
+| Quick bug fix | Quick Flow Solo Dev |

package/docs/explanation/core-concepts/index.md

@@ -0,0 +1,35 @@
+---
+title: "BMad Core Concepts"
+---
+
+Understanding the fundamental building blocks of the BMad Method.
+
+## The Essentials
+
+| Concept | Description | Guide |
+|---------|-------------|-------|
+| **Agents** | AI assistants with personas, capabilities, and menus | [Agents Guide](/docs/explanation/core-concepts/what-are-agents.md) |
+| **Workflows** | Structured processes for achieving specific outcomes | [Workflows Guide](/docs/explanation/core-concepts/what-are-workflows.md) |
+| **Modules** | Packaged collections of agents and workflows | [Modules Guide](/docs/explanation/core-concepts/what-are-modules.md) |
+
+## Getting Started
+
+### New to BMad?
+Start here to understand what BMad is and how it works:
+
+1. **[Agents Guide](/docs/explanation/core-concepts/what-are-agents.md)** - Learn about Simple and Expert agents
+2. **[Workflows Guide](/docs/explanation/core-concepts/what-are-workflows.md)** - Understand how workflows orchestrate tasks
+3. **[Modules Guide](/docs/explanation/core-concepts/what-are-modules.md)** - See how modules organize functionality
+
+### Installing BMad
+
+- **[Installation Guide](/docs/how-to/installation/index.md)** - Set up BMad in your project
+- **[Upgrading from v4](/docs/how-to/installation/upgrade-to-v6.md)** - Migrate from earlier versions
+
+### Configuration
+
+- **[BMad Customization](/docs/how-to/customization/index.md)** - Personalize agents and workflows
+
+### Advanced
+
+- **[Web Bundles](/docs/explanation/features/web-bundles.md)** - Use BMad in Gemini Gems and Custom GPTs

package/docs/explanation/core-concepts/what-are-agents.md

@@ -0,0 +1,97 @@
+---
+title: "Agents"
+---
+
+Agents are AI assistants that help you accomplish tasks. Each agent has a unique personality, specialized capabilities, and an interactive menu.
+
+## Agent Types
+
+BMad has two primary agent types, designed for different use cases:
+
+### Simple Agents
+
+**Self-contained, focused, ready to use.**
+
+Simple agents are complete in a single file. They excel at well-defined tasks and require minimal setup.
+
+**Best for:**
+- Single-purpose assistants (code review, documentation, commit messages)
+- Quick deployment
+- Projects that don't require persistent memory
+- Getting started fast
+
+**Example:** A commit message agent that reads your git diff and generates conventional commits.
+
+### Expert Agents
+
+**Powerful, memory-equipped, domain specialists.**
+
+Expert agents have a **sidecar** - a companion folder containing additional instructions, workflows, and memory files. They remember context across sessions and handle complex, multi-step tasks.
+
+**Best for:**
+- Domain specialists (security architect, game designer, product manager)
+- Tasks requiring persistent memory
+- Complex workflows with multiple stages
+- Projects that grow over time
+
+**Example:** A game architect that remembers your design decisions, maintains consistency across sprints, and coordinates with other specialists.
+
+## Key Differences
+
+| Feature          | Simple         | Expert                     |
+| ---------------- | -------------- | -------------------------- |
+| **Files**        | Single file    | Agent + sidecar folder     |
+| **Memory**       | Session only   | Persistent across sessions |
+| **Capabilities** | Focused scope  | Multi-domain, extensible   |
+| **Setup**        | Zero config    | Sidecar initialization     |
+| **Best Use**     | Specific tasks | Ongoing projects           |
+
+## Agent Components
+
+All agents share these building blocks:
+
+### Persona
+- **Role** - What the agent does (expertise domain)
+- **Identity** - Who the agent is (personality, character)
+- **Communication Style** - How the agent speaks (tone, voice)
+- **Principles** - Why the agent acts (values, decision framework)
+
+### Capabilities
+- Skills, tools, and knowledge the agent can apply
+- Mapped to specific menu commands
+
+### Menu
+- Interactive command list
+- Triggers, descriptions, and handlers
+- Auto-includes help and exit options
+
+### Critical Actions (optional)
+- Instructions that execute before the agent starts
+- Enable autonomous behaviors (e.g., "check git status before changes")
+
+## Which Should You Use?
+
+:::tip[Quick Decision]
+Choose **Simple** for focused, one-off tasks with no memory needs. Choose **Expert** when you need persistent context and complex workflows.
+:::
+
+**Choose Simple when:**
+- You need a task done quickly and reliably
+- The scope is well-defined and won't change much
+- You don't need the agent to remember things between sessions
+
+**Choose Expert when:**
+- You're building something complex over time
+- The agent needs to maintain context (project history, decisions)
+- You want the agent to coordinate workflows or other agents
+- Domain expertise requires specialized knowledge bases
+
+## Creating Custom Agents
+
+BMad provides the **BMad Builder (BMB)** module for creating your own agents. See the [Agent Creation Guide](https://github.com/bmad-code-org/bmad-builder/blob/main/docs/tutorials/create-custom-agent.md) for step-by-step instructions.
+
+
+
+## Customizing Existing Agents
+
+You can modify any agent's behavior without editing core files. See [BMad Customization](/docs/how-to/customization/index.md) for details. It is critical to never modify an installed agents .md file directly and follow the customization process, this way future updates to the agent or module its part of will continue to be updated and recompiled with the installer tool, and your customizations will still be retained.

package/docs/explanation/core-concepts/what-are-modules.md

@@ -0,0 +1,85 @@
+---
+title: "Modules"
+---
+
+Modules are organized collections of agents and workflows that solve specific problems or address particular domains.
+
+## What is a Module?
+
+A module is a self-contained package that includes:
+
+- **Agents** - Specialized AI assistants
+- **Workflows** - Step-by-step processes
+- **Configuration** - Module-specific settings
+- **Documentation** - Usage guides and reference
+
+## Official BMad Method and Builder Modules
+
+:::note[Core is Always Installed]
+The Core module is automatically included with every BMad installation. It provides the foundation that other modules build upon.
+:::
+
+### Core Module
+Always installed, provides shared functionality:
+- Global configuration
+- Core workflows (Party Mode, Advanced Elicitation, Brainstorming)
+- Common tasks (document indexing, sharding, review)
+
+### BMad Method (BMM)
+Software and game development:
+- Project planning workflows
+- Implementation agents (Dev, PM, QA, Scrum Master)
+- Testing and architecture guidance
+
+### BMad Builder (BMB)
+Create custom solutions:
+- Agent creation workflows
+- Workflow authoring tools
+- Module scaffolding
+
+## Additional Official BMad Modules
+
+These are officially maintained modules by BMad but have their own repo's and docs.
+These give a good idea also of what can be done with the BMad builder and creating your own custom modules.
+
+### Creative Intelligence Suite (CIS)
+Innovation and creativity:
+- Creative thinking techniques
+- Innovation strategy workflows
+- Storytelling and ideation
+- [Available Here](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
+
+### BMad Game Dev (BMGD)
+Game development specialization:
+- Game design workflows
+- Narrative development
+- Performance testing frameworks
+- [Available Here](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
+
+## Module Structure
+
+Installed modules follow this structure:
+
+```
+_bmad/
+├── core/           # Always present
+├── bmm/            # BMad Method (if installed)
+├── bmb/            # BMad Builder (if installed)
+├── cis/            # Creative Intelligence (if installed)
+└── bmgd/           # Game Dev (if installed)
+```
+
+## Custom Modules
+
+You can create your own modules containing:
+- Custom agents for your domain
+- Organizational workflows
+- Team-specific configurations
+
+Custom modules are installed the same way as official modules.
+
+## Installing Modules
+
+During BMad installation, you choose which modules to install. You can also add or remove modules later by re-running the installer.
+
+See [Installation Guide](/docs/how-to/installation/index.md) for details.