bmad-method 6.0.0-alpha.20 → 6.0.0-alpha.22

package/{src/modules/bmm/docs → docs/modules/bmm-bmad-method}/quick-spec-flow.md

@@ -371,8 +371,6 @@ Checks:
 
 **Total time:** 1-3 hours (mostly implementation)
 
----
-
 ## Integration with Phase 4 Workflows
 
 Quick Spec Flow works seamlessly with all Phase 4 implementation workflows:
@@ -395,8 +393,6 @@ Quick Spec Flow works seamlessly with all Phase 4 implementation workflows:
 - ✅ Uses tech-spec.md as comprehensive context
 - ✅ Implements following detected conventions
 
----
-
 ## Comparison: Quick Spec vs Full BMM
 
 | Aspect                | Quick Flow Track             | BMad Method/Enterprise Tracks      |
@@ -411,7 +407,6 @@ Quick Spec Flow works seamlessly with all Phase 4 implementation workflows:
 | **Brownfield**        | Auto-analyzes and conforms   | Manual documentation required      |
 | **Conventions**       | Auto-detects and confirms    | Document in PRD/Architecture       |
 
----
 
 ## When to Graduate from Quick Flow to BMad Method
 
@@ -426,8 +421,6 @@ Start with Quick Flow, but switch to BMad Method when:
 
 💡 **Tip:** You can always run `workflow-init` later to transition from Quick Flow to BMad Method!
 
----
-
 ## Quick Spec Flow - Key Benefits
 
 ### 🚀 **Speed**
@@ -465,8 +458,6 @@ Start with Quick Flow, but switch to BMad Method when:
 - No scope creep
 - Fast iteration
 
----
-
 ## Getting Started
 
 ### Prerequisites
@@ -478,12 +469,12 @@ Start with Quick Flow, but switch to BMad Method when:
 
 ```bash
 # For a quick bug fix or small change:
-# 1. Load PM agent
+# 1. Load Quick Dev Solo agent
 # 2. Say: "I want to [describe your change]"
-# 3. PM will ask if you want to run tech-spec
+# 3. Agent will ask if you want to run tech-spec
 # 4. Answer questions about your change
 # 5. Get tech-spec + story
-# 6. Load DEV agent and implement!
+# 6. Reload a fresh context with the solo agent and implement!
 
 # For a small feature with multiple stories:
 # Same as above, but get epic + 2-3 stories
@@ -492,14 +483,7 @@ Start with Quick Flow, but switch to BMad Method when:
 
 ### No workflow-init Required!
 
-Quick Spec Flow is **fully standalone**:
-
-- Detects if it's a single change or multi-story feature
-- Asks for greenfield vs brownfield
-- Works without status file tracking
-- Perfect for rapid prototyping
-
----
+Quick Spec Flow is **fully standalone**
 
 ## FAQ
 

package/{src/modules/bmm/docs → docs/modules/bmm-bmad-method}/quick-start.md

@@ -43,10 +43,7 @@ The interactive installer will guide you through setup and create a `_bmad/` fol
 
 ### Step 1: Initialize Your Workflow
 
-1. **Load the Analyst agent** in your IDE - See your IDE-specific instructions in [docs/ide-info](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/docs/ide-info) for how to activate agents:
-   - [Claude Code](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/docs/ide-info/claude-code.md)
-   - [VS Code/Cursor/Windsurf](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/docs/ide-info) - Check your IDE folder
-   - Other IDEs also supported
+1. **Load the Analyst agent** in your IDE - Generally this is done by typing `/<workflow or agent name - allow autocomplete to find the right command>` - if you are unsure, you can just start with /bmad and see all that is available, sorted by agents and workflows.
 2. **Wait for the agent's menu** to appear
 3. **Tell the agent**: "Run workflow-init" or type "\*workflow-init" or select the menu item number
 
@@ -113,7 +110,7 @@ The next TRULY REQUIRED step is:
 
 When an agent tells you to run a workflow (like `prd`):
 
-1. **Start a new chat** with the specified agent (e.g., PM) - See [docs/ide-info](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/docs/ide-info) for your IDE's specific instructions
+1. **Start a new chat** with the specified agent
 2. **Wait for the menu** to appear
 3. **Tell the agent** to run it using any of these formats:
    - Type the shorthand: `*prd`

package/{src/modules/bmm/docs → docs/modules/bmm-bmad-method}/test-architecture.md

@@ -1,7 +1,3 @@
----
-last-redoc-date: 2025-11-05
----
-
 # Test Architect (TEA) Agent Guide
 
 ## Overview
@@ -259,17 +255,17 @@ These cheat sheets map TEA workflows to the **BMad Method and Enterprise tracks*
 - 🔄 Phase 4: `*test-design` - Focus on regression hotspots and brownfield risks
 - 🔄 Phase 4: Story Review - May include `*nfr-assess` if not done earlier
 
-| Workflow Stage                     | Test Architect                                                               | Dev / Team                                                                          | Outputs                                                                |
-| ---------------------------------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| **Documentation**: Prerequisite ➕ | -                                                                            | Analyst `*document-project` (if undocumented)                                       | Comprehensive project documentation                                    |
-| **Phase 1**: Discovery             | -                                                                            | Analyst/PM/Architect rerun planning workflows                                       | Updated planning artifacts in `{output_folder}`                        |
-| **Phase 2**: Planning              | Run ➕ `*trace` (baseline coverage)                                          | PM `*prd` (creates PRD with FRs/NFRs)                                               | PRD with FRs/NFRs, ➕ coverage baseline                                |
-| **Phase 3**: Solutioning           | Run `*framework`, `*ci` AFTER architecture and epic creation                 | Architect `*architecture`, `*create-epics-and-stories`, `*implementation-readiness` | Architecture, epics/stories, test framework, CI pipeline               |
-| **Phase 4**: Sprint Start          | -                                                                            | SM `*sprint-planning`                                                               | Sprint status file with all epics and stories                          |
-| **Phase 4**: Epic Planning         | Run `*test-design` for THIS epic 🔄 (regression hotspots)                    | Review epic scope and brownfield risks                                              | `test-design-epic-N.md` with brownfield risk assessment and mitigation |
-| **Phase 4**: Story Dev             | (Optional) `*atdd` before dev, then `*automate` after                        | SM `*create-story`, DEV implements                                                  | Tests, story implementation                                            |
-| **Phase 4**: Story Review          | Apply `*test-review` (optional), re-run `*trace`, ➕ `*nfr-assess` if needed | Resolve gaps, update docs/tests                                                     | Quality report, refreshed coverage matrix, NFR report                  |
-| **Phase 4**: Release Gate          | (Optional) `*test-review` for final audit, Run `*trace` (Phase 2)            | Capture sign-offs, share release notes                                              | Quality audit, Gate YAML + release summary                             |
+| Workflow Stage                    | Test Architect                                                              | Dev / Team                                                                          | Outputs                                                                |
+| --------------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| **Documentation**: Prerequisite ➕ | -                                                                           | Analyst `*document-project` (if undocumented)                                       | Comprehensive project documentation                                    |
+| **Phase 1**: Discovery            | -                                                                           | Analyst/PM/Architect rerun planning workflows                                       | Updated planning artifacts in `{output_folder}`                        |
+| **Phase 2**: Planning             | Run ➕ `*trace` (baseline coverage)                                          | PM `*prd` (creates PRD with FRs/NFRs)                                               | PRD with FRs/NFRs, ➕ coverage baseline                                 |
+| **Phase 3**: Solutioning          | Run `*framework`, `*ci` AFTER architecture and epic creation                | Architect `*architecture`, `*create-epics-and-stories`, `*implementation-readiness` | Architecture, epics/stories, test framework, CI pipeline               |
+| **Phase 4**: Sprint Start         | -                                                                           | SM `*sprint-planning`                                                               | Sprint status file with all epics and stories                          |
+| **Phase 4**: Epic Planning        | Run `*test-design` for THIS epic 🔄 (regression hotspots)                    | Review epic scope and brownfield risks                                              | `test-design-epic-N.md` with brownfield risk assessment and mitigation |
+| **Phase 4**: Story Dev            | (Optional) `*atdd` before dev, then `*automate` after                       | SM `*create-story`, DEV implements                                                  | Tests, story implementation                                            |
+| **Phase 4**: Story Review         | Apply `*test-review` (optional), re-run `*trace`, ➕ `*nfr-assess` if needed | Resolve gaps, update docs/tests                                                     | Quality report, refreshed coverage matrix, NFR report                  |
+| **Phase 4**: Release Gate         | (Optional) `*test-review` for final audit, Run `*trace` (Phase 2)           | Capture sign-offs, share release notes                                              | Quality audit, Gate YAML + release summary                             |
 
 <details>
 <summary>Execution Notes</summary>
@@ -309,15 +305,15 @@ These cheat sheets map TEA workflows to the **BMad Method and Enterprise tracks*
 - 🔄 Phase 4: `*test-design` - Enterprise focus (compliance, security architecture alignment)
 - 📦 Release Gate - Archive artifacts and compliance evidence for audits
 
-| Workflow Stage             | Test Architect                                                           | Dev / Team                                                                          | Outputs                                                            |
-| -------------------------- | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
-| **Phase 1**: Discovery     | -                                                                        | Analyst ➕ `*research`, `*product-brief`                                            | Domain research, compliance analysis, product brief                |
-| **Phase 2**: Planning      | Run ➕ `*nfr-assess`                                                     | PM `*prd` (creates PRD with FRs/NFRs), UX `*create-ux-design`                       | Enterprise PRD with FRs/NFRs, UX design, ➕ NFR documentation      |
-| **Phase 3**: Solutioning   | Run `*framework`, `*ci` AFTER architecture and epic creation             | Architect `*architecture`, `*create-epics-and-stories`, `*implementation-readiness` | Architecture, epics/stories, test framework, CI pipeline           |
-| **Phase 4**: Sprint Start  | -                                                                        | SM `*sprint-planning`                                                               | Sprint plan with all epics                                         |
+| Workflow Stage             | Test Architect                                                          | Dev / Team                                                                          | Outputs                                                            |
+| -------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
+| **Phase 1**: Discovery     | -                                                                       | Analyst ➕ `*research`, `*product-brief`                                             | Domain research, compliance analysis, product brief                |
+| **Phase 2**: Planning      | Run ➕ `*nfr-assess`                                                     | PM `*prd` (creates PRD with FRs/NFRs), UX `*create-ux-design`                       | Enterprise PRD with FRs/NFRs, UX design, ➕ NFR documentation       |
+| **Phase 3**: Solutioning   | Run `*framework`, `*ci` AFTER architecture and epic creation            | Architect `*architecture`, `*create-epics-and-stories`, `*implementation-readiness` | Architecture, epics/stories, test framework, CI pipeline           |
+| **Phase 4**: Sprint Start  | -                                                                       | SM `*sprint-planning`                                                               | Sprint plan with all epics                                         |
 | **Phase 4**: Epic Planning | Run `*test-design` for THIS epic 🔄 (compliance focus)                   | Review epic scope and compliance requirements                                       | `test-design-epic-N.md` with security/performance/compliance focus |
-| **Phase 4**: Story Dev     | (Optional) `*atdd`, `*automate`, `*test-review`, `*trace` per story      | SM `*create-story`, DEV implements                                                  | Tests, fixtures, quality reports, coverage matrices                |
-| **Phase 4**: Release Gate  | Final `*test-review` audit, Run `*trace` (Phase 2), 📦 archive artifacts | Capture sign-offs, 📦 compliance evidence                                           | Quality audit, updated assessments, gate YAML, 📦 audit trail      |
+| **Phase 4**: Story Dev     | (Optional) `*atdd`, `*automate`, `*test-review`, `*trace` per story     | SM `*create-story`, DEV implements                                                  | Tests, fixtures, quality reports, coverage matrices                |
+| **Phase 4**: Release Gate  | Final `*test-review` audit, Run `*trace` (Phase 2), 📦 archive artifacts | Capture sign-offs, 📦 compliance evidence                                            | Quality audit, updated assessments, gate YAML, 📦 audit trail       |
 
 <details>
 <summary>Execution Notes</summary>

package/docs/modules/bmm-bmad-method/troubleshooting.md

@@ -0,0 +1,3 @@
+# BMM Troubleshooting Guide
+
+Common issues and solutions for the BMad Method Module will be listed here as needed.

package/docs/modules/bmm-bmad-method/workflow-document-project-reference.md

@@ -0,0 +1,71 @@
+# Document Project Workflow - Technical Reference
+
+**Module:** BMM (BMAD Method Module)
+
+## Purpose
+
+Analyzes and documents brownfield projects by scanning codebase, architecture, and patterns to create comprehensive reference documentation for AI-assisted development. Generates a master index and multiple documentation files tailored to project structure and type.
+
+## How to Invoke
+```bash
+/bmad:bmm:workflows:document-project
+```
+---
+
+## Scan Levels
+
+Choose the right scan depth for your needs:
+
+### 1. Quick Scan (Default)
+
+**What it does:** Pattern-based analysis without reading source files
+**Reads:** Config files, package manifests, directory structure, README
+**Use when:**
+
+- You need a fast project overview
+- Initial understanding of project structure
+- Planning next steps before deeper analysis
+
+**Does NOT read:** Source code files (`_.js`, `_.ts`, `_.py`, `_.go`, etc.)
+
+### 2. Deep Scan
+
+**What it does:** Reads files in critical directories based on project type
+**Reads:** Files in critical paths defined by documentation requirements
+**Use when:**
+
+- Creating comprehensive documentation for brownfield PRD
+- Need detailed analysis of key areas
+- Want balance between depth and speed
+
+**Example:** For a web app, reads controllers/, models/, components/, but not every utility file
+
+### 3. Exhaustive Scan
+
+**What it does:** Reads ALL source files in project
+**Reads:** Every source file (excludes node_modules, dist, build, .git)
+**Use when:**
+
+- Complete project analysis needed
+- Migration planning requires full understanding
+- Detailed audit of entire codebase
+- Deep technical debt assessment
+
+**Note:** Deep-dive mode ALWAYS uses exhaustive scan (no choice)
+
+---
+
+## Resumability
+
+The workflow can be interrupted and resumed without losing progress:
+
+- **State Tracking:** Progress saved in `project-scan-report.json`
+- **Auto-Detection:** Workflow detects incomplete runs (<24 hours old)
+- **Resume Prompt:** Choose to resume or start fresh
+- **Step-by-Step:** Resume from exact step where interrupted
+- **Archiving:** Old state files automatically archived
+
+**Related Documentation:**
+
+- [Brownfield Development Guide](./brownfield-guide.md)
+- [Implementation Workflows](./workflows-implementation.md)

package/{src/modules/bmm/docs → docs/modules/bmm-bmad-method}/workflows-analysis.md

@@ -19,7 +19,6 @@ Phase 1 Analysis consists of three categories of optional workflows:
 ### Discovery & Ideation (Optional)
 
 - **brainstorm-project** - Multi-track solution exploration for software projects
-- **brainstorm-game** - Game concept generation (coming soon)
 
 ### Research & Validation (Optional)
 
@@ -54,19 +53,10 @@ These workflows feed into Phase 2 (Planning) workflows, particularly the `prd` w
 
 **When to Use:**
 
-- Unclear technical approach with business objectives
-- Multiple solution paths need evaluation
-- Hidden assumptions need discovery
-- Innovation beyond obvious solutions
-
-**Key Outputs:**
-
-- Architecture proposals with trade-off analysis
-- Value framework (prioritized features)
-- Risk analysis (dependencies, challenges)
-- Strategic recommendation with rationale
-
-**Example:** "We need a customer dashboard" → Options: Monolith SSR (faster), Microservices SPA (scalable), Hybrid (balanced) with recommendation.
+- Very vague or seed kernal of an idea that needs exploration
+- Consider alternatives or enhancements to an idea
+- See your idea from different angles and viewpoints
+- No idea what you want to build, but want to find some inspiration
 
 ---
 
@@ -111,11 +101,6 @@ These workflows feed into Phase 2 (Planning) workflows, particularly the `prd` w
 - Transitioning from exploration to strategy
 - Need executive-level product documentation
 
-**Modes:**
-
-- **Interactive Mode** (Recommended): Step-by-step collaborative development with probing questions
-- **YOLO Mode**: AI generates complete draft from context, then iterative refinement
-
 **Key Outputs:**
 
 - Executive summary
@@ -179,32 +164,6 @@ Analysis outputs feed directly into Planning:
 
 Planning workflows automatically load these documents if they exist in the output folder.
 
----
-
-## Best Practices
-
-### 1. Don't Over-Invest in Analysis
-
-Analysis is optional. If requirements are clear, skip to Phase 2 (Planning).
-
-### 2. Iterate Between Workflows
-
-Common pattern: brainstorm → research (validate) → brief (synthesize)
-
-### 3. Document Assumptions
-
-Analysis surfaces and validates assumptions. Document them explicitly for planning to challenge.
-
-### 4. Keep It Strategic
-
-Focus on "what" and "why", not "how". Leave implementation for Planning and Solutioning.
-
-### 5. Involve Stakeholders
-
-Use analysis workflows to align stakeholders before committing to detailed planning.
-
----
-
 ## Common Patterns
 
 ### Greenfield Software (Full Analysis)
@@ -233,34 +192,8 @@ Use analysis workflows to align stakeholders before committing to detailed plann
 
 ## Related Documentation
 
-- [Phase 2: Planning Workflows](./workflows-planning.md) - Next phase
-- [Phase 3: Solutioning Workflows](./workflows-solutioning.md)
-- [Phase 4: Implementation Workflows](./workflows-implementation.md)
+- [Phase 2: Planning Workflows](../../../../docs/modules/bmm-bmad-method/workflows-planning.md) - Next phase
+- [Phase 3: Solutioning Workflows](../../../../docs/modules/bmm-bmad-method/workflows-solutioning.md)
+- [Phase 4: Implementation Workflows](../../../../docs/modules/bmm-bmad-method/workflows-implementation.md)
 - [Scale Adaptive System](./scale-adaptive-system.md) - Understanding project complexity
-- [Agents Guide](./agents-guide.md) - Complete agent reference
-
----
-
-## Troubleshooting
-
-**Q: Do I need to run all analysis workflows?**
-A: No! Analysis is entirely optional. Use only workflows that help you think through your problem.
-
-**Q: Which workflow should I start with?**
-A: If unsure, start with `research` (market type) to validate viability, then move to `product-brief`.
-
-**Q: Can I skip straight to Planning?**
-A: Yes! If you know what you're building and why, skip Phase 1 entirely and start with Phase 2 (prd/tech-spec).
-
-**Q: How long should Analysis take?**
-A: Typically hours to 1-2 days. If taking longer, you may be over-analyzing. Move to Planning.
-
-**Q: What if I discover problems during Analysis?**
-A: That's the point! Analysis helps you fail fast and pivot before heavy planning investment.
-
-**Q: Should brownfield projects do Analysis?**
-A: Usually no. Start with `document-project` (Documentation prerequisite), then skip to Planning (Phase 2).
-
----
-
-_Phase 1 Analysis - Optional strategic thinking before commitment._
+- [Agents Guide](../../../../docs/modules/bmm-bmad-method/agents-guide.md) - Complete agent reference

package/docs/modules/bmm-bmad-method/workflows-planning.md

@@ -0,0 +1,89 @@
+# BMM Planning Workflows (Phase 2)
+
+## Phase 2 Planning Workflow Overview
+
+
+## Quick Reference
+
+| Workflow             | Agent       | Track                   | Purpose                               |
+| -------------------- | ----------- | ----------------------- | ------------------------------------- |
+| **prd**              | PM          | BMad Method, Enterprise | Strategic PRD with FRs/NFRs           |
+| **create-ux-design** | UX Designer | BMad Method, Enterprise | Optional UX specification (after PRD) |
+
+### prd (Product Requirements Document)
+
+**Purpose:** Strategic PRD with Functional Requirements (FRs) and Non-Functional Requirements (NFRs) for software products (BMad Method track).
+
+**Agent:** PM (with Architect and Analyst support)
+
+**When to Use:**
+
+- Medium to large feature sets
+- Multi-screen user experiences
+- Complex business logic
+- Multiple system integrations
+- Phased delivery required
+
+**Scale-Adaptive Structure:**
+
+- **Light:** Focused FRs/NFRs, simplified analysis (10-15 pages)
+- **Standard:** Comprehensive FRs/NFRs, thorough analysis (20-30 pages)
+- **Comprehensive:** Extensive FRs/NFRs, multi-phase, stakeholder analysis (30-50+ pages)
+
+**Key Outputs:**
+
+- PRD.md (complete requirements with FRs and NFRs)
+
+**Note:** V6 improvement - PRD focuses on WHAT to build (requirements). Epic+Stories are created AFTER architecture via `create-epics-and-stories` workflow for better quality.
+
+**Integration:** Feeds into Architecture (Phase 3)
+
+**Example:** E-commerce checkout → PRD with 15 FRs (user account, cart management, payment flow) and 8 NFRs (performance, security, scalability).
+
+---
+
+### create-ux-design (UX Design)
+
+**Purpose:** UX specification for projects where user experience is the primary differentiator (BMad Method track).
+
+**Agent:** UX Designer
+
+**When to Use:**
+
+- UX is primary competitive advantage
+- Complex user workflows needing design thinking
+- Innovative interaction patterns
+- Design system creation
+- Accessibility-critical experiences
+
+**Collaborative Approach:**
+
+1. Visual exploration (generate multiple options)
+2. Informed decisions (evaluate with user needs)
+3. Collaborative design (refine iteratively)
+4. Living documentation (evolves with project)
+
+**Key Outputs:**
+
+- ux-spec.md (complete UX specification)
+- User journeys
+- Wireframes and mockups
+- Interaction specifications
+- Design system (components, patterns, tokens)
+- Epic breakdown (UX stories)
+
+**Integration:** Feeds PRD or updates epics, then Architecture (Phase 3)
+
+**Example:** Dashboard redesign → Card-based layout with split-pane toggle, 5 card components, 12 color tokens, responsive grid, 3 epics (Layout, Visualization, Accessibility).
+
+## Best Practices
+
+### 1. Do Product Brief from Phase 1 to kickstart the PRD for better results
+
+### 2. Focus on "What" Not "How"
+
+Planning defines **what** to build and **why**. Leave **how** (technical design) to Phase 3 (Solutioning).
+
+### 3. Document-Project First for Brownfield
+
+Always run `document-project` before planning brownfield projects. AI agents need existing codebase context and will make a large quality difference. If you are adding a small addition to an existing project, you might want to consider instead after using document-project to use the quick flow solo dev process instead.

package/{src/modules/bmm/docs → docs/modules/bmm-bmad-method}/workflows-solutioning.md

@@ -434,7 +434,7 @@ Architecture documents are living. Update them as you learn during implementatio
 
 **Key Difference:** Enterprise adds optional extended workflows AFTER architecture but BEFORE create-epics-and-stories. Everything else is identical to BMad Method.
 
-**Note:** TEA (Test Architect) operates across all phases and validates architecture testability but is not a Phase 3-specific workflow. See [Test Architecture Guide](./test-architecture.md) for TEA's full lifecycle integration.
+**Note:** TEA (Test Architect) operates across all phases and validates architecture testability but is not a Phase 3-specific workflow. See [Test Architecture Guide](../../../../docs/modules/bmm-bmad-method/test-architecture.md) for TEA's full lifecycle integration.
 
 ---
 
@@ -471,10 +471,10 @@ Architecture documents are living. Update them as you learn during implementatio
 
 ## Related Documentation
 
-- [Phase 2: Planning Workflows](./workflows-planning.md) - Previous phase
-- [Phase 4: Implementation Workflows](./workflows-implementation.md) - Next phase
+- [Phase 2: Planning Workflows](../../../../docs/modules/bmm-bmad-method/workflows-planning.md) - Previous phase
+- [Phase 4: Implementation Workflows](../../../../docs/modules/bmm-bmad-method/workflows-implementation.md) - Next phase
 - [Scale Adaptive System](./scale-adaptive-system.md) - Understanding tracks
-- [Agents Guide](./agents-guide.md) - Complete agent reference
+- [Agents Guide](../../../../docs/modules/bmm-bmad-method/agents-guide.md) - Complete agent reference
 
 ---
 

package/docs/modules/core/advanced-elicitation.md

@@ -0,0 +1,105 @@
+# Advanced Elicitation
+
+**Push the LLM to rethink its work through 50+ reasoning methods—essentially, LLM brainstorming.**
+
+Advanced Elicitation is the inverse of Brainstorming. Instead of pulling ideas out of you, the LLM applies sophisticated reasoning techniques to re-examine and enhance content it has just generated. It's the LLM brainstorming with itself to find better approaches, uncover hidden issues, and discover improvements it missed on the first pass.
+
+---
+
+## When to Use It
+
+- After a workflow generates a section of content and you want to explore alternatives
+- When the LLM's initial output seems adequate but you suspect there's more depth available
+- For high-stakes content where multiple perspectives would strengthen the result
+- To stress-test assumptions, explore edge cases, or find weaknesses in generated plans
+- When you want the LLM to "think again" but with structured reasoning methods
+
+---
+
+## How It Works
+
+### 1. Context Analysis
+The LLM analyzes the current content, understanding its type, complexity, stakeholder needs, risk level, and creative potential.
+
+### 2. Smart Method Selection
+Based on context, 5 methods are intelligently selected from a library of 50+ techniques and presented to you:
+
+| Option            | Description                              |
+| ----------------- | ---------------------------------------- |
+| **1-5**           | Apply the selected method to the content |
+| **[r] Reshuffle** | Get 5 new methods selected randomly      |
+| **[a] List All**  | Browse the complete method library       |
+| **[x] Proceed**   | Continue with enhanced content           |
+
+### 3. Method Execution & Iteration
+- The selected method is applied to the current content
+- Improvements are shown for your review
+- You choose whether to apply changes or discard them
+- The menu re-appears for additional elicitations
+- Each method builds on previous enhancements
+
+### 4. Party Mode Integration (Optional)
+If Party Mode is active, BMAD agents participate randomly in the elicitation process, adding their unique perspectives to the methods.
+
+---
+
+## Method Categories
+
+| Category          | Focus                               | Example Methods                                                |
+| ----------------- | ----------------------------------- | -------------------------------------------------------------- |
+| **Core**          | Foundational reasoning techniques   | First Principles Analysis, 5 Whys, Socratic Questioning        |
+| **Collaboration** | Multiple perspectives and synthesis | Stakeholder Round Table, Expert Panel Review, Debate Club      |
+| **Advanced**      | Complex reasoning frameworks        | Tree of Thoughts, Graph of Thoughts, Self-Consistency          |
+| **Competitive**   | Adversarial stress-testing          | Red Team vs Blue Team, Shark Tank Pitch, Code Review Gauntlet  |
+| **Technical**     | Architecture and code quality       | Decision Records, Rubber Duck Debugging, Algorithm Olympics    |
+| **Creative**      | Innovation and lateral thinking     | SCAMPER, Reverse Engineering, Random Input Stimulus            |
+| **Research**      | Evidence-based analysis             | Literature Review Personas, Thesis Defense, Comparative Matrix |
+| **Risk**          | Risk identification and mitigation  | Pre-mortem Analysis, Failure Mode Analysis, Chaos Monkey       |
+| **Learning**      | Understanding verification          | Feynman Technique, Active Recall Testing                       |
+| **Philosophical** | Conceptual clarity                  | Occam's Razor, Ethical Dilemmas                                |
+| **Retrospective** | Reflection and lessons              | Hindsight Reflection, Lessons Learned Extraction               |
+
+---
+
+## Key Features
+
+- **50+ reasoning methods** — Spanning core logic to advanced multi-step reasoning frameworks
+- **Smart context selection** — Methods chosen based on content type, complexity, and stakeholder needs
+- **Iterative enhancement** — Each method builds on previous improvements
+- **User control** — Accept or discard each enhancement before proceeding
+- **Party Mode integration** — Agents can participate when Party Mode is active
+
+---
+
+## Workflow Integration
+
+Advanced Elicitation is a core workflow designed to be invoked by other workflows during content generation:
+
+| Parameter              | Description                                               |
+| ---------------------- | --------------------------------------------------------- |
+| **Content to enhance** | The current section content that was just generated       |
+| **Context type**       | The kind of content being created (spec, code, doc, etc.) |
+| **Enhancement goals**  | What the calling workflow wants to improve                |
+
+### Integration Flow
+
+When called from a workflow:
+1. Receives the current section content that was just generated
+2. Applies elicitation methods iteratively to enhance that content
+3. Returns the enhanced version when user selects 'x' to proceed
+4. The enhanced content replaces the original section in the output document
+
+### Example
+
+A specification generation workflow could invoke Advanced Elicitation after producing each major section (requirements, architecture, implementation plan). The workflow would pass the generated section, and Advanced Elicitation would offer methods like "Stakeholder Round Table" to gather diverse perspectives on requirements, or "Red Team vs Blue Team" to stress-test the architecture for vulnerabilities.
+
+---
+
+## Advanced Elicitation vs. Brainstorming
+
+|              | **Advanced Elicitation**                          | **Brainstorming**                             |
+| ------------ | ------------------------------------------------- | --------------------------------------------- |
+| **Source**   | LLM generates ideas through structured reasoning  | User provides ideas, AI coaches them out      |
+| **Purpose**  | Rethink and improve LLM's own output              | Unlock user's creativity                      |
+| **Methods**  | 50+ reasoning and analysis techniques             | 60+ ideation and creativity techniques        |
+| **Best for** | Enhancing generated content, finding alternatives | Breaking through blocks, generating new ideas |