.github/workflows/docs.yaml

@@ -1,72 +0,0 @@
-name: Deploy Documentation
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "docs/**"
-      - "src/modules/*/docs/**"
-      - "website/**"
-      - "tools/build-docs.js"
-      - ".github/workflows/docs.yaml"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-concurrency:
-  group: "pages"
-  cancel-in-progress: false
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-          cache: "npm"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Determine site URL
-        id: site-url
-        run: |
-          if [ "${{ github.repository }}" = "bmad-code-org/BMAD-METHOD" ]; then
-            echo "url=https://bmad-code-org.github.io/BMAD-METHOD" >> $GITHUB_OUTPUT
-          else
-            OWNER="${{ github.repository_owner }}"
-            REPO="${{ github.event.repository.name }}"
-            echo "url=https://${OWNER}.github.io/${REPO}" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Build documentation
-        env:
-          SITE_URL: ${{ steps.site-url.outputs.url }}
-        run: npm run docs:build
-
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: build/site
-
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    needs: build
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.github/workflows/quality.yaml

@@ -92,3 +92,6 @@ jobs:
 
       - name: Test agent compilation components
         run: npm run test:install
+
+      - name: Validate web bundles
+        run: npm run validate:bundles

.gitignore

@@ -46,6 +46,8 @@ CLAUDE.local.md
 # Project-specific
 _bmad-core
 _bmad-creator-tools
+test-project-install/*
+sample-project/*
 flattened-codebase.xml
 *.stats.md
 .internal-docs/
@@ -64,7 +66,6 @@ shared-modules
 z*/
 
 _bmad
-_bmad-output
 .claude
 .codex
 .github/chatmodes
@@ -73,8 +74,4 @@ _bmad-output
 .kiro/
 .roo
 
-bmad-custom-src/
-
-# Docusaurus / Documentation Build
-.docusaurus/
-build/
+bmad-custom-src/

.vscode/settings.json

@@ -57,7 +57,6 @@
     "tileset",
     "tmpl",
     "Trae",
-    "Unsharded",
     "VNET",
     "webskip"
   ],

CHANGELOG.md

@@ -1,244 +1,5 @@
 # Changelog
 
-## [6.0.0-alpha.21]
-
-**Release: December 27, 2025**
-
-### 🌟 Key Highlights
-
-1. **Consistent Menu System**: All agents now use standardized 2-letter menu codes (e.g., "rd" for research, "ca" for create-architecture)
-2. **Planning Artifacts Architecture**: Phase 1-3 workflows now properly segregate planning artifacts from documentation
-3. **Windows Installer Fixed Again**: Updated inquirer to resolve multiselection tool issues
-4. **Auto-Injected Features**: Chat and party mode automatically injected into all agents
-5. **Validation System**: All agents now pass comprehensive new validation checks
-
-### 🎯 Consistent Menu System (Major Feature)
-
-**Standardized 2-Letter Codes:**
-
-- **Compound Menu Triggers**: All agents now use consistent 2-letter compound trigger format (e.g., `bmm-rd`, `bmm-ca`)
-- **Improved UX**: Shorter, more memorable command shortcuts across all modules
-- **Module Prefixing**: Menu items properly scoped by module prefix (bmm-, bmgd-, cis-, bmb-)
-- **Universal Pattern**: All 22 agents updated to follow the same menu structure
-
-**Agent Updates:**
-
-- **BMM Module**: 9 agents with standardized menus (pm, analyst, architect, dev, ux-designer, tech-writer, sm, tea, quick-flow-solo-dev)
-- **BMGD Module**: 6 agents with standardized menus (game-architect, game-designer, game-dev, game-qa, game-scrum-master, game-solo-dev)
-- **CIS Module**: 6 agents with standardized menus (innovation-strategist, design-thinking-coach, creative-problem-solver, brainstorming-coach, presentation-master, storyteller)
-- **BMB Module**: 3 agents with standardized menus (bmad-builder, agent-builder, module-builder, workflow-builder)
-- **Core Module**: BMAD Master agent updated with consistent menu patterns
-
-### 📁 Planning Artifacts Architecture
-
-**Content Segregation Implementation:**
-
-- **Phase 1-3 Workflows**: All planning workflows now use `planning_artifacts` folder (default changed from `docs`)
-- **Proper Input Discovery**: Workflows follow consistent input discovery patterns from planning artifacts
-- **Output Management**: Planning artifacts properly separated from long-term documentation
-- **Affected Workflows**:
-  - Product Brief: Updated discovery and output to planning artifacts
-  - PRD: Fixed discovery and output to planning artifacts
-  - UX Design: Updated all steps for proper artifact handling
-  - Architecture: Updated discovery and output flow
-  - Game Architecture: Updated for planning artifacts
-  - Story Creation: Updated workflow output paths
-
-**File Organization:**
-
-- **Planning Artifacts**: Ephemeral planning documents (prd.md, product-brief.md, ux-design.md, architecture.md)
-- **Documentation**: Long-term project documentation (separate from planning)
-- **Module Configuration**: BMM and BMGD modules updated with proper default paths
-
-### 🪟 Windows Installer Fixes
-
-**Inquirer Multiselection Fix:**
-
-- **Updated Inquirer Version**: Resolved tool multiselection issues that were causing Windows installer failures
-- **Better Compatibility**: Improved handling of checkbox and multi-select prompts on Windows(?)
-
-### 🤖 Agent System Improvements
-
-**Auto-Injected Features:**
-
-- **Chat Mode**: Automatically injected into all agents during compilation
-- **Party Mode**: Automatically injected into all agents during compilation
-- **Reduced Manual Configuration**: No need to manually add these features to agent definitions
-- **Consistent Behavior**: All agents now have uniform access to chat and party mode capabilities
-
-**Agent Normalization:**
-
-- **All Agents Validated**: All 22 agents pass comprehensive validation checks
-- **Schema Enforcement**: Proper compound trigger validation implemented
-- **Metadata Cleanup**: Removed obsolete and inconsistent metadata patterns
-- **Test Fixtures Updated**: Validation test fixtures aligned with new requirements
-
-### 🔧 Bug Fixes & Cleanup
-
-**Docusaurus Merge Recovery:**
-
-- **Restored Agent Files**: Fixed agent files accidentally modified in Docusaurus merge (PR #1191)
-- **Reference Cleanup**: Removed obsolete agent reference examples (journal-keeper, security-engineer, trend-analyst)
-- **Test Fixture Updates**: Aligned test fixtures with current validation requirements
-
-**Code Quality:**
-
-- **Schema Improvements**: Enhanced agent schema validation with better error messages
-- **Removed Redundancy**: Cleaned up duplicate and obsolete agent definitions
-- **Installer Cleanup**: Removed unused configuration code from BMM installer
-
-**Planning Artifacts Path:**
-- Default: `planning_artifacts/` (configurable in module.yaml)
-- Previous: `docs/`
-- Benefit: Clear separation between planning work and permanent documentation
-
----
-
-## [6.0.0-alpha.20]
-
-**Release: December 23, 2025**
-
-### 🌟 Key Highlights
-
-1. **Windows Installer Fixed**: Better compatibility with inquirer v9.x upgrade
-2. **Path Segregation**: Revolutionary content organization separating ephemeral artifacts from permanent documentation
-3. **Custom Installation Messages**: Configurable intro/outro messages for professional installation experience
-4. **Enhanced Upgrade Logic**: Two-version auto upgrades with proper config preservation
-5. **Quick-Dev Refactor**: Sharded format with comprehensive adversarial review
-6. **Improved Quality**: Streamlined personas, fixed workflows, and cleaned up documentation
-7. **Doc Site Auto Generation**; Auto Generate a docusaurus site update on merge
-
-### 🪟 Windows Installer (hopefully) Fixed
-
-**Inquirer Upgrade:**
-
-- **Updated to v9.x**: Upgraded inquirer package for better Windows support
-- **Improved Compatibility**: Better handling of Windows terminal environments
-- **Enhanced UX**: More reliable interactive prompts across platforms
-
-### 🎯 Path Segregation Implementation (Major Feature)
-
-**Revolutionary Content Organization:**
-
-- **Phase 1-4 Path Segregation**: Implemented new BM paths across all BMM and BMGD workflows
-- **Planning vs Implementation Artifacts**: Separated ephemeral Phase 4 artifacts from permanent documentation
-- **Optimized File Organization**: Better structure differentiating planning artifacts from long-term project documentation
-- **Backward Compatible**: Existing installations continue working while preparing for optimized content organization
-- **Module Configuration Updates**: Enhanced module.yaml with new path configurations for all phases
-- **Workflow Path Updates**: All 90+ workflow files updated with proper path configurations
-
-**Documentation Cleanup:**
-
-- **Removed Obsolete Documentation**: Cleaned up 3,100+ lines of outdated documentation
-- **Streamlined README Files**: Consolidated and improved module documentation
-- **Enhanced Clarity**: Removed redundant content and improved information architecture
-
-### 💬 Installation Experience Enhancements
-
-**Custom Installation Messages:**
-
-- **Configurable Intro/Outro Messages**: New install-messages.yaml file for customizable installation messages
-- **Professional Installation Flow**: Custom welcome messages and completion notifications
-- **Module-Specific Messaging**: Tailored messages for different installation contexts
-- **Enhanced User Experience**: More informative and personalized installation process
-
-**Core Module Improvements:**
-
-- **Always Ask Questions**: Core module now always prompts for configuration (no accept defaults)
-- **Better User Engagement**: Ensures users actively configure their installation
-- **Improved Configuration Accuracy**: Reduces accidental acceptance of defaults
-
-### 🔧 Upgrade & Configuration Management
-
-**Two-Version Auto Upgrade:**
-
-- **Smarter Upgrade Logic**: Automatic upgrades now span 2 versions (e.g., .16 → .18)
-- **Config Variable Preservation**: Ensures all configuration variables are retained during quick updates
-- **Seamless Updates**: Quick updates now preserve custom settings properly
-- **Enhanced Upgrade Safety**: Better handling of configuration across version boundaries
-
-### 🤖 Workflow Improvements
-
-**Quick-Dev Workflow Refactor (PR #1182):**
-
-- **Sharded Format Conversion**: Converted quick-dev workflow to modern step-file format
-- **Adversarial Review Integration**: Added comprehensive self-check and adversarial review steps
-- **Enhanced Quality Assurance**: 6-step process with mode detection, context gathering, execution, self-check, review, and resolution
-- **578 New Lines Added**: Significant expansion of quick-dev capabilities
-
-**BMGD Workflow Fixes:**
-
-- **workflow-status Filename Correction**: Fixed incorrect filename references (PR #1172)
-- **sprint-planning Update**: Added workflow-status update to game-architecture completion
-- **Path Corrections**: Resolved dead references and syntax errors (PR #1164)
-
-### 🎨 Code Quality & Refactoring
-
-**Persona Streamlining (PR #1167):**
-
-- **Quick-Flow-Solo-Dev Persona**: Streamlined for clarity and accuracy
-- **Improved Agent Behavior**: More focused and efficient solo development support
-
-**Package Management:**
-
-- **package-lock.json Sync**: Ensured version consistency (PR #1168)
-- **Dependency Cleanup**: Reduced package-lock bloat significantly
-
-**Prettier Configuration:**
-
-- **Markdown Underscore Protection**: Prettier will no longer mess up underscores in markdown files
-- **Disabled Auto-Fix**: Markdown formatting issues now handled more intelligently
-- **Better Code Formatting**: Improved handling of special characters in documentation
-
-### 📚 Documentation Updates
-
-**Sponsor Attribution:**
-
-- **DigitalOcean Sponsorship**: Added attribution for DigitalOcean support (PR #1162)
-
-**Content Reorganization:**
-
-- **Removed Unused Docs**: Eliminated obsolete documentation files
-- **Consolidated References**: Merged and reorganized technical references
-- **Enhanced README Files**: Improved module and workflow documentation
-
-### 🧹 Cleanup & Optimization
-
-**File Organization:**
-
-- **Removed Asterisk Insertion**: Eliminated unwanted asterisk insertions into agent files
-- **Removed Unused Commands**: Cleaned up deprecated command references
-- **Consolidated Duplication**: Reduced code duplication across multiple files
-- **Removed Unneeded Folders**: Cleaned up temporary and obsolete directory structures
-
-### 📊 Statistics
-
-- **23 commits** since alpha.19
-- **90+ workflow files** updated with new path configurations
-- **3,100+ lines of documentation** removed and reorganized
-- **578 lines added** to quick-dev workflow with adversarial review
-- **Major architectural improvement** to content organization
-
-## [6.0.0-alpha.19]
-
-**Release: December 18, 2025**
-
-### 🐛 Bug Fixes
-
-**Installer Stability:**
-
-- **Fixed \_bmad Folder Stutter**: Resolved issue with duplicate \_bmad folder creation when applying agent custom files
-- **Cleaner Installation**: Removed unnecessary backup file that was causing bloat in the installer
-- **Streamlined Agent Customization**: Fixed path handling for agent custom files to prevent folder duplication
-
-### 📊 Statistics
-
-- **3 files changed** with critical fix
-- **3,688 lines removed** by eliminating backup files
-- **Improved installer performance** and stability
-
----
-
 ## [6.0.0-alpha.18]
 
 **Release: December 18, 2025**

CONTRIBUTING.md

@@ -236,8 +236,10 @@ Each commit should represent one logical change:
 3. **Don't paste code in issues** - create a proper PR instead
 4. **Don't submit your whole project** - contribute specific improvements
 
-## Prompt & Agent Guidelines
+## Code Style
 
+- Follow the existing code style and conventions
+- Write clear comments for complex logic
 - Keep dev agents lean - they need context for coding, not documentation
 - Web/planning agents can be larger with more complex tasks
 - Everything is natural language (markdown) - no code in core framework

README.md

@@ -24,9 +24,10 @@ The completely revamped **BMAD V6 installer** now includes built-in support for
 
 **📚 Learn More:**
 
-- [**Custom Content Overview**](docs/modules/bmb-bmad-builder/custom-content.md) - Discover all supported content types
-- [**Installation Guide**](docs/modules/bmb-bmad-builder/custom-content-installation.md) - Learn to create and install custom content
-- [**2 Very simple Custom Modules of questionable quality**](./samples/sample-custom-modules/README.md) - if you want to download and try to install a custom shared module, get an idea of how to bundle and share your own, or create your own personal agents, workflows and modules.
+- [**Custom Content Overview**](./docs/custom-content.md) - Discover all supported content types
+- [**Installation Guide**](./docs/custom-content-installation.md) - Learn to create and install custom content
+- [**Detail Content Docs**](./src/modules/bmb/docs/README.md) - Reference details for agents, modules, workflows and the bmad builder
+- [**2 Very simple Custom Modules of questionable quality**](./docs/sample-custom-modules/README.md) - if you want to download and try to install a custom shared module, get an idea of how to bundle and share your own, or create your own personal agents, workflows and modules.
 
 </div>
 
@@ -67,7 +68,7 @@ With **BMad Builder**, you can architect both simple agents and vastly complex d
 ## 📊 See It In Action
 
 <p align="center">
-  <img src="./docs/modules/bmm-bmad-method/images/workflow-method-greenfield.svg" alt="BMad Method Workflow" width="100%">
+  <img src="./src/modules/bmm/docs/images/workflow-method-greenfield.svg" alt="BMad Method Workflow" width="100%">
 </p>
 
 <p align="center">
@@ -79,18 +80,13 @@ With **BMad Builder**, you can architect both simple agents and vastly complex d
 ### 1. Install BMad Method
 
 ```bash
-# Install v6 RECOMMENDED
+# Install v6 Alpha (recommended)
 npx bmad-method@alpha install
-```
 
-```bash
-# Install v4 Legacy (not recommended if starting fresh)
+# Or stable v4 for production
 npx bmad-method install
-# OR
-npx bmad-method@latest install
 ```
 
-
 ### 2. Initialize Your Project
 
 Load any agent in your IDE and run:
@@ -105,8 +101,8 @@ This analyzes your project and recommends the right workflow track.
 
 BMad Method adapts to your needs with three intelligent tracks:
 
-| Track             | Use For                   | Planning                | Time to Start |
-| ----------------- | ------------------------- | ----------------------- | ------------- |
+| Track              | Use For                   | Planning                | Time to Start |
+| ------------------ | ------------------------- | ----------------------- | ------------- |
 | **⚡ Quick Flow**  | Bug fixes, small features | Tech spec only          | < 5 minutes   |
 | **📋 BMad Method** | Products, platforms       | PRD + Architecture + UX | < 15 minutes  |
 | **🏢 Enterprise**  | Compliance, scale         | Full governance suite   | < 30 minutes  |
@@ -128,35 +124,36 @@ Each phase has specialized workflows and agents working together to deliver exce
 
 **12 Specialized Agents** working in concert:
 
-| Development | Architecture   | Product     | Leadership   |
-| ----------- | -------------- | ----------- | ------------ |
-| Developer   | Architect      | PM          | Scrum Master |
-| UX Designer | Test Architect | Analyst     | BMad Master  |
-|             |                | Tech Writer |              |
+| Development | Architecture   | Product       | Leadership     |
+| ----------- | -------------- | ------------- | -------------- |
+| Developer   | Architect      | PM            | Scrum Master   |
+| UX Designer | Test Architect | Analyst       | BMad Master    |
+| Tech Writer | Game Architect | Game Designer | Game Developer |
 
-**Test Architect** integrates with `@seontechnologies/playwright-utils` for production-ready web app fixture-based utilities.
+**Test Architect** integrates with `@seontechnologies/playwright-utils` for production-ready fixture-based utilities.
 
 Each agent brings deep expertise and can be customized to match your team's style.
 
 ## 📦 What's Included
 
-### Official Modules
+### Core Modules
 
 - **BMad Method (BMM)** - Complete agile development framework
   - 12 specialized agents
   - 34 workflows across 4 phases
-  - Stand Along Quick Spec Flow for a streamlined simple implementation process
-  - [→ Documentation Hub](./docs/modules/bmm-bmad-method/index.md)
+  - Scale-adaptive planning
+  - [→ Documentation Hub](./src/modules/bmm/docs/README.md)
 
 - **BMad Builder (BMB)** - Create custom agents and workflows
   - Build anything from simple agents to complex modules
   - Create domain-specific solutions (legal, medical, finance, education)
-  - [→ Builder Guide](./docs/modules/bmb-bmad-builder/index.md)
+  - [→ Builder Guide](src/modules/bmb/docs/README.md) marketplace
+  - [→ Builder Guide](./src/modules/bmb/README.md)
 
 - **Creative Intelligence Suite (CIS)** - Innovation & problem-solving
   - Brainstorming, design thinking, storytelling
   - 5 creative facilitation workflows
-  - [→ Creative Workflows](./docs/modules/cis-creative-intelligence-suite/index.md)
+  - [→ Creative Workflows](./src/modules/cis/README.md)
 
 ### Key Features
 
@@ -170,14 +167,14 @@ Each agent brings deep expertise and can be customized to match your team's styl
 
 ### Quick Links
 
-- **[Quick Start Guide](./docs/modules/bmm-bmad-method/quick-start.md)** - 15-minute introduction
-- **[Complete BMM Documentation](./docs/modules/bmm-bmad-method/index.md)** - All guides and references
-- **[Agent Customization](docs/bmad-customization/agent-customization-guide.md)** - Personalize your agents
+- **[Quick Start Guide](./src/modules/bmm/docs/quick-start.md)** - 15-minute introduction
+- **[Complete BMM Documentation](./src/modules/bmm/docs/README.md)** - All guides and references
+- **[Agent Customization](./docs/agent-customization-guide.md)** - Personalize your agents
 - **[All Documentation](./docs/index.md)** - Complete documentation index
 
 ### For v4 Users
 
-- **[v4 Documentation](https://github.com/bmad-code-org/BMAD-METHOD/tree/V4/docs)**
+- **[v4 Documentation](https://github.com/bmad-code-org/BMAD-METHOD/tree/V4)**
 - **[v4 to v6 Upgrade Guide](./docs/v4-to-v6-upgrade.md)**
 
 ## 💬 Community & Support
@@ -185,12 +182,24 @@ Each agent brings deep expertise and can be customized to match your team's styl
 - **[Discord Community](https://discord.gg/gk8jAdXWmj)** - Get help, share projects
 - **[GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)** - Report bugs, request features
 - **[YouTube Channel](https://www.youtube.com/@BMadCode)** - Video tutorials and demos
-- **[Web Bundles](https://bmad-code-org.github.io/bmad-bundles/)** - Pre-built agent bundles (Currently not functioning, reworking soon)
+- **[Web Bundles](https://bmad-code-org.github.io/bmad-bundles/)** - Pre-built agent bundles
 - **[Code of Conduct](.github/CODE_OF_CONDUCT.md)** - Community guidelines
 
 ## 🛠️ Development
 
-If you would like to contribute, first check the [CONTRIBUTING.md](CONTRIBUTING.md) for full development guidelines.
+For contributors working on the BMad codebase:
+
+```bash
+# Run all quality checks
+npm test
+
+# Development commands
+npm run lint:fix      # Fix code style
+npm run format:fix    # Auto-format code
+npm run bundle        # Build web bundles
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for full development guidelines.
 
 ## What's New in v6
 
@@ -222,8 +231,6 @@ MIT License - See [LICENSE](LICENSE) for details.
 
 **Trademarks:** BMad™ and BMAD-METHOD™ are trademarks of BMad Code, LLC.
 
-Supported by:&nbsp;&nbsp;<a href="https://m.do.co/c/00f11bd932bb"><img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" height="24" alt="DigitalOcean" style="vertical-align: middle;"></a>
-
 ---
 
 <p align="center">

docs/agent-customization-guide.md

@@ -81,7 +81,7 @@ Add your own workflows to the agent's menu:
 ```yaml
 menu:
   - trigger: my-workflow
-    workflow: '{project-root}/my-custom/workflows/my-workflow.yaml'
+    workflow: '{project-root}/custom/my-workflow.yaml'
     description: My custom workflow
   - trigger: deploy
     action: '#deploy-prompt'
@@ -203,6 +203,6 @@ memories:
 
 ## Next Steps
 
-- **[BMM Agents Guide](./modules/bmm/agents-guide)** - Learn about the BMad Method agents
-- **[BMB Create Agent Workflow](./modules/bmb/agents/index)** - Build completely custom agents
-- **[BMM Complete Documentation](./modules/bmm/index)** - Full BMad Method reference
+- **[BMM Agents Guide](../src/modules/bmm/docs/agents-guide.md)** - Learn about the BMad Method agents
+- **[BMB Create Agent Workflow](../src/modules/bmb/workflows/create-agent/README.md)** - Build completely custom agents
+- **[BMM Complete Documentation](../src/modules/bmm/docs/README.md)** - Full BMad Method reference

docs/bmad-customization/workflow-customization-guide.md

@@ -1,3 +0,0 @@
-# Workflow Customization Guide
-
-Coming Soon...

docs/custom-content-installation.md

@@ -2,9 +2,9 @@
 
 This guide explains how to create and install custom BMAD content including agents, workflows, and modules. Custom content extends BMAD's functionality with specialized tools and workflows that can be shared across projects or teams.
 
-For detailed information about the different types of custom content available, see [Custom Content](modules/bmb-bmad-builder/custom-content.md).
+For detailed information about the different types of custom content available, see [Custom Content](./custom-content.md).
 
-You can find example custom modules in the `samples/sample-custom-modules/` folder of the repository. Download either of the sample folders to try them out.
+If you download either of the folders within the [Sample Custom Modules](./sample-custom-modules/readme.md) folder
 
 ## Content Types Overview
 
@@ -26,8 +26,10 @@ To create an installable custom module:
    - Create a folder with a short, abbreviated name (e.g., `cis` for Creative Intelligence Suite)
    - The folder name serves as the module code
 
-2. **Required File**
-   - Include a `module.yaml` file in the root folder (this drives questions for the final generated config.yaml at install target)
+2. **Required Files**
+   - Include a `module.yaml` file in the root folder
+   - This file drives the installation process when used by the BMAD installer
+   - Reference existing modules or the BMad Builder for configuration examples
 
 3. **Folder Organization**
    Follow these conventions for optimal compatibility:
@@ -54,10 +56,8 @@ For standalone content that isn't part of a cohesive module collection, follow t
 
 1. **Module Configuration**
    - Create a folder with a `module.yaml` file (similar to custom modules)
-   - Add the property `unitary: true` in the module.yaml
-     - The `unitary: true` property indicates this is a collection of potentially unrelated items that don't depend on each other
-   - Any content you add to this folder should still be nested under workflows and agents - but the key with stand alone content is they do not rely on each other.
-     - Agents do not reference other workflows even if stored in a unitary:true module. But unitary Agents can have their own workflows in their sidecar, or reference workflows as requirements from other modules - with a process known as workflow vendoring. Keep in mind, this will require that the workflow referenced from the other module would need to be available for the end user to install, so its recommended to only vendor workflows from the core module, or official bmm modules (See [Workflow Vendoring, Customization, and Inheritance](workflow-vendoring-customization-inheritance.md)).
+   - Add the property `unitary: true` to the module.yaml
+   - The `unitary: true` property indicates this is a collection of potentially unrelated items that don't depend on each other
 
 2. **Folder Structure**
    Organize content in specific named folders:

docs/custom-content.md

@@ -1,6 +1,6 @@
 # Custom Content
 
-BMAD supports several categories of officially supported custom content that extend the platform's capabilities. Custom content can be created manually or with the recommended assistance of the BMad Builder (BoMB) Module. The BoMB Agents provides workflows and expertise to plan and build any custom content you can imagine.
+BMAD supports several categories of officially supported custom content that extend the platform's capabilities. Custom content can be created manually or with the recommended assistance of the BMad Builder (BoMB) Module. The BoMB Agent provides workflows and expertise to plan and build any custom content you can imagine.
 
 This flexibility transforms the platform beyond its current capabilities, enabling:
 
@@ -21,7 +21,7 @@ This flexibility transforms the platform beyond its current capabilities, enabli
   - [Custom Global Modules](#custom-global-modules)
   - [Custom Agents](#custom-agents)
     - [BMad Tiny Agents](#bmad-tiny-agents)
-    - [Simple and Expert Agents](#simple-and-expert-agents)
+    - [Simple vs Expert Agents](#simple-vs-expert-agents)
   - [Custom Workflows](#custom-workflows)
 
 ## Custom Stand Alone Modules
@@ -57,7 +57,7 @@ Similar to Custom Stand Alone Modules, but designed to add functionality that ap
 
 Examples include:
 
-- The current TTS (Text-to-Speech) functionality for Claude, which will soon be converted to a global module
+- The current TTS (Text-to-Speech) functionality for Claude, which will be rebuilt as a global module
 - The core module, which is always installed and provides all agents with party mode and advanced elicitation capabilities
 - Installation and update tools that work with any BMAD method configuration
 
@@ -81,7 +81,7 @@ Personal agents designed for highly specific needs that may not be suitable for
 
 These are simple, standalone files that can be scoped to focus on specific data or paths when integrated into an information vault or repository.
 
-### Simple and Expert Agents
+### Simple vs Expert Agents
 
 The distinction between simple and expert agents lies in their structure:
 
@@ -89,6 +89,7 @@ The distinction between simple and expert agents lies in their structure:
 
 - Single file containing all prompts and configuration
 - Self-contained and straightforward
+- has metadata type: simple
 
 **Expert Agent:**
 

docs/document-sharding-guide.md

@@ -0,0 +1,449 @@
+# Document Sharding Guide
+
+Comprehensive guide to BMad Method's document sharding system for managing large planning and architecture documents.
+
+## Table of Contents
+
+- [What is Document Sharding?](#what-is-document-sharding)
+- [When to Use Sharding](#when-to-use-sharding)
+- [How Sharding Works](#how-sharding-works)
+- [Using the Shard-Doc Tool](#using-the-shard-doc-tool)
+- [Workflow Support](#workflow-support)
+- [Best Practices](#best-practices)
+- [Examples](#examples)
+
+## What is Document Sharding?
+
+Document sharding splits large markdown files into smaller, organized files based on level 2 headings (`## Heading`). This enables:
+
+- **Selective Loading** - Workflows load only the sections they need
+- **Reduced Token Usage** - Massive efficiency gains for large projects
+- **Better Organization** - Logical section-based file structure
+- **Maintained Context** - Index file preserves document structure
+
+### Architecture
+
+```
+Before Sharding:
+docs/
+└── PRD.md (large 50k token file)
+
+After Sharding:
+docs/
+└── prd/
+    ├── index.md                    # Table of contents with descriptions
+    ├── overview.md                 # Section 1
+    ├── user-requirements.md        # Section 2
+    ├── technical-requirements.md   # Section 3
+    └── ...                         # Additional sections
+```
+
+## When to Use Sharding
+
+### Ideal Candidates
+
+**Large Multi-Epic Projects:**
+
+- Very large complex PRDs
+- Architecture documents with multiple system layers
+- Epic files with 4+ epics (especially for Phase 4)
+- UX design specs covering multiple subsystems
+
+**Token Thresholds:**
+
+- **Consider sharding**: Documents > 20k tokens
+- **Strongly recommended**: Documents > 40k tokens
+- **Critical for efficiency**: Documents > 60k tokens
+
+### When NOT to Shard
+
+**Small Projects:**
+
+- Single epic projects
+- Level 0-1 projects (tech-spec only)
+- Documents under 10k tokens
+- Quick prototypes
+
+**Frequently Updated Docs:**
+
+- Active work-in-progress documents
+- Documents updated daily
+- Documents where whole-file context is essential
+
+## How Sharding Works
+
+### Sharding Process
+
+1. **Tool Execution**: Run `npx @kayvan/markdown-tree-parser source.md destination/` - this is abstracted with the core shard-doc task which is installed as a slash command or manual task rule depending on your tools.
+2. **Section Extraction**: Tool splits by level 2 headings
+3. **File Creation**: Each section becomes a separate file
+4. **Index Generation**: `index.md` created with structure and descriptions
+
+### Workflow Discovery
+
+BMad workflows use a **dual discovery system**:
+
+1. **Try whole document first** - Look for `document-name.md`
+2. **Check for sharded version** - Look for `document-name/index.md`
+3. **Priority rule** - Whole document takes precedence if both exist
+
+### Loading Strategies
+
+**Full Load (Phase 1-3 workflows):**
+
+```
+If sharded:
+  - Read index.md
+  - Read ALL section files
+  - Treat as single combined document
+```
+
+**Selective Load (Phase 4 workflows):**
+
+```
+If sharded epics and working on Epic 3:
+  - Read epics/index.md
+  - Load ONLY epics/epic-3.md
+  - Skip all other epic files
+  - 90%+ token savings!
+```
+
+## Using the Shard-Doc Tool
+
+### CLI Command
+
+```bash
+# Activate bmad-master or analyst agent, then:
+/shard-doc
+```
+
+### Interactive Process
+
+```
+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!
+```
+
+### What Gets Created
+
+**index.md structure:**
+
+```markdown
+# PRD - Index
+
+## Sections
+
+1. [Overview](./overview.md) - Project vision and objectives
+2. [User Requirements](./user-requirements.md) - Feature specifications
+3. [Epic 1: Authentication](./epic-1-authentication.md) - User auth system
+4. [Epic 2: Dashboard](./epic-2-dashboard.md) - Main dashboard UI
+   ...
+```
+
+**Individual section files:**
+
+- Named from heading text (kebab-case)
+- Contains complete section content
+- Preserves all markdown formatting
+- Can be read independently
+
+## Workflow Support
+
+### Universal Support
+
+**All BMM workflows support both formats:**
+
+- ✅ Whole documents
+- ✅ Sharded documents
+- ✅ Automatic detection
+- ✅ Transparent to user
+
+### Workflow-Specific Patterns
+
+#### Phase 1-3 (Full Load)
+
+Workflows load entire sharded documents:
+
+- `product-brief` - Research, brainstorming docs
+- `prd` - Product brief, research
+- `gdd` - Game brief, research
+- `create-ux-design` - PRD, brief, architecture (if available)
+- `tech-spec` - Brief, research
+- `architecture` - PRD, UX design (if available)
+- `create-epics-and-stories` - PRD, architecture
+- `implementation-readiness` - All planning docs
+
+#### Phase 4 (Selective Load)
+
+Workflows load only needed sections:
+
+**sprint-planning** (Full Load):
+
+- Needs ALL epics to build complete status
+
+**create-story, code-review** (Selective):
+
+```
+Working on Epic 3, Story 2:
+  ✓ Load epics/epic-3.md only
+  ✗ Skip epics/epic-1.md, epic-2.md, epic-4.md, etc.
+
+Result: 90%+ token reduction for 10-epic projects!
+```
+
+### Input File Patterns
+
+Workflows use standardized patterns:
+
+```yaml
+input_file_patterns:
+  prd:
+    whole: '{output_folder}/*prd*.md'
+    sharded: '{output_folder}/*prd*/index.md'
+
+  epics:
+    whole: '{output_folder}/*epic*.md'
+    sharded_index: '{output_folder}/*epic*/index.md'
+    sharded_single: '{output_folder}/*epic*/epic-{{epic_num}}.md'
+```
+
+## Best Practices
+
+### Sharding Strategy
+
+**Do:**
+
+- ✅ Shard after planning phase complete
+- ✅ Keep level 2 headings well-organized
+- ✅ Use descriptive section names
+- ✅ Shard before Phase 4 implementation
+- ✅ Keep original file as backup initially
+
+**Don't:**
+
+- ❌ Shard work-in-progress documents
+- ❌ Shard small documents (<20k tokens)
+- ❌ Mix sharded and whole versions
+- ❌ Manually edit index.md structure
+
+### Naming Conventions
+
+**Good Section Names:**
+
+```markdown
+## Epic 1: User Authentication
+
+## Technical Requirements
+
+## System Architecture
+
+## UX Design Principles
+```
+
+**Poor Section Names:**
+
+```markdown
+## Section 1
+
+## Part A
+
+## Details
+
+## More Info
+```
+
+### File Management
+
+**When to Re-shard:**
+
+- Significant structural changes to document
+- Adding/removing major sections
+- After major refactoring
+
+**Updating Sharded Docs:**
+
+1. Edit individual section files directly
+2. OR edit original, delete sharded folder, re-shard
+3. Don't manually edit index.md
+
+## Examples
+
+### Example 1: Large PRD
+
+**Scenario:** 15-epic project, PRD is 45k tokens
+
+**Before Sharding:**
+
+```
+Every workflow loads entire 45k token PRD
+Architecture workflow: 45k tokens
+UX design workflow: 45k tokens
+```
+
+**After Sharding:**
+
+```bash
+/shard-doc
+Source: docs/PRD.md
+Destination: docs/prd/
+
+Created:
+  prd/index.md
+  prd/overview.md (3k tokens)
+  prd/functional-requirements.md (8k tokens)
+  prd/non-functional-requirements.md (6k tokens)
+  prd/user-personas.md (4k tokens)
+  ...additional FR/NFR sections
+```
+
+**Result:**
+
+```
+Architecture workflow: Can load specific sections needed
+UX design workflow: Can load specific sections needed
+Significant token reduction for large requirement docs!
+```
+
+### Example 2: Sharding Epics File
+
+**Scenario:** 8 epics with detailed stories, 35k tokens total
+
+```bash
+/shard-doc
+Source: docs/bmm-epics.md
+Destination: docs/epics/
+
+Created:
+  epics/index.md
+  epics/epic-1.md
+  epics/epic-2.md
+  ...
+  epics/epic-8.md
+```
+
+**Efficiency Gain:**
+
+```
+Working on Epic 5 stories:
+  Old: Load all 8 epics (35k tokens)
+  New: Load epic-5.md only (4k tokens)
+  Savings: 88% reduction
+```
+
+### Example 3: Architecture Document
+
+**Scenario:** Multi-layer system architecture, 28k tokens
+
+```bash
+/shard-doc
+Source: docs/architecture.md
+Destination: docs/architecture/
+
+Created:
+  architecture/index.md
+  architecture/system-overview.md
+  architecture/frontend-architecture.md
+  architecture/backend-services.md
+  architecture/data-layer.md
+  architecture/infrastructure.md
+  architecture/security-architecture.md
+```
+
+**Benefit:** Code-review workflow can reference specific architectural layers without loading entire architecture doc.
+
+## Custom Workflow Integration
+
+### For Workflow Builders
+
+When creating custom workflows that load large documents:
+
+**1. Add input_file_patterns to workflow.yaml:**
+
+```yaml
+input_file_patterns:
+  your_document:
+    whole: '{output_folder}/*your-doc*.md'
+    sharded: '{output_folder}/*your-doc*/index.md'
+```
+
+**2. Add discovery instructions to instructions.md:**
+
+```markdown
+## Document Discovery
+
+1. Search for whole document: _your-doc_.md
+2. Check for sharded version: _your-doc_/index.md
+3. If sharded: Read index + ALL sections (or specific sections if selective load)
+4. Priority: Whole document first
+```
+
+**3. Choose loading strategy:**
+
+- **Full Load**: Read all sections when sharded
+- **Selective Load**: Read only relevant sections (requires section identification logic)
+
+### Pattern Templates
+
+**Full Load Pattern:**
+
+```xml
+<action>Search for document: {output_folder}/*doc-name*.md</action>
+<action>If not found, check for sharded: {output_folder}/*doc-name*/index.md</action>
+<action if="sharded found">Read index.md to understand structure</action>
+<action if="sharded found">Read ALL section files listed in index</action>
+<action if="sharded found">Combine content as single document</action>
+```
+
+**Selective Load Pattern (with section ID):**
+
+```xml
+<action>Determine section needed (e.g., epic_num = 3)</action>
+<action>Check for sharded version: {output_folder}/*doc-name*/index.md</action>
+<action if="sharded found">Read ONLY the specific section file needed</action>
+<action if="sharded found">Skip all other section files</action>
+```
+
+## Troubleshooting
+
+### Common Issues
+
+**Both whole and sharded exist:**
+
+- Workflows will use whole document (priority rule)
+- Delete or archive the one you don't want
+
+**Index.md out of sync:**
+
+- Delete sharded folder
+- Re-run shard-doc on original
+
+**Workflow can't find document:**
+
+- Check file naming matches patterns (`*prd*.md`, `*epic*.md`, etc.)
+- Verify index.md exists in sharded folder
+- Check output_folder path in config
+
+**Sections too granular:**
+
+- Combine sections in original document
+- Use fewer level 2 headings
+- Re-shard
+
+## Related Documentation
+
+- [shard-doc Tool](../src/core/tools/shard-doc.xml) - Tool implementation
+- [BMM Workflows Guide](../src/modules/bmm/workflows/README.md) - Workflow overview
+- [Workflow Creation Guide](../src/modules/bmb/workflows/create-workflow/workflow-creation-guide.md) - Custom workflow patterns
+
+---
+
+**Document sharding is optional but powerful** - use it when efficiency matters for large projects!

docs/ide-info/auggie.md

@@ -0,0 +1,31 @@
+# BMAD Method - Auggie CLI Instructions
+
+## Activating Agents
+
+BMAD agents can be installed in multiple locations based on your setup.
+
+### Common Locations
+
+- User Home: `~/.augment/commands/`
+- Project: `.augment/commands/`
+- Custom paths you selected
+
+### How to Use
+
+1. **Type Trigger**: Use `@{agent-name}` in your prompt
+2. **Activate**: Agent persona activates
+3. **Tasks**: Use `@task-{task-name}` for tasks
+
+### Examples
+
+```
+@dev - Activate development agent
+@architect - Activate architect agent
+@task-setup - Execute setup task
+```
+
+### Notes
+
+- Agents can be in multiple locations
+- Check your installation paths
+- Activation syntax same across all locations

docs/ide-info/claude-code.md

@@ -0,0 +1,25 @@
+# BMAD Method - Claude Code Instructions
+
+## Activating Agents
+
+BMAD agents are installed as slash commands in `.claude/commands/bmad/`.
+
+### How to Use
+
+1. **Type Slash Command**: Start with `/` to see available commands
+2. **Select Agent**: Type `/bmad-{agent-name}` (e.g., `/bmad-dev`)
+3. **Execute**: Press Enter to activate that agent persona
+
+### Examples
+
+```
+/bmad:bmm:agents:dev - Activate development agent
+/bmad:bmm:agents:architect - Activate architect agent
+/bmad:bmm:workflows:dev-story - Execute dev-story workflow
+```
+
+### Notes
+
+- Commands are autocompleted when you type `/`
+- Agent remains active for the conversation
+- Start a new conversation to switch agents

docs/ide-info/cline.md

@@ -0,0 +1,31 @@
+# BMAD Method - Cline Instructions
+
+## Activating Agents
+
+BMAD agents are installed as **toggleable rules** in `.clinerules/` directory.
+
+### Important: Rules are OFF by default
+
+- Rules are NOT automatically loaded to avoid context pollution
+- You must manually enable the agent you want to use
+
+### How to Use
+
+1. **Open Rules Panel**: Click the rules icon below the chat input
+2. **Enable an Agent**: Toggle ON the specific agent rule you need (e.g., `01-core-dev`)
+3. **Activate in Chat**: Type `@{agent-name}` to activate that persona
+4. **Disable When Done**: Toggle OFF to free up context
+
+### Best Practices
+
+- Only enable 1-2 agents at a time to preserve context
+- Disable agents when switching tasks
+- Rules are numbered (01-, 02-) for organization, not priority
+
+### Example
+
+```
+Toggle ON: 01-core-dev.md
+In chat: "@dev help me refactor this code"
+When done: Toggle OFF the rule
+```

docs/ide-info/codex.md

@@ -0,0 +1,21 @@
+# BMAD Method - Codex Instructions
+
+## Activating Agents
+
+BMAD agents, tasks and workflows are installed as custom prompts in
+`$CODEX_HOME/prompts/bmad-*.md` files. If `CODEX_HOME` is not set, it
+defaults to `$HOME/.codex/`.
+
+### Examples
+
+```
+/bmad-bmm-agents-dev - Activate development agent
+/bmad-bmm-agents-architect - Activate architect agent
+/bmad-bmm-workflows-dev-story - Execute dev-story workflow
+```
+
+### Notes
+
+Prompts are autocompleted when you type /
+Agent remains active for the conversation
+Start a new conversation to switch agents

docs/ide-info/crush.md

@@ -0,0 +1,30 @@
+# BMAD Method - Crush Instructions
+
+## Activating Agents
+
+BMAD agents are installed as commands in `.crush/commands/bmad/`.
+
+### How to Use
+
+1. **Open Command Palette**: Use Crush command interface
+2. **Navigate**: Browse to `_bmad/{module}/agents/`
+3. **Select Agent**: Choose the agent command
+4. **Execute**: Run to activate agent persona
+
+### Command Structure
+
+```
+.crush/commands/bmad/
+├── agents/          # All agents
+├── tasks/           # All tasks
+├── core/            # Core module
+│   ├── agents/
+│   └── tasks/
+└── {module}/        # Other modules
+```
+
+### Notes
+
+- Commands organized by module
+- Can browse hierarchically
+- Agent activates for session

docs/ide-info/cursor.md

@@ -0,0 +1,25 @@
+# BMAD Method - Cursor Instructions
+
+## Activating Agents
+
+BMAD agents are installed in `.cursor/rules/bmad/` as MDC rules.
+
+### How to Use
+
+1. **Reference in Chat**: Use `@_bmad/{module}/agents/{agent-name}`
+2. **Include Entire Module**: Use `@_bmad/{module}`
+3. **Reference Index**: Use `@_bmad/index` for all available agents
+
+### Examples
+
+```
+@_bmad/core/agents/dev - Activate dev agent
+@_bmad/bmm/agents/architect - Activate architect agent
+@_bmad/core - Include all core agents/tasks
+```
+
+### Notes
+
+- Rules are Manual type - only loaded when explicitly referenced
+- No automatic context pollution
+- Can combine multiple agents: `@_bmad/core/agents/dev @_bmad/core/agents/test`

docs/ide-info/gemini.md

@@ -0,0 +1,25 @@
+# BMAD Method - Gemini CLI Instructions
+
+## Activating Agents
+
+BMAD agents are concatenated in `.gemini/bmad-method/GEMINI.md`.
+
+### How to Use
+
+1. **Type Trigger**: Use `*{agent-name}` in your prompt
+2. **Activate**: Agent persona activates from the concatenated file
+3. **Continue**: Agent remains active for conversation
+
+### Examples
+
+```
+*dev - Activate development agent
+*architect - Activate architect agent
+*test - Activate test agent
+```
+
+### Notes
+
+- All agents loaded from single GEMINI.md file
+- Triggers with asterisk: `*{agent-name}`
+- Context includes all agents (may be large)

docs/ide-info/github-copilot.md

@@ -0,0 +1,26 @@
+# BMAD Method - GitHub Copilot Instructions
+
+## Activating Agents
+
+BMAD agents are installed as chat modes in `.github/chatmodes/`.
+
+### How to Use
+
+1. **Open Chat View**: Click Copilot icon in VS Code sidebar
+2. **Select Mode**: Click mode selector (top of chat)
+3. **Choose Agent**: Select the BMAD agent from dropdown
+4. **Chat**: Agent is now active for this session
+
+### VS Code Settings
+
+Configured in `.vscode/settings.json`:
+
+- Max requests per session
+- Auto-fix enabled
+- MCP discovery enabled
+
+### Notes
+
+- Modes persist for the chat session
+- Switch modes anytime via dropdown
+- Multiple agents available in mode selector

docs/ide-info/iflow.md

@@ -0,0 +1,33 @@
+# BMAD Method - iFlow CLI Instructions
+
+## Activating Agents
+
+BMAD agents are installed as commands in `.iflow/commands/bmad/`.
+
+### How to Use
+
+1. **Access Commands**: Use iFlow command interface
+2. **Navigate**: Browse to `_bmad/agents/` or `_bmad/tasks/`
+3. **Select**: Choose the agent or task command
+4. **Execute**: Run to activate
+
+### Command Structure
+
+```
+.iflow/commands/bmad/
+├── agents/     # Agent commands
+└── tasks/      # Task commands
+```
+
+### Examples
+
+```
+/_bmad/agents/core-dev - Activate dev agent
+/_bmad/tasks/core-setup - Execute setup task
+```
+
+### Notes
+
+- Commands organized by type (agents/tasks)
+- Agent activates for session
+- Similar to Crush command structure

docs/ide-info/kilo.md

@@ -0,0 +1,24 @@
+# BMAD Method - KiloCode Instructions
+
+## Activating Agents
+
+BMAD agents are installed as custom modes in `.kilocodemodes`.
+
+### How to Use
+
+1. **Open Project**: Modes auto-load when project opens
+2. **Select Mode**: Use mode selector in KiloCode interface
+3. **Choose Agent**: Pick `bmad-{module}-{agent}` mode
+4. **Activate**: Mode is now active
+
+### Mode Format
+
+- Mode name: `bmad-{module}-{agent}`
+- Display: `{icon} {title}`
+- Example: `bmad-core-dev` shows as `🤖 Dev`
+
+### Notes
+
+- Modes persist until changed
+- Similar to Roo Code mode system
+- Icon shows in mode selector

docs/ide-info/opencode.md

@@ -0,0 +1,24 @@
+# BMAD Method - OpenCode Instructions
+
+## Activating Agents
+
+BMAD agents are installed as OpenCode agents in `.opencode/agent/BMAD/{module_name}` and workflow commands in `.opencode/command/BMAD/{module_name}`.
+
+### How to Use
+
+1. **Switch Agents**: Press **Tab** to cycle through primary agents or select using the `/agents`
+2. **Activate Agent**: Once the Agent is selected say `hello` or any prompt to activate that agent persona
+3. **Execute Commands**: Type `/bmad` to see and execute bmad workflow commands (commands allow for fuzzy matching)
+
+### Examples
+
+```
+/agents - to see a list of agents and switch between them
+/_bmad/bmm/workflows/workflow-init - Activate the workflow-init command
+```
+
+### Notes
+
+- Press **Tab** to switch between primary agents (Analyst, Architect, Dev, etc.)
+- Commands are autocompleted when you type `/` and allow for fuzzy matching
+- Workflow commands execute in current agent context, make sure you have the right agent activated before running a command

docs/ide-info/qwen.md

@@ -0,0 +1,25 @@
+# BMAD Method - Qwen Code Instructions
+
+## Activating Agents
+
+BMAD agents are concatenated in `.qwen/bmad-method/QWEN.md`.
+
+### How to Use
+
+1. **Type Trigger**: Use `*{agent-name}` in your prompt
+2. **Activate**: Agent persona activates from the concatenated file
+3. **Continue**: Agent remains active for conversation
+
+### Examples
+
+```
+*dev - Activate development agent
+*architect - Activate architect agent
+*test - Activate test agent
+```
+
+### Notes
+
+- All agents loaded from single QWEN.md file
+- Triggers with asterisk: `*{agent-name}`
+- Similar to Gemini CLI setup

docs/ide-info/roo.md

@@ -0,0 +1,27 @@
+# BMAD Method - Roo Code Instructions
+
+## Activating Agents
+
+BMAD agents are installed as custom modes in `.roomodes`.
+
+### How to Use
+
+1. **Open Project**: Modes auto-load when project opens
+2. **Select Mode**: Use mode selector in Roo interface
+3. **Choose Agent**: Pick `bmad-{module}-{agent}` mode
+4. **Activate**: Mode is now active with configured permissions
+
+### Permission Levels
+
+Modes are configured with file edit permissions:
+
+- Development files only
+- Configuration files only
+- Documentation files only
+- All files (if configured)
+
+### Notes
+
+- Modes persist until changed
+- Each mode has specific file access rights
+- Icon shows in mode selector for easy identification

docs/ide-info/rovo-dev.md

@@ -0,0 +1,388 @@
+# Rovo Dev IDE Integration
+
+This document describes how BMAD-METHOD integrates with [Atlassian Rovo Dev](https://www.atlassian.com/rovo-dev), an AI-powered software development assistant.
+
+## Overview
+
+Rovo Dev is designed to integrate deeply with developer workflows and organizational knowledge bases. When you install BMAD-METHOD in a Rovo Dev project, it automatically installs BMAD agents, workflows, tasks, and tools just like it does for other IDEs (Cursor, VS Code, etc.).
+
+BMAD-METHOD provides:
+
+- **Agents**: Specialized subagents for various development tasks
+- **Workflows**: Multi-step workflow guides and coordinators
+- **Tasks & Tools**: Reference documentation for BMAD tasks and tools
+
+### What are Rovo Dev Subagents?
+
+Subagents are specialized agents that Rovo Dev can delegate tasks to. They are defined as Markdown files with YAML frontmatter stored in the `.rovodev/subagents/` directory. Rovo Dev automatically discovers these files and makes them available through the `@subagent-name` syntax.
+
+## Installation and Setup
+
+### Automatic Installation
+
+When you run the BMAD-METHOD installer and select Rovo Dev as your IDE:
+
+```bash
+bmad install
+```
+
+The installer will:
+
+1. Create a `.rovodev/subagents/` directory in your project (if it doesn't exist)
+2. Convert BMAD agents into Rovo Dev subagent format
+3. Write subagent files with the naming pattern: `bmad-<module>-<agent-name>.md`
+
+### File Structure
+
+After installation, your project will have:
+
+```
+project-root/
+├── .rovodev/
+│   ├── subagents/
+│   │   ├── bmad-core-code-reviewer.md
+│   │   ├── bmad-bmm-pm.md
+│   │   ├── bmad-bmm-dev.md
+│   │   └── ... (more agents from selected modules)
+│   ├── workflows/
+│   │   ├── bmad-brainstorming.md
+│   │   ├── bmad-prd-creation.md
+│   │   └── ... (workflow guides)
+│   ├── references/
+│   │   ├── bmad-task-core-code-review.md
+│   │   ├── bmad-tool-core-analysis.md
+│   │   └── ... (task/tool references)
+│   ├── config.yml          (Rovo Dev configuration)
+│   ├── prompts.yml         (Optional: reusable prompts)
+│   └── ...
+├── _bmad/                  (BMAD installation directory)
+└── ...
+```
+
+**Directory Structure Explanation:**
+
+- **subagents/**: Agents discovered and used by Rovo Dev with `@agent-name` syntax
+- **workflows/**: Multi-step workflow guides and instructions
+- **references/**: Documentation for available tasks and tools in BMAD
+
+## Subagent File Format
+
+BMAD agents are converted to Rovo Dev subagent format, which uses Markdown with YAML frontmatter:
+
+### Basic Structure
+
+```markdown
+---
+name: bmad-module-agent-name
+description: One sentence description of what this agent does
+tools:
+  - bash
+  - open_files
+  - grep
+  - expand_code_chunks
+model: anthropic.claude-3-5-sonnet-20241022-v2:0 # Optional
+load_memory: true # Optional
+---
+
+You are a specialized agent for [specific task].
+
+## Your Role
+
+Describe the agent's role and responsibilities...
+
+## Key Instructions
+
+1. First instruction
+2. Second instruction
+3. Third instruction
+
+## When to Use This Agent
+
+Explain when and how to use this agent...
+```
+
+### YAML Frontmatter Fields
+
+| Field         | Type    | Required | Description                                                                                                                           |
+| ------------- | ------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `name`        | string  | Yes      | Unique identifier for the subagent (kebab-case, no spaces)                                                                            |
+| `description` | string  | Yes      | One-line description of the subagent's purpose                                                                                        |
+| `tools`       | array   | No       | List of tools the subagent can use. If not specified, uses parent agent's tools                                                       |
+| `model`       | string  | No       | Specific LLM model for this subagent (e.g., `anthropic.claude-3-5-sonnet-20241022-v2:0`). If not specified, uses parent agent's model |
+| `load_memory` | boolean | No       | Whether to load default memory files (AGENTS.md, AGENTS.local.md). Defaults to `true`                                                 |
+
+### System Prompt
+
+The content after the closing `---` is the subagent's system prompt. This defines:
+
+- The agent's persona and role
+- Its capabilities and constraints
+- Step-by-step instructions for task execution
+- Examples of expected behavior
+
+## Using BMAD Components in Rovo Dev
+
+### Invoking a Subagent (Agent)
+
+In Rovo Dev, you can invoke a BMAD agent as a subagent using the `@` syntax:
+
+```
+@bmad-core-code-reviewer Please review this PR for potential issues
+@bmad-bmm-pm Help plan this feature release
+@bmad-bmm-dev Implement this feature
+```
+
+### Accessing Workflows
+
+Workflow guides are available in `.rovodev/workflows/` directory:
+
+```
+@bmad-core-code-reviewer Use the brainstorming workflow from .rovodev/workflows/bmad-brainstorming.md
+```
+
+Workflow files contain step-by-step instructions and can be referenced or copied into Rovo Dev for collaborative workflow execution.
+
+### Accessing Tasks and Tools
+
+Task and tool documentation is available in `.rovodev/references/` directory. These provide:
+
+- Task execution instructions
+- Tool capabilities and usage
+- Integration examples
+- Parameter documentation
+
+### Example Usage Scenarios
+
+#### Code Review
+
+```
+@bmad-core-code-reviewer Review the changes in src/components/Button.tsx
+for best practices, performance, and potential bugs
+```
+
+#### Documentation
+
+```
+@bmad-core-documentation-writer Generate API documentation for the new
+user authentication module
+```
+
+#### Feature Design
+
+```
+@bmad-module-feature-designer Design a solution for implementing
+dark mode support across the application
+```
+
+## Customizing BMAD Subagents
+
+You can customize BMAD subagents after installation by editing their files directly in `.rovodev/subagents/`.
+
+### Example: Adding Tool Restrictions
+
+By default, BMAD subagents inherit tools from the parent Rovo Dev agent. You can restrict which tools a specific subagent can use:
+
+```yaml
+---
+name: bmad-core-code-reviewer
+description: Reviews code and suggests improvements
+tools:
+  - open_files
+  - expand_code_chunks
+  - grep
+---
+```
+
+### Example: Using a Specific Model
+
+Some agents might benefit from using a different model. You can specify this:
+
+```yaml
+---
+name: bmad-core-documentation-writer
+description: Writes clear and comprehensive documentation
+model: anthropic.claude-3-5-sonnet-20241022-v2:0
+---
+```
+
+### Example: Enhancing the System Prompt
+
+You can add additional context to a subagent's system prompt:
+
+```markdown
+---
+name: bmad-core-code-reviewer
+description: Reviews code and suggests improvements
+---
+
+You are a specialized code review agent for our project.
+
+## Project Context
+
+Our codebase uses:
+
+- React 18 for frontend
+- Node.js 18+ for backend
+- TypeScript for type safety
+- Jest for testing
+
+## Review Checklist
+
+1. Type safety and TypeScript correctness
+2. React best practices and hooks usage
+3. Performance considerations
+4. Test coverage
+5. Documentation and comments
+
+...rest of original system prompt...
+```
+
+## Memory and Context
+
+By default, BMAD subagents have `load_memory: true`, which means they will load memory files from your project:
+
+- **Project-level**: `.rovodev/AGENTS.md` and `.rovodev/.agent.md`
+- **User-level**: `~/.rovodev/AGENTS.md` (global memory across all projects)
+
+These files can contain:
+
+- Project guidelines and conventions
+- Common patterns and best practices
+- Recent decisions and context
+- Custom instructions for all agents
+
+### Creating Project Memory
+
+Create `.rovodev/AGENTS.md` in your project:
+
+```markdown
+# Project Guidelines
+
+## Code Style
+
+- Use 2-space indentation
+- Use camelCase for variables
+- Use PascalCase for classes
+
+## Architecture
+
+- Follow modular component structure
+- Use dependency injection for services
+- Implement proper error handling
+
+## Testing Requirements
+
+- Minimum 80% code coverage
+- Write tests before implementation
+- Use descriptive test names
+```
+
+## Troubleshooting
+
+### Subagents Not Appearing in Rovo Dev
+
+1. **Verify files exist**: Check that `.rovodev/subagents/bmad-*.md` files are present
+2. **Check Rovo Dev is reloaded**: Rovo Dev may cache agent definitions. Restart Rovo Dev or reload the project
+3. **Verify file format**: Ensure files have proper YAML frontmatter (between `---` markers)
+4. **Check file permissions**: Ensure files are readable by Rovo Dev
+
+### Agent Name Conflicts
+
+If you have custom subagents with the same names as BMAD agents, Rovo Dev will load both but may show a warning. Use unique prefixes for custom subagents to avoid conflicts.
+
+### Tools Not Available
+
+If a subagent's tools aren't working:
+
+1. Verify the tool names match Rovo Dev's available tools
+2. Check that the parent Rovo Dev agent has access to those tools
+3. Ensure tool permissions are properly configured in `.rovodev/config.yml`
+
+## Advanced: Tool Configuration
+
+Rovo Dev agents have access to a set of tools for various tasks. Common tools available include:
+
+- `bash`: Execute shell commands
+- `open_files`: View file contents
+- `grep`: Search across files
+- `expand_code_chunks`: View specific code sections
+- `find_and_replace_code`: Modify files
+- `create_file`: Create new files
+- `delete_file`: Delete files
+- `move_file`: Rename or move files
+
+### MCP Servers
+
+Rovo Dev can also connect to Model Context Protocol (MCP) servers, which provide additional tools and data sources:
+
+- **Atlassian Integration**: Access to Jira, Confluence, and Bitbucket
+- **Code Analysis**: Custom code analysis and metrics
+- **External Services**: APIs and third-party integrations
+
+Configure MCP servers in `~/.rovodev/mcp.json` or `.rovodev/mcp.json`.
+
+## Integration with Other IDE Handlers
+
+BMAD-METHOD supports multiple IDEs simultaneously. You can have both Rovo Dev and other IDE configurations (Cursor, VS Code, etc.) in the same project. Each IDE will have its own artifacts installed in separate directories.
+
+For example:
+
+- Rovo Dev agents: `.rovodev/subagents/bmad-*.md`
+- Cursor rules: `.cursor/rules/bmad/`
+- Claude Code: `.claude/rules/bmad/`
+
+## Performance Considerations
+
+- BMAD subagent files are typically small (1-5 KB each)
+- Rovo Dev lazy-loads subagents, so having many subagents doesn't impact startup time
+- System prompts are cached by Rovo Dev after first load
+
+## Best Practices
+
+1. **Keep System Prompts Concise**: Shorter, well-structured prompts are more effective
+2. **Use Project Memory**: Leverage `.rovodev/AGENTS.md` for shared context
+3. **Customize Tool Restrictions**: Give subagents only the tools they need
+4. **Test Subagent Invocations**: Verify each subagent works as expected for your project
+5. **Version Control**: Commit `.rovodev/subagents/` to version control for team consistency
+6. **Document Custom Subagents**: Add comments explaining the purpose of customized subagents
+
+## Related Documentation
+
+- [Rovo Dev Official Documentation](https://www.atlassian.com/rovo-dev)
+- [BMAD-METHOD Installation Guide](./installation.md)
+- [IDE Handler Architecture](./ide-handlers.md)
+- [Rovo Dev Configuration Reference](https://www.atlassian.com/rovo-dev/configuration)
+
+## Examples
+
+### Example 1: Code Review Workflow
+
+```
+User: @bmad-core-code-reviewer Review src/auth/login.ts for security issues
+Rovo Dev → Subagent: Opens file, analyzes code, suggests improvements
+Subagent output: Security vulnerabilities found, recommendations provided
+```
+
+### Example 2: Documentation Generation
+
+```
+User: @bmad-core-documentation-writer Generate API docs for the new payment module
+Rovo Dev → Subagent: Analyzes code structure, generates documentation
+Subagent output: Markdown documentation with examples and API reference
+```
+
+### Example 3: Architecture Design
+
+```
+User: @bmad-module-feature-designer Design a caching strategy for the database layer
+Rovo Dev → Subagent: Reviews current architecture, proposes design
+Subagent output: Detailed architecture proposal with implementation plan
+```
+
+## Support
+
+For issues or questions about:
+
+- **Rovo Dev**: See [Atlassian Rovo Dev Documentation](https://www.atlassian.com/rovo-dev)
+- **BMAD-METHOD**: See [BMAD-METHOD README](../README.md)
+- **IDE Integration**: See [IDE Handler Guide](./ide-handlers.md)

docs/ide-info/trae.md

@@ -0,0 +1,25 @@
+# BMAD Method - Trae Instructions
+
+## Activating Agents
+
+BMAD agents are installed as rules in `.trae/rules/`.
+
+### How to Use
+
+1. **Type Trigger**: Use `@{agent-name}` in your prompt
+2. **Activate**: Agent persona activates automatically
+3. **Continue**: Agent remains active for conversation
+
+### Examples
+
+```
+@dev - Activate development agent
+@architect - Activate architect agent
+@task-setup - Execute setup task
+```
+
+### Notes
+
+- Rules auto-load from `.trae/rules/` directory
+- Multiple agents can be referenced: `@dev and @test`
+- Agent follows YAML configuration in rule file

docs/ide-info/windsurf.md

@@ -0,0 +1,22 @@
+# BMAD Method - Windsurf Instructions
+
+## Activating Agents
+
+BMAD agents are installed as workflows in `.windsurf/workflows/`.
+
+### How to Use
+
+1. **Open Workflows**: Access via Windsurf menu or command palette
+2. **Select Workflow**: Choose the agent/task workflow
+3. **Execute**: Run to activate that agent persona
+
+### Workflow Types
+
+- **Agent workflows**: `{module}-{agent}.md` (auto_execution_mode: 3)
+- **Task workflows**: `task-{module}-{task}.md` (auto_execution_mode: 2)
+
+### Notes
+
+- Agents run with higher autonomy (mode 3)
+- Tasks run with guided execution (mode 2)
+- Workflows persist for the session

docs/index.md

@@ -1,108 +1,152 @@
 # BMad Documentation Index
 
-## Core Documentation
+Complete map of all BMad Method v6 documentation with recommended reading paths.
+
+---
+
+## 🎯 Getting Started (Start Here!)
+
+**New users:** Start with one of these based on your situation:
+
+| Your Situation         | Start Here                                                      | Then Read                                                     |
+| ---------------------- | --------------------------------------------------------------- | ------------------------------------------------------------- |
+| **Brand new to BMad**  | [Quick Start Guide](../src/modules/bmm/docs/quick-start.md)     | [BMM Workflows Guide](../src/modules/bmm/workflows/README.md) |
+| **Upgrading from v4**  | [v4 to v6 Upgrade Guide](./v4-to-v6-upgrade.md)                 | [Quick Start Guide](../src/modules/bmm/docs/quick-start.md)   |
+| **Brownfield project** | [Brownfield Guide](../src/modules/bmm/docs/brownfield-guide.md) | [Quick Start Guide](../src/modules/bmm/docs/quick-start.md)   |
+
+---
+
+## 📋 Core Documentation
 
 ### Project-Level Docs (Root)
 
-- **[README.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/README.md)** - Main project overview, feature summary, and module introductions
-- **[CONTRIBUTING.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CONTRIBUTING.md)** - How to contribute, pull request guidelines, code style
-- **[CHANGELOG.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CHANGELOG.md)** - Version history and breaking changes
+- **[README.md](../README.md)** - Main project overview, feature summary, and module introductions
+- **[CONTRIBUTING.md](../CONTRIBUTING.md)** - How to contribute, pull request guidelines, code style
+- **[CHANGELOG.md](../CHANGELOG.md)** - Version history and breaking changes
+- **[CLAUDE.md](../CLAUDE.md)** - Claude Code specific guidelines for this project
 
 ### Installation & Setup
 
-- **[Quick Installation](./installing-bmad.md)** - Add BMad official and custom modules to a project folder.
 - **[v4 to v6 Upgrade Guide](./v4-to-v6-upgrade.md)** - Migration path for v4 users
-- **[Document Sharding Guide](modules/core/document-sharding-guide.md)** - Split large documents
-- **[Bundle Distribution Setup](../tools/docs/BUNDLE_DISTRIBUTION_SETUP.md)** - (temporarily non-functional) Maintainer guide for bundle auto-publishing
+- **[Document Sharding Guide](./document-sharding-guide.md)** - Split large documents for 90%+ token savings
+- **[Web Bundles](./USING_WEB_BUNDLES.md)** - Use BMAD agents in Claude Projects, ChatGPT, or Gemini without installation
+- **[Bundle Distribution Setup](./BUNDLE_DISTRIBUTION_SETUP.md)** - Maintainer guide for bundle auto-publishing
 
-## Module Documentation
+---
 
-### Core Module Global Entities
-
-- **[Core Module Index](./modules/core/index)** — Shared functionality available to all modules
-  - [Global Core Config](./modules/core/global-core-config.md) — Inheritable configuration impacting all modules and custom content
-  - [Core Workflows](./modules/core/core-workflows.md) — Domain-agnostic workflows usable by any module
-    - [Party Mode](./modules/core/party-mode.md) — Multi-agent conversation orchestration
-    - [Brainstorming](./modules/core/brainstorming.md) — Structured creative sessions with 60+ techniques
-    - [Advanced Elicitation](./modules/core/advanced-elicitation.md) — LLM rethinking with 50+ reasoning methods
-  - [Core Tasks](./modules/core/core-tasks.md) — Common tasks available across modules
-    - [Index Docs](./modules/core/core-tasks.md#index-docs) — Generate directory index files
-    - [Adversarial Review](./modules/core/core-tasks.md#adversarial-review-general) — Critical content review
-    - [Shard Document](./modules/core/core-tasks.md#shard-document) — Split large documents into sections
+## 🏗️ Module Documentation
 
 ### BMad Method (BMM) - Software & Game Development
 
 The flagship module for agile AI-driven development.
 
-- **[BMM Module Index](./modules/bmm-bmad-method/index)** - Module overview, agents, and complete documentation index
-  - [Quick Start Guide](./modules/bmm-bmad-method/quick-start) - Step-by-step guide to building your first project
-  - [Quick Spec Flow](./modules/bmm-bmad-method/quick-spec-flow) - Rapid Level 0-1 development
-  - [Brownfield Guide](./modules/bmm-bmad-method/brownfield-guide) - Working with existing codebases
-- **[BMM Workflows Guide](./modules/bmm-bmad-method/index#-workflow-guides)** - **ESSENTIAL READING**
-- **[Test Architect Guide](./modules/bmm-bmad-method/test-architecture)** - Testing strategy and quality assurance
+- **[BMM Module README](../src/modules/bmm/README.md)** - Module overview, agents, and complete documentation index
+- **[BMM Documentation](../src/modules/bmm/docs/)** - All BMM-specific guides and references:
+  - [Quick Start Guide](../src/modules/bmm/docs/quick-start.md) - Step-by-step guide to building your first project
+  - [Quick Spec Flow](../src/modules/bmm/docs/quick-spec-flow.md) - Rapid Level 0-1 development
+  - [Scale Adaptive System](../src/modules/bmm/docs/scale-adaptive-system.md) - Understanding the 5-level system
+  - [Brownfield Guide](../src/modules/bmm/docs/brownfield-guide.md) - Working with existing codebases
+- **[BMM Workflows Guide](../src/modules/bmm/workflows/README.md)** - **ESSENTIAL READING**
+- **[Test Architect Guide](../src/modules/bmm/testarch/README.md)** - Testing strategy and quality assurance
 
 ### BMad Builder (BMB) - Create Custom Solutions
 
 Build your own agents, workflows, and modules.
 
-- **[BMB Module Overview](./modules/bmb-bmad-builder/index)** - Module overview and capabilities
-- **[Custom Content Guide](./modules/bmb-bmad-builder/custom-content)** - Design custom agents, workflows, and modules
-- **[How to Install Custom Agents, Workflows and Modules](./modules/bmb-bmad-builder/custom-content-installation.md)** - Share and Install Custom Creations
+- **[BMB Module README](../src/modules/bmb/docs/README.md)** - Module overview and capabilities
+- **[Agent Creation Guide](../src/modules/bmb/workflows/create-agent/README.md)** - Design custom agents
 
 ### Creative Intelligence Suite (CIS) - Innovation & Creativity
 
-- **[CIS Docs](./modules/cis-creative-intelligence-suite/index.md)**
-
-#### Bmad Game Dev (BMGD)
-
-- [Main Game Dev Module Docs Index](./modules/bmgd-bmad-game-dev/index.md)
-
 AI-powered creative thinking and brainstorming.
 
-- **[CIS Module README](./modules/cis-creative-intelligence-suite/index)** - Module overview and workflows
+- **[CIS Module README](../src/modules/cis/README.md)** - Module overview and workflows
 
-## Advanced Topics
+---
+
+## 🖥️ IDE-Specific Guides
+
+Instructions for loading agents and running workflows in your development environment.
+
+**Popular IDEs:**
+
+- [Claude Code](./ide-info/claude-code.md)
+- [Cursor](./ide-info/cursor.md)
+- [VS Code](./ide-info/windsurf.md)
+
+**Other Supported IDEs:**
+
+- [Augment](./ide-info/auggie.md)
+- [Cline](./ide-info/cline.md)
+- [Codex](./ide-info/codex.md)
+- [Crush](./ide-info/crush.md)
+- [Gemini](./ide-info/gemini.md)
+- [GitHub Copilot](./ide-info/github-copilot.md)
+- [IFlow](./ide-info/iflow.md)
+- [Kilo](./ide-info/kilo.md)
+- [OpenCode](./ide-info/opencode.md)
+- [Qwen](./ide-info/qwen.md)
+- [Roo](./ide-info/roo.md)
+- [Rovo Dev](./ide-info/rovo-dev.md)
+- [Trae](./ide-info/trae.md)
+
+**Key concept:** Every reference to "load an agent" or "activate an agent" in the main docs links to the [ide-info](./ide-info/) directory for IDE-specific instructions.
+
+---
+
+## 🔧 Advanced Topics
 
 ### Custom Agents, Workflow and Modules
-- **[Custom Content Installation](modules/bmb-bmad-builder/custom-content-installation.md)** - Install and personalize agents, workflows and modules with the default bmad-method installer!
-- [Agent Customization Guide](./bmad-customization/agent-customization-guide.md) - Customize agent behavior and responses
-- [Workflow Customization Guide](./bmad-customization/workflow-customization-guide.md) - Customize and Optimize workflows with step replacement and hooks (Capability Coming Soon)
 
-## Recommended Reading Paths
+- **[Custom Content Installation](./custom-content-installation.md)** - Install and personalize agents, workflows and modules with the default bmad-method installer!
+- [Agent Customization Guide](./agent-customization-guide.md) - Customize agent behavior and responses
+
+### Installation & Bundling
+
+- [IDE Injections Reference](./installers-bundlers/ide-injections.md) - How agents are installed to IDEs
+- [Installers & Platforms Reference](./installers-bundlers/installers-modules-platforms-reference.md) - CLI tool and platform support
+- [Web Bundler Usage](./installers-bundlers/web-bundler-usage.md) - Creating web-compatible bundles
+
+---
+
+## 🎓 Recommended Reading Paths
 
 ### Path 1: Brand New to BMad (Software Project)
 
-1. [README.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/README.md) - Understand the vision
-2. [Quick Start Guide](./modules/bmm-bmad-method/quick-start) - Get hands-on
-3. [BMM Module README](./modules/bmm-bmad-method/) - Understand agents
-4. [BMM Workflows Guide](./modules/bmm-bmad-method/index#-workflow-guides) - Master the methodology
+1. [README.md](../README.md) - Understand the vision
+2. [Quick Start Guide](../src/modules/bmm/docs/quick-start.md) - Get hands-on
+3. [BMM Module README](../src/modules/bmm/README.md) - Understand agents
+4. [BMM Workflows Guide](../src/modules/bmm/workflows/README.md) - Master the methodology
+5. [Your IDE guide](./ide-info/) - Optimize your workflow
 
 ### Path 2: Game Development Project
 
-1. [README.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/README.md) - Understand the vision
-2. [Quick Start Guide](./modules/bmm-bmad-method/quick-start) - Get hands-on
-3. [BMGD Workflows Guide](./modules/bmgd-bmad-game-dev/workflows-guide) - Game-specific workflows
+1. [README.md](../README.md) - Understand the vision
+2. [Quick Start Guide](../src/modules/bmm/docs/quick-start.md) - Get hands-on
+3. [BMM Module README](../src/modules/bmm/README.md) - Game agents are included
+4. [BMM Workflows Guide](../src/modules/bmm/workflows/README.md) - Game workflows
+5. [Your IDE guide](./ide-info/) - Optimize your workflow
 
 ### Path 3: Upgrading from v4
 
 1. [v4 to v6 Upgrade Guide](./v4-to-v6-upgrade.md) - Understand what changed
-2. [Quick Start Guide](./modules/bmm-bmad-method/quick-start) - Reorient yourself
-3. [BMM Workflows Guide](./modules/bmm-bmad-method/index#-workflow-guides) - Learn new v6 workflows
+2. [Quick Start Guide](../src/modules/bmm/docs/quick-start.md) - Reorient yourself
+3. [BMM Workflows Guide](../src/modules/bmm/workflows/README.md) - Learn new v6 workflows
 
 ### Path 4: Working with Existing Codebase (Brownfield)
 
-1. [Brownfield Guide](./modules/bmm-bmad-method/brownfield-guide) - Approach for legacy code
-2. [Quick Start Guide](./modules/bmm-bmad-method/quick-start) - Follow the process
-3. [BMM Workflows Guide](./modules/bmm-bmad-method/index#-workflow-guides) - Master the methodology
+1. [Brownfield Guide](../src/modules/bmm/docs/brownfield-guide.md) - Approach for legacy code
+2. [Quick Start Guide](../src/modules/bmm/docs/quick-start.md) - Follow the process
+3. [BMM Workflows Guide](../src/modules/bmm/workflows/README.md) - Master the methodology
 
 ### Path 5: Building Custom Solutions
 
-1. [BMB Module Overview](./modules/bmb-bmad-builder/index) - Understand capabilities
-2. [BMB Custom Content Types](./modules/bmb-bmad-builder/custom-content.md) - Understand the different types and whats possible
-3. [BMB Content Installation](./modules/bmb-bmad-builder/custom-content-installation.md) - How to bundle install use and share
-4. More Docs coming soon....
+1. [BMB Module README](../src/modules/bmb/docs/README.md) - Understand capabilities
+2. [Agent Creation Guide](../src/modules/bmb/workflows/create-agent/README.md) - Create agents
+3. [BMM Workflows Guide](../src/modules/bmm/workflows/README.md) - Understand workflow structure
 
 ### Path 6: Contributing to BMad
 
-1. [CONTRIBUTING.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CONTRIBUTING.md) - Contribution guidelines
+1. [CONTRIBUTING.md](../CONTRIBUTING.md) - Contribution guidelines
 2. Relevant module README - Understand the area you're contributing to
+3. [Code Style section in CONTRIBUTING.md](../CONTRIBUTING.md#code-style) - Follow standards

docs/installers-bundlers/ide-injections.md

@@ -0,0 +1,186 @@
+# IDE Content Injection Standard
+
+## Overview
+
+This document defines the standard for IDE-specific content injection in BMAD modules. Each IDE can inject its own specific content into BMAD templates during installation without polluting the source files with IDE-specific code. The installation process is interactive, allowing users to choose what IDE-specific features they want to install.
+
+## Architecture
+
+### 1. Injection Points
+
+Files that support IDE-specific content define injection points using HTML comments:
+
+```xml
+<!-- IDE-INJECT-POINT: unique-point-name -->
+```
+
+### 2. Module Structure
+
+Each module that needs IDE-specific content creates a sub-module folder:
+
+```
+src/modules/{module-name}/sub-modules/{ide-name}/
+  ├── injections.yaml    # Injection configuration
+  ├── sub-agents/        # IDE-specific subagents (if applicable)
+  └── config.yaml        # Other IDE-specific config
+```
+
+### 3. Injection Configuration Format
+
+The `injections.yaml` file defines what content to inject where:
+
+```yaml
+# injections.yaml structure
+injections:
+  - file: 'relative/path/to/file.md' # Path relative to installation root
+    point: 'injection-point-name' # Must match IDE-INJECT-POINT name
+    requires: 'subagent-name' # Which subagent must be selected (or "any")
+    content: | # Content to inject (preserves formatting)
+      <llm>
+        <i>Instructions specific to this IDE</i>
+      </llm>
+
+# Subagents available for installation
+subagents:
+  source: 'sub-agents' # Source folder relative to this config
+  target: '.claude/agents' # Claude's expected location (don't change)
+  files:
+    - 'agent1.md'
+    - 'agent2.md'
+```
+
+### 4. Interactive Installation Process
+
+For Claude Code specifically, the installer will:
+
+1. **Detect available subagents** from the module's `injections.yaml`
+2. **Ask the user** about subagent installation:
+   - Install all subagents (default)
+   - Select specific subagents
+   - Skip subagent installation
+3. **Ask installation location** (if subagents selected):
+   - Project level: `.claude/agents/`
+   - User level: `~/.claude/agents/`
+4. **Copy selected subagents** to the chosen location
+5. **Inject only relevant content** based on selected subagents
+
+Other IDEs can implement their own installation logic appropriate to their architecture.
+
+## Implementation
+
+### IDE Installer Responsibilities
+
+Each IDE installer (e.g., `claude-code.js`) must:
+
+1. **Check for sub-modules**: Look for `sub-modules/{ide-name}/` in each installed module
+2. **Load injection config**: Parse `injections.yaml` if present
+3. **Process injections**: Replace injection points with configured content
+4. **Copy additional files**: Handle subagents or other IDE-specific files
+
+### Example Implementation (Claude Code)
+
+```javascript
+async processModuleInjections(projectDir, bmadDir, options) {
+  for (const moduleName of options.selectedModules) {
+    const configPath = path.join(
+      bmadDir, 'src/modules', moduleName,
+      'sub-modules/claude-code/injections.yaml'
+    );
+
+    if (exists(configPath)) {
+      const config = yaml.load(configPath);
+
+      // Interactive: Ask user about subagent installation
+      const choices = await this.promptSubagentInstallation(config.subagents);
+
+      if (choices.install !== 'none') {
+        // Ask where to install
+        const location = await this.promptInstallLocation();
+
+        // Process injections based on selections
+        for (const injection of config.injections) {
+          if (this.shouldInject(injection, choices)) {
+            await this.injectContent(projectDir, injection, choices);
+          }
+        }
+
+        // Copy selected subagents
+        await this.copySelectedSubagents(projectDir, config.subagents, choices, location);
+      }
+    }
+  }
+}
+```
+
+## Benefits
+
+1. **Clean Source Files**: No IDE-specific conditionals in source
+2. **Modular**: Each IDE manages its own injections
+3. **Scalable**: Easy to add support for new IDEs
+4. **Maintainable**: IDE-specific content lives with IDE config
+5. **Flexible**: Different modules can inject different content
+
+## Adding Support for a New IDE
+
+1. Create sub-module folder: `src/modules/{module}/sub-modules/{new-ide}/`
+2. Add `injections.yaml` with IDE-specific content
+3. Update IDE installer to process injections using this standard
+4. Test installation with and without the IDE selected
+
+## Example: BMM Module with Claude Code
+
+### File Structure
+
+```
+src/modules/bmm/
+├── agents/pm.md                         # Has injection point
+├── templates/prd.md                     # Has multiple injection points
+└── sub-modules/
+    └── claude-code/
+        ├── injections.yaml              # Defines what to inject
+        └── sub-agents/                  # Claude Code specific subagents
+            ├── market-researcher.md
+            ├── requirements-analyst.md
+            └── ...
+```
+
+### Injection Point in pm.md
+
+```xml
+<agent>
+  <persona>...</persona>
+  <!-- IDE-INJECT-POINT: pm-agent-instructions -->
+  <cmds>...</cmds>
+</agent>
+```
+
+### Injection Configuration
+
+```yaml
+injections:
+  - file: '_bmad/bmm/agents/pm.md'
+    point: 'pm-agent-instructions'
+    requires: 'any' # Injected if ANY subagent is selected
+    content: |
+      <llm critical="true">
+        <i>Use 'market-researcher' subagent for analysis</i>
+      </llm>
+
+  - file: '_bmad/bmm/templates/prd.md'
+    point: 'prd-goals-context-delegation'
+    requires: 'market-researcher' # Only if this specific subagent selected
+    content: |
+      <i>DELEGATE: Use 'market-researcher' subagent...</i>
+```
+
+### Result After Installation
+
+```xml
+<agent>
+  <persona>...</persona>
+  <llm critical="true">
+    <i>Use 'market-researcher' subagent for analysis</i>
+  </llm>
+  <cmds>...</cmds>
+</agent>
+```

docs/installers-bundlers/installers-modules-platforms-reference.md

@@ -0,0 +1,389 @@
+# BMAD Installation & Module System Reference
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Quick Start](#quick-start)
+3. [Architecture](#architecture)
+4. [Modules](#modules)
+5. [Configuration System](#configuration-system)
+6. [Platform Integration](#platform-integration)
+7. [Development Guide](#development-guide)
+8. [Troubleshooting](#troubleshooting)
+
+## Overview
+
+BMad Core is a modular AI agent framework with intelligent installation, platform-agnostic support, and configuration inheritance.
+
+### Key Features
+
+- **Modular Design**: Core + optional modules (BMB, BMM, CIS)
+- **Smart Installation**: Interactive configuration with dependency resolution
+- **Clean Architecture**: Centralized `_bmad` directory add to project, no source pollution with multiple folders added
+
+## Architecture
+
+### Directory Structure upon installation
+
+```
+project-root/
+├── _bmad/             # Centralized installation
+│   ├── _config/                  # Configuration
+│   │   ├── agents/            # Agent configs
+│   │   └── agent-manifest.csv # Agent manifest
+│   ├── core/                  # Core module
+│   │   ├── agents/
+│   │   ├── tasks/
+│   │   └── config.yaml
+│   ├── bmm/                   # BMad Method module
+│   │   ├── agents/
+│   │   ├── tasks/
+│   │   ├── workflows/
+│   │   └── config.yaml
+│   └── cis/                   # Creative Innovation Studio
+│       └── ...
+└── .claude/                   # Platform-specific (example)
+    └── agents/
+```
+
+### Installation Flow
+
+1. **Detection**: Check existing installation
+2. **Selection**: Choose modules interactively or via CLI
+3. **Configuration**: Collect module-specific settings
+4. **Installation**: Compile Process and copy files
+5. **Generation**: Create config files with inheritance
+6. **Post-Install**: Run module installers
+7. **Manifest**: Track installed components
+
+### Key Exclusions
+
+- `_module-installer/` directories are never copied to destination
+- module.yaml
+- `localskip="true"` agents are filtered out
+- Source `config.yaml` templates are replaced with generated configs
+
+## Modules
+
+### Core Module (Required)
+
+Foundation framework with C.O.R.E. (Collaboration Optimized Reflection Engine)
+
+- **Components**: Base agents, activation system, advanced elicitation
+- **Config**: `user_name`, `communication_language`
+
+### BMM Module
+
+BMad Method for software development workflows
+
+- **Components**: PM agent, dev tasks, PRD templates, story generation
+- **Config**: `project_name`, `tech_docs`, `output_folder`, `story_location`
+- **Dependencies**: Core
+
+### CIS Module
+
+Creative Innovation Studio for design workflows
+
+- **Components**: Design agents, creative tasks
+- **Config**: `output_folder`, design preferences
+- **Dependencies**: Core
+
+### Module Structure
+
+```
+src/modules/{module}/
+├── _module-installer/       # Not copied to destination
+│   ├── installer.js         # Post-install logic
+├── module.yaml
+├── agents/
+├── tasks/
+├── templates/
+└── sub-modules/            # Platform-specific content
+    └── {platform}/
+        ├── injections.yaml
+        └── sub-agents/
+```
+
+## Configuration System
+
+### Collection Process
+
+Modules define prompts in `module.yaml`:
+
+```yaml
+project_name:
+  prompt: 'Project title?'
+  default: 'My Project'
+  result: '{value}'
+
+output_folder:
+  prompt: 'Output location?'
+  default: 'docs'
+  result: '{project-root}/{value}'
+
+tools:
+  prompt: 'Select tools:'
+  multi-select:
+    - 'Tool A'
+    - 'Tool B'
+```
+
+### Configuration Inheritance
+
+Core values cascade to ALL modules automatically:
+
+```yaml
+# core/config.yaml
+user_name: "Jane"
+communication_language: "English"
+
+# bmm/config.yaml (generated)
+project_name: "My App"
+tech_docs: "/path/to/docs"
+# Core Configuration Values (inherited)
+user_name: "Jane"
+communication_language: "English"
+```
+
+**Reserved Keys**: Core configuration keys cannot be redefined by other modules.
+
+### Path Placeholders
+
+- `{project-root}`: Project directory path
+- `{value}`: User input
+- `{module}`: Module name
+- `{core:field}`: Reference core config value
+
+### Config Generation Rules
+
+1. ALL installed modules get a `config.yaml` (even without prompts)
+2. Core values are ALWAYS included in module configs
+3. Module-specific values come first, core values appended
+4. Source templates are never copied, only generated configs
+
+## Platform Integration
+
+### Supported Platforms
+
+**Preferred** (Full Integration):
+
+- Claude Code
+- Cursor
+- Windsurf
+
+**Additional**:
+Cline, Roo, Rovo Dev,Auggie, GitHub Copilot, Codex, Gemini, Qwen, Trae, Kilo, Crush, iFlow
+
+### Platform Features
+
+1. **Setup Handler** (`tools/cli/installers/lib/ide/{platform}.js`)
+   - Directory creation
+   - Configuration generation
+   - Agent processing
+
+2. **Content Injection** (`sub-modules/{platform}/injections.yaml`)
+
+   ```yaml
+   injections:
+     - file: '_bmad/bmm/agents/pm.md'
+       point: 'pm-agent-instructions'
+       content: |
+         <i>Platform-specific instruction</i>
+
+   subagents:
+     source: 'sub-agents'
+     target: '.claude/agents'
+     files: ['agent.md']
+   ```
+
+3. **Interactive Config**
+   - Subagent selection
+   - Installation scope (project/user)
+   - Feature toggles
+
+### Injection System
+
+Platform-specific content without source modification:
+
+- Inject points marked in source: `<!-- IDE-INJECT-POINT:name -->`
+- Content added during installation only
+- Source files remain clean
+
+## Development Guide
+
+### Creating a Module
+
+1. **Structure**
+
+   ```
+   src/modules/mymod/
+   ├── _module-installer/
+   │   ├── installer.js
+   ├── module.yaml
+   ├── agents/
+   └── tasks/
+   ```
+
+2. **Configuration** (`module.yaml`)
+
+   ```yaml
+   code: mymod
+   name: 'My Module'
+   prompt: 'Welcome message'
+
+   setting_name:
+     prompt: 'Configure X?'
+     default: 'value'
+   ```
+
+3. **Installer** (`installer.js`)
+   ```javascript
+   async function install(options) {
+     const { projectRoot, config, installedIDEs, logger } = options;
+     // Custom logic
+     return true;
+   }
+   module.exports = { install };
+   ```
+
+### Adding Platform Support
+
+1. Create handler: `tools/cli/installers/lib/ide/myplatform.js`
+2. Extend `BaseIdeSetup` class
+3. Add sub-module: `src/modules/{mod}/sub-modules/myplatform/`
+4. Define injections and platform agents
+
+### Agent Configuration
+
+Extractable config nodes:
+
+```xml
+<agent>
+  <setting agentConfig="true">
+    Default value
+  </setting>
+</agent>
+```
+
+Generated in: `bmad/_config/agents/{module}-{agent}.md`
+
+## Troubleshooting
+
+### Common Issues
+
+| Issue                   | Solution                             |
+| ----------------------- | ------------------------------------ |
+| Existing installation   | Use `bmad update` or remove `_bmad/` |
+| Module not found        | Check `src/modules/` exists          |
+| Config not applied      | Verify `_bmad/{module}/config.yaml`  |
+| Missing config.yaml     | Fixed: All modules now get configs   |
+| Agent unavailable       | Check for `localskip="true"`         |
+| module-installer copied | Fixed: Now excluded from copy        |
+
+### Debug Commands
+
+```bash
+bmad install -v     # Verbose installation
+bmad status -v      # Detailed status
+```
+
+### Best Practices
+
+1. Run from project root
+2. Backup `_bmad/_config/` before updates
+3. Use interactive mode for guidance
+4. Review generated configs post-install
+
+## Migration from v4
+
+| v4                  | v6                   |
+| ------------------- | -------------------- |
+| Scattered files     | Centralized `_bmad/` |
+| Monolithic          | Modular              |
+| Manual config       | Interactive setup    |
+| Limited IDE support | 15+ platforms        |
+| Source modification | Clean injection      |
+
+## Technical Notes
+
+### Dependency Resolution
+
+- Direct dependencies (module → module)
+- Agent references (cross-module)
+- Template dependencies
+- Partial module installation (only required files)
+- Workflow vendoring for standalone module operation
+
+## Workflow Vendoring
+
+**Problem**: Modules that reference workflows from other modules create dependencies, forcing users to install multiple modules even when they only need one.
+
+**Solution**: Workflow vendoring allows modules to copy workflows from other modules during installation, making them fully standalone.
+
+### How It Works
+
+Agents can specify both `workflow` (source location) and `workflow-install` (destination location) in their menu items:
+
+```yaml
+menu:
+  - trigger: create-story
+    workflow: '{project-root}/_bmad/bmm/workflows/4-implementation/create-story/workflow.yaml'
+    workflow-install: '{project-root}/_bmad/bmgd/workflows/4-production/create-story/workflow.yaml'
+    description: 'Create a game feature story'
+```
+
+**During Installation:**
+
+1. **Vendoring Phase**: Before copying module files, the installer:
+   - Scans source agent YAML files for `workflow-install` attributes
+   - Copies entire workflow folders from `workflow` path to `workflow-install` path
+   - Updates vendored `workflow.yaml` files to reference target module's config
+
+2. **Compilation Phase**: When compiling agents:
+   - If `workflow-install` exists, uses its value for the `workflow` attribute
+   - `workflow-install` is build-time metadata only, never appears in final XML
+   - Compiled agent references vendored workflow location
+
+3. **Config Update**: Vendored workflows get their `config_source` updated:
+
+   ```yaml
+   # Source workflow (in bmm):
+   config_source: "{project-root}/_bmad/bmm/config.yaml"
+
+   # Vendored workflow (in bmgd):
+   config_source: "{project-root}/_bmad/bmgd/config.yaml"
+   ```
+
+**Result**: Modules become completely standalone with their own copies of needed workflows, configured for their specific use case.
+
+### Example Use Case: BMGD Module
+
+The BMad Game Development module vendors implementation workflows from BMM:
+
+- Game Dev Scrum Master agent references BMM workflows
+- During installation, workflows are copied to `bmgd/workflows/4-production/`
+- Vendored workflows use BMGD's config (with game-specific settings)
+- BMGD can be installed without BMM dependency
+
+### Benefits
+
+✅ **Module Independence** - No forced dependencies
+✅ **Clean Namespace** - Workflows live in their module
+✅ **Config Isolation** - Each module uses its own configuration
+✅ **Customization Ready** - Vendored workflows can be modified independently
+✅ **No User Confusion** - Avoid partial module installations
+
+### File Processing
+
+- Filters `localskip="true"` agents
+- Excludes `_module-installer/` directories
+- Replaces path placeholders at runtime
+- Injects activation blocks
+- Vendors cross-module workflows (see Workflow Vendoring below)
+
+### Web Bundling
+
+```bash
+bmad bundle --web           # Filter for web deployment
+npm run validate:bundles    # Validate bundles
+```

docs/installing-bmad.md

@@ -1,68 +0,0 @@
-# Installation
-
-## Quick Install
-
-```bash
-npx bmad-method install
-```
-
-This interactive installer will:
-
-1. Let you choose a location to install to
-2. Let you choose which Agentic LLM Tools you would like to use (Such as Claude Code, Cursor, Windsurf, etc...)
-3. Let you choose which official modules to install (BMad Method, Creative Intelligence suite, BMad Builder)
-4. Let you choose any custom local modules, workflows or agents to install
-5. Let you configure each module or quickly accept the default recommended settings for each selected model
-
-## Requirements
-
-- **Node.js** 20+ (for the installer)
-- **Git** (recommended for version control)
-- An **AI-powered Agent and/or IDE** or access to Claude/ChatGPT/Gemini
-
-## Module Options
-
-During installation, you'll choose which modules to install:
-
-| Module   | Description          | Best For                                              |
-| -------- | -------------------- | ----------------------------------------------------- |
-| **BMM**  | BMAD Method Core     | Software development projects                         |
-| **BMGD** | Game Development     | Game projects with specialized workflows              |
-| **CIS**  | Creative Intel Suite | Creativity Unlocking Suite, not software dev specific |
-| **BMB**  | Builder              | Creating custom agents and workflows                  |
-
-You will also be asked if you would like to install custom content (agents, workflows or modules) you have created with the BMB, or shared from others in the community.
-
-
-## Post-Installation
-
-After installation, your project will have:
-
-```
-your-project/
-├── _bmad/              # BMAD configuration and agents
-│   ├── bmm/            # Method module (if installed)
-│   ├── bmgd/           # Game dev module (if installed)
-│   ├── core/           # Always installed, includes party mode, advanced elicitation, and other core generic utils
-│   ├── {others}/       # etc...
-├── _bmad-output/       # BMAD default output folder - configurable during install
-├── .claude/            # IDE-specific setup (varies by IDE)
-└── ... your code       # maybe nothing else yet if a fresh new folder
-```
-
-## Next Steps
-
-1. **Read the [Quick Start Guide](../modules/bmm/quick-start.md)** to build your first feature
-2. **Explore [Workflows](../modules/bmm/workflows-planning.md)** to understand the methodology
-
-## Troubleshooting
-
-### Common Issues
-
-**"Command not found: npx"**
-: Install Node.js 20+ from [nodejs.org](https://nodejs.org)
-
-**"Permission denied"**
-: Run with appropriate permissions or check your npm configuration
-
-For more help, join our [Discord](https://discord.gg/bmad).

docs/modules/bmb-bmad-builder/index.md

@@ -1,55 +0,0 @@
-# BMB Module Documentation
-
-Reference documentation for building BMAD agents and workflows.
-
-## Agent Architecture
-
-Comprehensive guides for each agent type (choose based on use case):
-
-- [Understanding Agent Types](./understanding-agent-types.md) - **START HERE** - Architecture vs capability, "The Same Agent, Three Ways"
-- [Simple Agent Architecture](./simple-agent-architecture.md) - Self-contained, optimized, personality-driven
-- [Expert Agent Architecture](./expert-agent-architecture.md) - Memory, sidecar files, domain restrictions
-- Module Agent Architecture _(TODO)_ - Workflow integration, professional tools
-
-## Agent Design Patterns
-
-- [Agent Menu Patterns](./agent-menu-patterns.md) - Menu handlers, triggers, prompts, organization
-- [Agent Compilation](./agent-compilation.md) - What compiler auto-injects (AVOID DUPLICATION)
-
-## Reference Examples
-
-Production-ready examples in [bmb/reference/agents/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents):
-
-**Simple Agents** ([simple-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/simple-examples))
-
-- [commit-poet.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/simple-examples/commit-poet.agent.yaml) - Commit message artisan with style customization
-
-**Expert Agents** ([expert-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/expert-examples))
-
-- [journal-keeper/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/expert-examples/journal-keeper) - Personal journal companion with memory and pattern recognition
-
-**Module Agents** ([module-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/module-examples))
-
-- [security-engineer.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/module-examples/security-engineer.agent.yaml) - BMM security specialist with threat modeling
-- [trend-analyst.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/module-examples/trend-analyst.agent.yaml) - CIS trend intelligence expert
-
-## Installation Guide
-
-For installing standalone simple and expert agents, see:
-
-- [Custom Agent Installation](/docs/modules/bmb-bmad-builder/custom-content-installation.md)
-
-## Key Concepts
-
-### YAML to XML Compilation
-
-Agents are authored in YAML with Handlebars templating. The compiler auto-injects:
-
-1. **Frontmatter** - Name and description from metadata
-2. **Activation Block** - Steps, menu handlers, rules (YOU don't write this)
-3. **Menu Enhancement** - `*help` and `*exit` commands added automatically
-4. **Trigger Prefixing** - Your triggers auto-prefixed with `*`
-
-**Critical:** See [Agent Compilation](./agent-compilation.md) to avoid duplicating auto-injected content.
-
-Source: `tools/cli/lib/agent/compiler.js`

docs/modules/bmb-bmad-builder/workflow-vendoring-customization-inheritance.md

@@ -1,42 +0,0 @@
-# Workflow Vendoring, Customization, and Inheritance (Official Support Consing Soon)
-
-Vendoring and Inheritance of workflows are 2 ways of sharing or reutilizing workflows - but with some key distinctions and use cases.
-
-## Workflow Vendoring
-
-Workflow Vendoring allows an agent to have access to a workflow from another module, without having to install said module. At install time, the module workflow being vendored will be cloned and installed into the module that is receiving the vendored workflow the agent needs.
-
-### How to Vendor
-
-Lets assume you are building a module, and you do not want to recreate a workflow from the BMad Method, such as workflows/4-implementation/dev-story/workflow.md. Instead of copying all the context to your module, and having to maintain it over time as updates are made, you can instead use the exec-vendor menu item in your agent.
-
-From your modules agent definition, you would implement the menu item as follows in the agent:
-
-```yaml
-    - trigger: develop-story
-      exec-vendor: "{project-root}/_bmad/<source-module>/workflows/4-production/dev-story/workflow.md"
-      exec: "{project-root}/_bmad/<my-module>/workflows/dev-story/workflow.md"
-      description: "Execute Dev Story workflow, implementing tasks and tests, or performing updates to the story"
-```
-
-At install time, it will clone the workflow and all of its required assets, and the agent that gets built will have an exec to a path installed in its own module. The content gets added to the folder you specify in exec. While it does not have to exactly match the source path, you will want to ensure you are specifying the workflow.md to be in a new location (in other words in this example, dev-story would not already be the path of another custom module workflow that already exists.)
-
-## Workflow Inheritance (Official Support Coming Post Beta)
-
-Workflow Inheritance is a different concept, that allows you to modify or extend existing workflow.
-
-Party Mode from the core is an example of a workflow that is designed with inheritance in mind - customization for specific party needs. While party mode itself is generic - there might be specific agent collaborations you want to create. Without having to reinvent the whole party mode concept, or copy and paste all of its content - you could inherit from party mode to extend it to be specific.
-
-Some possible examples could be:
-
-- Retrospective
-- Sprint Planning
-- Collaborative Brainstorming Sessions
-
-## Workflow Customization (Official Support Coming Post Beta)
-
-Similar to Workflow Inheritance, Workflow Customization will soon be allowed for certain workflows that are meant to be user customized - similar in process to how agents are customized now.
-
-This will take the shape of workflows with optional hooks, configurable inputs, and the ability to replace whole at install time.
-
-For example, assume you are using the Create PRD workflow, which is comprised of 11 steps, and you want to always include specifics about your companies domain, technical landscape or something else. While project-context can be helpful with that, you can also through hooks and step overrides, have full replace steps, the key requirement being to ensure your step replace file is an exact file name match of an existing step, follows all conventions, and ends in a similar fashion to either hook back in to call the next existing step, or more custom steps that eventually hook back into the flow.

docs/modules/bmm-bmad-method/agents-guide.md

@@ -1,144 +0,0 @@
-# BMM Agents Reference
-
-Quick reference of what each agent can do based on their available commands.
-
----
-
-## Analyst (Mary) | `/bmad:bmm:agents:analyst`
-
-Business analysis and research.
-
-**Capabilities:**
-
-- `*workflow-status` - Get workflow status or initialize tracking
-- `*brainstorm-project` - Guided brainstorming session
-- `*research` - Market, domain, competitive, or technical research
-- `*product-brief` - Create a product brief (input for PRD)
-- `*document-project` - Document existing brownfield projects
-- Party mode and advanced elicitation
-
----
-
-## PM (John) | `/bmad:bmm:agents:pm`
-
-Product requirements and planning.
-
-**Capabilities:**
-
-- `*workflow-status` - Get workflow status or initialize tracking
-- `*create-prd` - Create Product Requirements Document
-- `*create-epics-and-stories` - Break PRD into epics and user stories (after Architecture)
-- `*implementation-readiness` - Validate PRD, UX, Architecture, Epics alignment
-- `*correct-course` - Course correction during implementation
-- Party mode and advanced elicitation
-
----
-
-## Architect (Winston) | `/bmad:bmm:agents:architect`
-
-System architecture and technical design.
-
-**Capabilities:**
-
-- `*workflow-status` - Get workflow status or initialize tracking
-- `*create-architecture` - Create architecture document to guide development
-- `*implementation-readiness` - Validate PRD, UX, Architecture, Epics alignment
-- `*create-excalidraw-diagram` - System architecture or technical diagrams
-- `*create-excalidraw-dataflow` - Data flow diagrams
-- Party mode and advanced elicitation
-
----
-
-## SM (Bob) | `/bmad:bmm:agents:sm`
-
-Sprint planning and story preparation.
-
-**Capabilities:**
-
-- `*sprint-planning` - Generate sprint-status.yaml from epic files
-- `*create-story` - Create story from epic (prep for development)
-- `*validate-create-story` - Validate story quality
-- `*epic-retrospective` - Team retrospective after epic completion
-- `*correct-course` - Course correction during implementation
-- Party mode and advanced elicitation
-
----
-
-## DEV (Amelia) | `/bmad:bmm:agents:dev`
-
-Story implementation and code review.
-
-**Capabilities:**
-
-- `*dev-story` - Execute story workflow (implementation with tests)
-- `*code-review` - Thorough code review
-
----
-
-## Quick Flow Solo Dev (Barry) | `/bmad:bmm:agents:quick-flow-solo-dev`
-
-Fast solo development without handoffs.
-
-**Capabilities:**
-
-- `*create-tech-spec` - Architect technical spec with implementation-ready stories
-- `*quick-dev` - Implement tech spec end-to-end solo
-- `*code-review` - Review and improve code
-
----
-
-## TEA (Murat) | `/bmad:bmm:agents:tea`
-
-Test architecture and quality strategy.
-
-**Capabilities:**
-
-- `*framework` - Initialize production-ready test framework
-- `*atdd` - Generate E2E tests first (before implementation)
-- `*automate` - Comprehensive test automation
-- `*test-design` - Create comprehensive test scenarios
-- `*trace` - Map requirements to tests, quality gate decision
-- `*nfr-assess` - Validate non-functional requirements
-- `*ci` - Scaffold CI/CD quality pipeline
-- `*test-review` - Review test quality
-
----
-
-## UX Designer (Sally) | `/bmad:bmm:agents:ux-designer`
-
-User experience and UI design.
-
-**Capabilities:**
-
-- `*create-ux-design` - Generate UX design and UI plan from PRD
-- `*validate-design` - Validate UX specification and design artifacts
-- `*create-excalidraw-wireframe` - Create website or app wireframe
-
----
-
-## Technical Writer (Paige) | `/bmad:bmm:agents:tech-writer`
-
-Technical documentation and diagrams.
-
-**Capabilities:**
-
-- `*document-project` - Comprehensive project documentation (brownfield analysis)
-- `*generate-mermaid` - Generate Mermaid diagrams (architecture, sequence, flow, ER, class, state)
-- `*create-excalidraw-flowchart` - Process and logic flow visualizations
-- `*create-excalidraw-diagram` - System architecture or technical diagrams
-- `*create-excalidraw-dataflow` - Data flow visualizations
-- `*validate-doc` - Review documentation against standards
-- `*improve-readme` - Review and improve README files
-- `*explain-concept` - Create clear technical explanations with examples
-- `*standards-guide` - Show BMAD documentation standards reference
-
----
-
-## Universal Commands
-
-Available to all agents:
-
-- `*menu` - Redisplay menu options
-- `*dismiss` - Dismiss agent
-
-Party mode is available to most agents for multi-agent collaboration.

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

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

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

@@ -1,71 +0,0 @@
-# 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)

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

@@ -1,89 +0,0 @@
-# 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.

docs/modules/core/advanced-elicitation.md

@@ -1,105 +0,0 @@
-# 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 |

docs/modules/core/brainstorming.md

@@ -1,100 +0,0 @@
-# Brainstorming
-
-**Facilitate structured creative sessions using 60+ proven ideation techniques.**
-
-The Brainstorming workflow is an interactive facilitation system that helps you unlock your own creativity. The AI acts as coach, guide, and creative partner—using proven techniques to draw out ideas and insights that are already within you.
-
-**Important:** Every idea comes from you. The workflow creates the conditions for your best thinking to emerge through guided exploration, but you are the source.
-
----
-
-## When to Use It
-
-- Breaking through creative blocks on a specific challenge
-- Generating innovative ideas for products, features, or solutions
-- Exploring a problem from completely new angles
-- Systematically developing ideas from raw concepts to actionable plans
-- Team ideation (with collaborative techniques) or personal creative exploration
-
----
-
-## How It Works
-
-### 1. Session Setup
-Define your topic, goals, and any constraints.
-
-### 2. Choose Your Approach
-
-| Approach | Description |
-|----------|-------------|
-| **User-Selected** | Browse the full technique library and pick what appeals to you |
-| **AI-Recommended** | Get customized technique suggestions based on your goals |
-| **Random Selection** | Discover unexpected methods through serendipitous technique combinations |
-| **Progressive Flow** | Journey systematically from expansive exploration to focused action planning |
-
-### 3. Interactive Facilitation
-Work through techniques with true collaborative coaching. The AI asks probing questions, builds on your ideas, and helps you think deeper—but your ideas are the source.
-
-### 4. Idea Organization
-All your generated ideas are organized into themes and prioritized.
-
-### 5. Action Planning
-Top ideas get concrete next steps, resource requirements, and success metrics.
-
----
-
-## What You Get
-
-A comprehensive session document that captures the entire journey:
-
-- Topic, goals, and session parameters
-- Each technique used and how it was applied
-- Your contributions and the ideas you generated
-- Thematic organization connecting related insights
-- Prioritized ideas with action plans
-- Session highlights and key breakthroughs
-
-This document becomes a permanent record of your creative process—valuable for future reference, sharing with stakeholders, or continuing the session later.
-
----
-
-## Technique Categories
-
-| Category | Focus |
-|----------|-------|
-| **Collaborative** | Team dynamics and inclusive participation |
-| **Creative** | Breakthrough thinking and paradigm shifts |
-| **Deep** | Root cause analysis and strategic insight |
-| **Structured** | Organized frameworks and systematic exploration |
-| **Theatrical** | Playful, radical perspectives |
-| **Wild** | Boundary-pushing, extreme thinking |
-| **Biomimetic** | Nature-inspired solutions |
-| **Quantum** | Quantum principles for innovation |
-| **Cultural** | Traditional knowledge and cross-cultural approaches |
-| **Introspective Delight** | Inner wisdom and authentic exploration |
-
----
-
-## Key Features
-
-- **Interactive coaching** — Pulls ideas *out* of you, doesn't generate them for you
-- **On-demand loading** — Techniques loaded from a comprehensive library as needed
-- **Session preservation** — Every step, insight, and action plan is documented
-- **Continuation support** — Pause sessions and return later, or extend with additional techniques
-
----
-
-## Workflow Integration
-
-Brainstorming is a core workflow designed to be invoked and configured by other modules. When called from another workflow, it accepts contextual parameters:
-
-| Parameter | Description |
-|-----------|-------------|
-| **Topic focus** | What the brainstorming should help discover or solve |
-| **Guardrails** | Constraints, boundaries, or must-avoid areas |
-| **Output goals** | What the final output needs to accomplish for the calling workflow |
-| **Context files** | Project-specific guidance to inform technique selection |
-
-### Example
-
-When creating a new module in the BMad Builder workflow, Brainstorming can be invoked with guardrails around the module's purpose and a goal to discover key features, user needs, or architectural considerations. The session becomes focused on producing exactly what the module creation workflow needs.

docs/modules/core/core-tasks.md

@@ -1,64 +0,0 @@
-# Core Tasks
-
-Core Tasks are reusable task definitions that can be invoked by any BMAD module, workflow, or agent. These tasks provide standardized functionality for common operations.
-
-## Table of Contents
-
-- [Index Docs](#index-docs) — Generate directory index files
-- [Adversarial Review](#adversarial-review-general) — Critical content review
-- [Shard Document](#shard-document) — Split large documents into sections
-
----
-
-## Index Docs
-
-**Generates or updates an index.md file documenting all documents in a specified directory.**
-
-This task scans a target directory, reads file contents to understand their purpose, and creates a well-organized index with accurate descriptions. Files are grouped by type, purpose, or subdirectory, and descriptions are generated from actual content rather than guessing from filenames.
-
-**Use it when:** You need to create navigable documentation for a folder of markdown files, or you want to maintain an updated index as content evolves.
-
-**How it works:**
-1. Scan the target directory for files and subdirectories
-2. Group content by type, purpose, or location
-3. Read each file to generate brief (3-10 word) descriptions based on actual content
-4. Create or update index.md with organized listings using relative paths
-
-**Output format:** A markdown index with sections for Files and Subdirectories, each entry containing a relative link and description.
-
----
-
-## Adversarial Review (General)
-
-**Performs a cynical, skeptical review of any content to identify issues and improvement opportunities.**
-
-This task applies adversarial thinking to content review—approaching the material with the assumption that problems exist. It's designed to find what's missing, not just what's wrong, and produces at least ten specific findings. The reviewer adopts a professional but skeptical tone, looking for gaps, inconsistencies, oversights, and areas that need clarification.
-
-**Use it when:** You need a critical eye on code diffs, specifications, user stories, documentation, or any artifact before finalizing. It's particularly valuable before merging code, releasing documentation, or considering a specification complete.
-
-**How it works:**
-1. Load the content to review (diff, branch, uncommitted changes, document, etc.)
-2. Perform adversarial analysis with extreme skepticism—assume problems exist
-3. Find at least ten issues to fix or improve
-4. Output findings as a markdown list
-
-**Note:** This task is designed to run in a separate subagent/process with read access to the project but no prior context, ensuring an unbiased review.
-
----
-
-## Shard Document
-
-**Splits large markdown documents into smaller, organized files based on level 2 (##) sections.**
-
-Uses the `@kayvan/markdown-tree-parser` tool to automatically break down large documents into a folder structure. Each level 2 heading becomes a separate file, and an index.md is generated to tie everything together. This makes large documents more maintainable and allows for easier navigation and updates to individual sections.
-
-**Use it when:** A markdown file has grown too large to effectively work with, or you want to break a monolithic document into manageable sections that can be edited independently.
-
-**How it works:**
-1. Confirm source document path and verify it's a markdown file
-2. Determine destination folder (defaults to same location as source, folder named after document)
-3. Execute the sharding command using npx @kayvan/markdown-tree-parser
-4. Verify output files and index.md were created
-5. Handle the original document—delete, move to archive, or keep with warning
-
-**Handling the original:** After sharding, the task prompts you to delete, archive, or keep the original document. Deleting or archiving is recommended to avoid confusion and ensure updates happen in the sharded files only.

docs/modules/core/core-workflows.md

@@ -1,30 +0,0 @@
-# Core Workflows
-
-Core Workflows are domain-agnostic workflows that can be utilized by any BMAD-compliant module, workflow, or agent. These workflows are installed by default and available at any time.
-
-## Available Core Workflows
-
-### [Party Mode](party-mode.md)
-
-Orchestrate dynamic multi-agent conversations with your entire BMAD team. Engage with multiple specialized perspectives simultaneously—each agent maintaining their unique personality, expertise, and communication style.
-
-### [Brainstorming](brainstorming.md)
-
-Facilitate structured creative sessions using 60+ proven ideation techniques. The AI acts as coach and guide, using proven creativity methods to draw out ideas and insights that are already within you.
-
-### [Advanced Elicitation](advanced-elicitation.md)
-
-Push the LLM to rethink its work through 50+ reasoning methods—the inverse of brainstorming. The LLM applies sophisticated techniques to re-examine and enhance content it has just generated, essentially "LLM brainstorming" to find better approaches and uncover improvements.
-
----
-
-## Workflow Integration
-
-Core Workflows are designed to be invoked and configured by other modules. When called from another workflow, they accept contextual parameters to customize the session:
-
-- **Topic focus** — Direct the session toward a specific domain or question
-- **Additional personas** (Party Mode) — Inject expert agents into the roster at runtime
-- **Guardrails** (Brainstorming) — Set constraints and boundaries for ideation
-- **Output goals** — Define what the final output needs to accomplish
-
-This allows modules to leverage these workflows' capabilities while maintaining focus on their specific domain and objectives.

docs/modules/core/document-sharding-guide.md

@@ -1,133 +0,0 @@
-# Document Sharding Guide
-
-Comprehensive guide to BMad Method's document sharding system for managing large planning and architecture documents.
-
-## Table of Contents
-
-- [Document Sharding Guide](#document-sharding-guide)
-  - [Table of Contents](#table-of-contents)
-  - [What is Document Sharding?](#what-is-document-sharding)
-    - [Architecture](#architecture)
-  - [When to Use Sharding](#when-to-use-sharding)
-    - [Ideal Candidates](#ideal-candidates)
-  - [How Sharding Works](#how-sharding-works)
-    - [Sharding Process](#sharding-process)
-    - [Workflow Discovery](#workflow-discovery)
-  - [Using the Shard-Doc Tool](#using-the-shard-doc-tool)
-    - [CLI Command](#cli-command)
-    - [Interactive Process](#interactive-process)
-    - [What Gets Created](#what-gets-created)
-  - [Workflow Support](#workflow-support)
-    - [Universal Support](#universal-support)
-
-## What is Document Sharding?
-
-Document sharding splits large markdown files into smaller, organized files based on level 2 headings (`## Heading`). This enables:
-
-- **Selective Loading** - Workflows load only the sections they need
-- **Reduced Token Usage** - Massive efficiency gains for large projects
-- **Better Organization** - Logical section-based file structure
-- **Maintained Context** - Index file preserves document structure
-
-### Architecture
-
-```
-Before Sharding:
-docs/
-└── PRD.md (large 50k token file)
-
-After Sharding:
-docs/
-└── prd/
-    ├── index.md                    # Table of contents with descriptions
-    ├── overview.md                 # Section 1
-    ├── user-requirements.md        # Section 2
-    ├── technical-requirements.md   # Section 3
-    └── ...                         # Additional sections
-```
-
-## When to Use Sharding
-
-### Ideal Candidates
-
-**Large Multi-Epic Projects:**
-
-- Very large complex PRDs
-- Architecture documents with multiple system layers
-- Epic files with 4+ epics (especially for Phase 4)
-- UX design specs covering multiple subsystems
-
-## How Sharding Works
-
-### Sharding Process
-
-1. **Tool Execution**: Run `npx @kayvan/markdown-tree-parser source.md destination/` - this is abstracted with the core shard-doc task which is installed as a slash command or manual task rule depending on your tools.
-2. **Section Extraction**: Tool splits by level 2 headings
-3. **File Creation**: Each section becomes a separate file
-4. **Index Generation**: `index.md` created with structure and descriptions
-
-### Workflow Discovery
-
-BMad workflows use a **dual discovery system**:
-
-1. **Try whole document first** - Look for `document-name.md`
-2. **Check for sharded version** - Look for `document-name/index.md`
-3. **Priority rule** - Whole document takes precedence if both exist - remove the whole document if you want the sharded to be used instead.
-
-## Using the Shard-Doc Tool
-
-### CLI Command
-
-```bash
-/bmad:core:tools:shard-doc 
-```
-
-### Interactive Process
-
-```
-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!
-```
-
-### What Gets Created
-
-**index.md structure:**
-
-```markdown
-# PRD - Index
-
-## Sections
-
-1. [Overview](./overview.md) - Project vision and objectives
-2. [User Requirements](./user-requirements.md) - Feature specifications
-3. [Epic 1: Authentication](./epic-1-authentication.md) - User auth system
-4. [Epic 2: Dashboard](./epic-2-dashboard.md) - Main dashboard UI
-   ...
-```
-
-**Individual section files:**
-
-- Named from heading text (kebab-case)
-- Contains complete section content
-- Preserves all markdown formatting
-- Can be read independently
-
-## Workflow Support
-
-### Universal Support
-
-**All BMM workflows support both formats:**
-
-- ✅ Whole documents
-- ✅ Sharded documents
-- ✅ Automatic detection
-- ✅ Transparent to user

docs/modules/core/global-core-config.md

@@ -1,11 +0,0 @@
-# Core Module Global Inheritable Config
-
-The Core Modules module.yaml file defines configuration values that are useful and unique for all other modules to utilize, and by default all other modules installed will clone the values defined in the core module yaml.config into their own. It is possible for other modules to override these values, but the general intent it to accept the core module values and define their own values as needed, or extend the core values.
-
-Currently, the core module.yaml config will define (asking the user upon installation, and recording to the core module config.yaml):
-- `user_name`: string (defaults to the system defined user name)
-- `communication_language`: string (defaults to english)
-- `document_output_language`: string (defaults to english)
-- `output_folder`: string (default `_bmad-output`)
-
-An example of extending one of these values, in the BMad Method module.yaml it defines a planning_artifacts config, which will default to `default: "{output_folder}/planning-artifacts"` thus whatever the output_folder will be, this extended versions default will use the value from this core module and append a new folder onto it. The user can choose to replace this without utilizing the output_folder from the core if they so chose.

docs/modules/core/index.md

@@ -1,15 +0,0 @@
-# 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](global-core-config.md)** — Inheritable configuration that impacts all modules and custom content
-- **[Core Workflows](core-workflows.md)** — Domain-agnostic workflows usable by any module
-  - [Party Mode](party-mode.md) — Multi-agent conversation orchestration
-  - [Brainstorming](brainstorming.md) — Structured creative sessions with 60+ techniques
-  - [Advanced Elicitation](advanced-elicitation.md) — LLM rethinking with 50+ reasoning methods
-- **[Core Tasks](core-tasks.md)** — Common tasks available across modules
-  - [Index Docs](core-tasks.md#index-docs) — Generate directory index files
-  - [Adversarial Review](core-tasks.md#adversarial-review-general) — Critical content review
-  - [Shard Document](core-tasks.md#shard-document) — Split large documents into sections

docs/modules/core/party-mode.md

@@ -1,50 +0,0 @@
-# Party Mode
-
-**Orchestrate dynamic multi-agent conversations with your entire BMAD team.**
-
-Party Mode brings together all your installed BMAD agents for collaborative discussions. Instead of working with a single agent, you can engage with multiple specialized perspectives simultaneously—each agent maintaining their unique personality, expertise, and communication style.
-
----
-
-## When to Use It
-
-- Exploring complex topics that would benefit from diverse expert perspectives
-- Brainstorming with agents who can build on each other's ideas
-- Getting a comprehensive view across multiple domains (technical, business, creative, strategic)
-- Enjoying dynamic, agent-to-agent conversations where experts challenge and complement each other
-
----
-
-## How It Works
-
-1. Party Mode loads your complete agent roster and introduces the available team members
-2. You present a topic or question
-3. The facilitator intelligently selects 2-3 most relevant agents based on expertise needed
-4. Agents respond in character, can reference each other, and engage in natural cross-talk
-5. The conversation continues until you choose to exit
-
----
-
-## Key Features
-
-- **Intelligent agent selection** — The system analyzes your topic and selects the most relevant agents based on their expertise, capabilities, and principles
-- **Authentic personalities** — Each agent maintains their unique voice, communication style, and domain knowledge throughout the conversation
-- **Natural cross-talk** — Agents can reference each other, build on previous points, ask questions, and even respectfully disagree
-- **Optional TTS integration** — Each agent response can be read aloud with voice configurations matching their personalities
-- **Graceful exit** — Sessions conclude with personalized farewells from participating agents
-
----
-
-## Workflow Integration
-
-Party Mode is a core workflow designed to be invoked and configured by other modules. When called from another workflow, it accepts contextual parameters:
-
-| Parameter | Description |
-|-----------|-------------|
-| **Topic focus** | Prebias the discussion toward a specific domain or question |
-| **Additional personas** | Inject expert agents into the roster at runtime for specialized perspectives |
-| **Participation constraints** | Limit which agents can contribute based on relevance |
-
-### Example
-
-A medical module workflow could invoke Party Mode with expert doctor personas added to the roster, and the conversation pre-focused on a specific diagnosis or treatment decision. The agents would then discuss the medical case with appropriate domain expertise while maintaining their distinct personalities and perspectives.

docs/sample-custom-modules/README.md

@@ -4,7 +4,7 @@ These are quickly put together examples of both a stand alone somewhat cohesive
 
 To try these out, download either or both folders to your local machine, and run the normal bmad installer, and when asked about custom local content, say yes, and give the path to one of these two folders. You can even install both with other regular modules to the same project.
 
-Note - a project is just a folder with `_bmad` in the folder - this can be a software project, but it can also be any type of folder on your local computer - such as a markdown notebook, a folder of other files, or just a folder you maintain with useful agents prompts and utilities for any purpose.
+Note - a project is just a folder with .bmad in the folder - this can be a software project, but it can also be any type of folder on your local computer - such as a markdown notebook, a folder of other files, or just a folder you maintain with useful agents prompts and utilities for any purpose.
 
 Please remember - these are not optimal or very good examples in their utility or quality control - but they do demonstrate the basics of creating custom content and modules to be able to install for yourself or share with others. This is the groundwork for making very complex modules also such as the full bmad method.
 

docs/sample-custom-modules/sample-unitary-module/agents/commit-poet/commit-poet.agent.yaml

@@ -4,7 +4,7 @@ agent:
     name: "Inkwell Von Comitizen"
     title: "Commit Message Artisan"
     icon: "📜"
-    module: stand-alone
+    type: simple
 
   persona:
     role: |

docs/sample-custom-modules/sample-unitary-module/agents/toolsmith/toolsmith-sidecar/knowledge/docs.md

@@ -25,6 +25,10 @@
 - @/docs/installers-bundlers/ - Tooling-specific documentation directory
 - @/tools/cli/README.md - CLI usage documentation (comprehensive)
 
+### IDE-Specific Documentation
+
+- @/docs/ide-info/ - IDE-specific setup guides (15+ files)
+
 ### Module Documentation
 
 Each module may have its own docs:
@@ -69,6 +73,7 @@ Follow Keep a Changelog format:
 When code changes, check these docs:
 
 - CLI changes → tools/cli/README.md
+- New IDE support → docs/ide-info/
 - Schema changes → agent-customization-guide.md
 - Bundle changes → web-bundles-gemini-gpt-guide.md
 - Installer changes → installers-bundlers/

docs/sample-custom-modules/sample-unitary-module/agents/toolsmith/toolsmith-sidecar/knowledge/installers.md

@@ -30,7 +30,7 @@
 ### IDE Manager & Base
 
 - @/tools/cli/installers/lib/ide/manager.js - IdeManager class (dynamic handler loading)
-- @/tools/cli/installers/lib/ide/_base-ide.js - BaseIdeSetup class (all handlers extend this)
+- @/tools/cli/installers/lib/ide/\_base-ide.js - BaseIdeSetup class (all handlers extend this)
 
 ### Shared Utilities
 
@@ -117,7 +117,7 @@ Contains:
 
 - Add new IDE handler: Create file in /tools/cli/installers/lib/ide/, extend BaseIdeSetup
 - Fix installer bug: Check installer.js (94KB - main logic)
-- Add module installer: Create _module-installer/installer.js if custom installer logic needed
+- Add module installer: Create \_module-installer/installer.js if custom installer logic needed
 - Update shared generators: Modify files in /shared/ directory
 
 ## Relationships

docs/sample-custom-modules/sample-unitary-module/agents/toolsmith/toolsmith-sidecar/knowledge/modules.md

@@ -142,7 +142,7 @@ Defined in @/tools/cli/lib/platform-codes.js
 
 ## Common Tasks
 
-- Create new module installer: Add _module-installer/installer.js
+- Create new module installer: Add \_module-installer/installer.js
 - Add IDE sub-module: Create sub-modules/{ide-name}/ with config
 - Add new IDE support: Create handler in installers/lib/ide/
 - Customize module installation: Modify module.yaml

docs/sample-custom-modules/sample-unitary-module/agents/toolsmith/toolsmith.agent.yaml

@@ -4,7 +4,7 @@ agent:
     name: Vexor
     title: Toolsmith + Guardian of the BMAD Forge
     icon: ⚒️
-    module: stand-alone
+    type: expert
     hasSidecar: true
   persona:
     role: |

docs/sample-custom-modules/sample-unitary-module/workflows/quiz-master/steps/step-01-init.md

@@ -66,7 +66,7 @@ To set up the quiz game by selecting game mode, choosing a category, and prepari
 
 ### 1. Welcome and Configuration Loading
 
-Load config from {project-root}/_bmad/bmb/config.yaml to get user_name.
+Load config from {project-root}/\_bmad/bmb/config.yaml to get user_name.
 
 Present dramatic welcome:
 "🎺 _DRAMATIC MUSIC PLAYS_ 🎺

docs/sample-custom-modules/sample-unitary-module/workflows/quiz-master/workflow.md

@@ -45,7 +45,7 @@ web_bundle: true
 
 ### 1. Module Configuration Loading
 
-Load and read full config from {project-root}/_bmad/bmb/config.yaml and resolve:
+Load and read full config from {project-root}/\_bmad/bmb/config.yaml and resolve:
 
 - `user_name`, `output_folder`, `communication_language`, `document_output_language`
 

docs/v4-to-v6-upgrade.md

@@ -8,35 +8,42 @@ BMad v6 represents a complete ground-up rewrite with significant architectural c
 
 ## Automatic V4 Detection
 
-When you run `npm run install:bmad` on a project, the installer automatically detects:
+When you run `npm run install:bmad` on a project with v4 installed, the installer automatically detects:
 
-- **Legacy v4 installation folder**: `.bmad-method`
+- **Legacy folders**: Any folders starting with `_bmad`, `bmad` (lowercase), or `Bmad`
 - **IDE command artifacts**: Legacy bmad folders in IDE configuration directories (`.claude/commands/`, `.cursor/commands/`, etc.)
 
 ### What Happens During Detection
 
-1. **Automatic Detection of v4 Modules**
-   1. Installer will suggest removal or backup of your .bmad-method folder. You can choose to exit the installer and handle this cleanup, or allow the install to continue. Technically you can have both v4 and v6 installed, but it is not recommended. All BMad content and modules will be installed under a .bmad folder, fully segregated.
+1. **Automatic Backup of v4 Modules**: All `_bmad-*` folders are moved to `v4-backup/` in your project root
+   - If a backup already exists, a timestamp is added to avoid conflicts
+   - Example: `_bmad-core` → `v4-backup/_bmad-core`
+   - Your project files and data are NOT affected
 
 2. **IDE Command Cleanup Recommended**: Legacy v4 IDE commands should be manually removed
-   - Located in IDE config folders, for example claude: `.claude/commands/BMad/agents`, `.claude/commands/BMad/tasks`, etc.
-   - NOTE: if the upgrade and install of v6 finished, the new commands will be under `.claude/commands/bmad/<module>/agents|workflows`
-   - Note 2: If you accidentally delete the wrong/new bmad commands - you can easily restore them by rerunning the installer, and choose quick update option, and all will be reapplied properly.
+   - Located in IDE config folders: `.claude/commands/`, `.cursor/commands/`, etc.
+   - These old commands would still reference v4 folder structure if left in place
+   - The installer provides copy/paste terminal commands for your platform
+   - You can proceed without cleanup, but removing them prevents confusion with old v4 commands
+
+---
 
 ## Module Migration
 
-### Deprecated Modules from v4
+### Deprecated Modules
 
-| v4 Module                     | v6 Status                                      |
-| ----------------------------- | ---------------------------------------------- |
-| `_bmad-2d-phaser-game-dev`    | Integrated into new BMGD Module                |
-| `_bmad-2d-unity-game-dev`     | Integrated into new BMGD Module                |
-| `_bmad-godot-game-dev`        | Integrated into new BMGD Module                |
-| `_bmad-*-game-dev` (any)      | Integrated into new BMGD Module                |
-| `_bmad-infrastructure-devops` | Deprecated - New core devops agent coming soon |
-| `_bmad-creative-writing`      | Not adapted - New v6 module coming soon        |
+| v4 Module                     | v6 Status                                        |
+| ----------------------------- | ------------------------------------------------ |
+| `_bmad-2d-phaser-game-dev`    | Integrated into BMM                              |
+| `_bmad-2d-unity-game-dev`     | Integrated into BMM                              |
+| `_bmad-godot-game-dev`        | Integrated into BMM                              |
+| `_bmad-*-game-dev` (any)      | Integrated into BMM                              |
+| `_bmad-infrastructure-devops` | Deprecated - New core devops agent coming in BMM |
+| `_bmad-creative-writing`      | Not adapted - New module releasing soon          |
 
-Aside from .bmad-method - if you have any of these others installed also, again its recommended to remove them and use the V6 equivalents, but its also fine if you decide to keep both. But it is not recommended to use both on the same project long term.
+**Game Development**: All game development functionality has been consolidated and expanded within the BMM (BMad Method) module. Game-specific workflows now adapt to your game type and engine.
+
+---
 
 ## Architecture Changes
 
@@ -46,54 +53,58 @@ Aside from .bmad-method - if you have any of these others installed also, again
 
 ```
 your-project/
-├── .bmad-method/         
-├── .bmad-game-dev/       
-├── .bmad-creative-writing/
-└── .bmad-infrastructure-devops/
+├── _bmad-core/           # Was actually the BMad Method
+├── _bmad-game-dev/       # Separate expansion packs
+├── _bmad-creative-writing/
+└── _bmad-infrastructure-devops/
 ```
 
 **v6 Unified Structure:**
 
 ```
 your-project/
-└── _bmad/               # Single installation folder is _bmad
-    └── _config/         # Your customizations
-    |  └── agents/       # Agent customization files
+└── _bmad/       # Single installation folder, default _bmad
     ├── core/            # Real core framework (applies to all modules)
     ├── bmm/             # BMad Method (software/game dev)
     ├── bmb/             # BMad Builder (create agents/workflows)
     ├── cis/             # Creative Intelligence Suite
-├── _bmad_output         # Default bmad output folder (was doc folder in v4)
-
+    └── _config/            # Your customizations
+        └── agents/      # Agent customization files
 ```
 
 ### Key Concept Changes
 
-- **v4 `_bmad-core and _bmad-method`**: Was actually the BMad Method
+- **v4 `_bmad-core`**: Was actually the BMad Method
 - **v6 `_bmad/core/`**: Is the real universal core framework
 - **v6 `_bmad/bmm/`**: Is the BMad Method module
-- **Module identification**: All modules now have a `config.yaml` file once installed at the root of the modules installed folder
+- **Module identification**: All modules now have a `config.yaml` file
+
+---
 
 ## Project Progress Migration
 
-### If You've Completed Some or all Planning Phases (Brief/PRD/UX/Architecture) with the BMad Method:
+### If You've Completed Planning Phase (PRD/Architecture) with the BMad Method:
 
-After running the v6 installer, if you kept the paths the same as the installation suggested, you will need to move a few files, or run the installer again. It is recommended to stick with these defaults as it will be easier to adapt if things change in the future.
+After running the v6 installer:
 
-If you have any planning artifacts, put them in a folder called _bmad-output/planning-artifacts at the root of your project, ensuring that:
-PRD has PRD in the file name or folder name if sharded.
-Similar for 'brief', 'architecture', 'ux-design'.
+1. **Run `workflow-init`** workflow to set up the guided workflow system
+2. **Specify your project level** when prompted:
+   - If you followed v4's full workflow (PRD → Architecture → Stories), select **Level 3 or 4**
+   - This tells v6 you've already completed planning and solutioning phases
+3. **Document paths**: Keep your existing paths during installation
+   - Default PRD/Architecture location: `docs/`
+   - Default stories location: `docs/sprint-artifacts/`
+   - **Accept these defaults** if you're already using them in v4
 
-If you have other long term docs that will not be as ephemeral as these project docs, you can put them in the /docs folder, ideally with a index.md file.
-
-HIGHLY RECOMMENDED NOTE: If you are only partway through planning, its highly recommended to restart and do the PRD, UX and ARCHITECTURE steps. You could even use your existing documents as inputs letting the agent know you want to redo them with the new workflows. These optimized v6 progressive discovery workflows that also will utilize web search at key moments, while offering better advanced elicitation and part mode in the IDE will produce superior results. And then once all are complete, an epics with stories is generated after the architecture step now - ensuring it uses input from all planing documents.
+> **Important**: v6 workflows can handle both sharded and unsharded documents. You don't need to restructure your existing PRD or architecture files.
 
 ### If You're Mid-Development (Stories Created/Implemented)
 
 1. Complete the v6 installation as above
-2. Ensure you have a file called epics.md or epics/epic*.md - these need to be located under the _bmad-output/planning-artifacts folder.
-3. Run the scrum masters `sprint-planning` workflow to generate the implementation tracking plan in _bmad-output/implementation-artifacts.
-4. Inform the SM after the output is complete which epics and stories were completed already and should be parked properly in the file.
+2. Run `workflow-init` and specify Level 3 or 4
+3. When ready to continue development, run the **`sprint-planning`** workflow (Phase 4)
+
+---
 
 ## Agent Customization Migration
 
@@ -120,15 +131,13 @@ persona:
     - Always upbeat and adventurous
 ```
 
-There is a lot more that is possible with agent customization, which is covered in detail in the [Agent Customization Guide](bmad-customization/agent-customization-guide.md)
-
-CRITICAL NOTE: After you modify the customization file, you need to run the npx installer against your installed location, and choose the option to rebuild all agents, or just do a quick update again. This always builds agents fresh and applies customizations.
-
 **How it works:**
 
 - Base agent: `_bmad/bmm/agents/pm.md`
 - Customization: `_bmad/_config/agents/bmm-pm.customize.yaml`
-- Rebuild all agents -> Result: Agent uses your custom name and style
+- Result: Agent uses your custom name and style, but updates don't overwrite your changes
+
+---
 
 ## Document Compatibility
 
@@ -142,3 +151,77 @@ CRITICAL NOTE: After you modify the customization file, you need to run the npx
 - ✅ Mixed approaches
 
 All workflow files are scanned automatically. No manual configuration needed.
+
+---
+
+## Installation Steps
+
+### 1. Clone Repository
+
+```bash
+git clone https://github.com/bmad-code-org/BMAD-METHOD
+cd BMAD-METHOD
+npm install
+```
+
+### 2. Run Installer on Your v4 Project
+
+```bash
+npx bmad-method install
+```
+
+**Enter the full path to your v4 project** when prompted.
+
+### 3. Follow Interactive Prompts
+
+The installer will:
+
+1. Detect v4 installation and offer to backup `_bmad-*` folders
+2. Prompt for recommended cleanup (you can skip)
+3. Let you select modules (recommend: BMM for software and or game development)
+4. Configure core settings (name, language, etc.)
+5. Configure module-specific options
+6. Configure IDE integrations
+
+### 4. Accept Default Paths
+
+If you're using:
+
+- `docs/` for PRD and architecture
+- `docs/sprint-artifacts/` for story files
+
+**Accept these defaults** during installation.
+
+### 5. Initialize Workflow
+
+After installation:
+
+1. **Load the Analyst agent** - See your IDE-specific instructions in [docs/ide-info](./ide-info/) for how to activate agents:
+   - [Claude Code](./ide-info/claude-code.md)
+   - [Cursor](./ide-info/cursor.md)
+   - [VS Code/Windsurf](./ide-info/) - Check your IDE folder
+
+2. **Wait for the agent's menu** to appear
+
+3. **Tell the agent**: `*workflow-init` - v6 supports excellent natural language fuzzy matching, so you could also say "workflow init" or "please init the workflow"
+
+Since you are migrating an existing project from v4, it's most likely **Level 3 or 4** you will want to suggest when asked - if you've already completed PRD/architecture in v4.
+
+---
+
+## Post-Migration Checklist
+
+- [ ] v4 folders backed up to `v4-backup/`
+- [ ] v6 installed to `_bmad/` folder
+- [ ] `workflow-init` run with correct project level selected
+- [ ] Agent customizations migrated to `_bmad/_config/agents/` if needed
+- [ ] IDE integration working (test by listing agents)
+- [ ] For active development: `sprint-planning` workflow executed
+
+---
+
+## Getting Help
+
+- **Discord**: [Join the BMad Community](https://discord.gg/gk8jAdXWmj)
+- **Issues**: [GitHub Issue Tracker](https://github.com/bmad-code-org/BMAD-METHOD/issues)
+- **Docs**: Check `_bmad/docs/` in your installation for IDE-specific instructions

docs/web-bundles-gemini-gpt-guide.md

@@ -2,15 +2,15 @@
 
 ## IMPORTANT NOTE
 
-The Web Bundling Feature is being rebuilt from the ground up, current bundles found for v6 may be incomplete or missing functionality and are not optimized.
+The Web Bundling Feature is being rebuilt from the ground up, current bundles for v6 may be incomplete or missing functionality and are not optimized. This will be rectified very soon, with a more expansive guide.
 
 ## What Are Web bundles
 
-Web bundles package BMad agents as self-contained files that work in Gemini Gems and Custom GPTs. Everything the agent needs - instructions, workflows, dependencies - is bundled into a single file for easy upload.
+Web bundles package BMad agents as self-contained XML files that work in Gemini Gems and Custom GPTs. Everything the agent needs - instructions, workflows, dependencies - is bundled into a single file.
 
 ## What Are Web Bundles?
 
-Web bundles are standalone files containing:
+Web bundles are standalone XML files containing:
 
 - Complete agent persona and instructions
 - All workflows and dependencies

eslint.config.mjs

@@ -18,10 +18,6 @@ export default [
       'test/fixtures/**/*.yaml',
       '_bmad/**',
       '_bmad*/**',
-      // Docusaurus build artifacts
-      '.docusaurus/**',
-      'build/**',
-      'website/**',
       // Gitignored patterns
       'z*/**', // z-samples, z1, z2, etc.
       '.claude/**',
@@ -81,9 +77,9 @@ export default [
     },
   },
 
-  // CLI scripts under tools/** and test/**
+  // CLI/CommonJS scripts under tools/** and test/**
   {
-    files: ['tools/**/*.js', 'tools/**/*.mjs', 'test/**/*.js'],
+    files: ['tools/**/*.js', 'test/**/*.js'],
     rules: {
       // Allow CommonJS patterns for Node CLI scripts
       'unicorn/prefer-module': 'off',
@@ -110,7 +106,6 @@ export default [
       'no-useless-catch': 'off',
       'unicorn/prefer-number-properties': 'off',
       'no-unreachable': 'off',
-      'unicorn/text-encoding-identifier-case': 'off',
     },
   },
 

package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method",
-  "version": "6.0.0-alpha.21",
+  "version": "6.0.0-alpha.18",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",
@@ -25,13 +25,11 @@
   },
   "scripts": {
     "bmad:install": "node tools/cli/bmad-cli.js install",
+    "bmad:status": "node tools/cli/bmad-cli.js status",
     "bundle": "node tools/cli/bundlers/bundle-web.js all",
-    "docs:build": "node tools/build-docs.js",
-    "docs:dev": "npm run docs:build && npm run docs:serve",
-    "docs:serve": "docusaurus start --config website/docusaurus.config.js --host localhost",
     "flatten": "node tools/flattener/main.js",
-    "format:check": "prettier --check \"**/*.{js,cjs,mjs,json,yaml}\"",
-    "format:fix": "prettier --write \"**/*.{js,cjs,mjs,json,yaml}\"",
+    "format:check": "prettier --check \"**/*.{js,cjs,mjs,json,md,yaml}\"",
+    "format:fix": "prettier --write \"**/*.{js,cjs,mjs,json,md,yaml}\"",
     "install:bmad": "node tools/cli/bmad-cli.js install",
     "lint": "eslint . --ext .js,.cjs,.mjs,.yaml --max-warnings=0",
     "lint:fix": "eslint . --ext .js,.cjs,.mjs,.yaml --fix",
@@ -42,10 +40,11 @@
     "release:minor": "gh workflow run \"Manual Release\" -f version_bump=minor",
     "release:patch": "gh workflow run \"Manual Release\" -f version_bump=patch",
     "release:watch": "gh run watch",
-    "test": "npm run test:schemas && npm run test:install && npm run validate:schemas && npm run lint && npm run lint:md && npm run format:check",
+    "test": "npm run test:schemas && npm run test:install && npm run validate:bundles && npm run validate:schemas && npm run lint && npm run lint:md && npm run format:check",
     "test:coverage": "c8 --reporter=text --reporter=html npm run test:schemas",
     "test:install": "node test/test-installation-components.js",
     "test:schemas": "node test/test-agent-schema.js",
+    "validate:bundles": "node tools/validate-bundles.js",
     "validate:schemas": "node tools/validate-agent-schema.js"
   },
   "lint-staged": {
@@ -61,7 +60,8 @@
       "npm run format:fix"
     ],
     "*.md": [
-      "markdownlint-cli2"
+      "markdownlint-cli2",
+      "npm run format:fix"
     ]
   },
   "dependencies": {
@@ -75,7 +75,7 @@
     "fs-extra": "^11.3.0",
     "glob": "^11.0.3",
     "ignore": "^7.0.5",
-    "inquirer": "^9.3.8",
+    "inquirer": "^8.2.6",
     "js-yaml": "^4.1.0",
     "ora": "^5.4.1",
     "semver": "^7.6.3",
@@ -84,10 +84,7 @@
     "yaml": "^2.7.0"
   },
   "devDependencies": {
-    "@docusaurus/core": "^3.6.0",
-    "@docusaurus/preset-classic": "^3.6.0",
     "@eslint/js": "^9.33.0",
-    "archiver": "^7.0.1",
     "c8": "^10.1.3",
     "eslint": "^9.33.0",
     "eslint-config-prettier": "^10.1.8",
@@ -100,9 +97,6 @@
     "markdownlint-cli2": "^0.19.1",
     "prettier": "^3.5.3",
     "prettier-plugin-packagejson": "^2.5.19",
-    "prism-react-renderer": "^2.4.1",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
     "yaml-eslint-parser": "^1.2.3",
     "yaml-lint": "^1.7.0",
     "zod": "^4.1.12"

src/core/agents/bmad-master.agent.yaml

@@ -21,10 +21,14 @@ agent:
     - "ALWAYS communicate in {communication_language}"
 
   menu:
-    - trigger: "LT or fuzzy match on list-tasks"
+    - trigger: "list-tasks"
       action: "list all tasks from {project-root}/_bmad/_config/task-manifest.csv"
-      description: "[LT] List Available Tasks"
+      description: "List Available Tasks"
 
-    - trigger: "LW or fuzzy match on list-workflows"
+    - trigger: "list-workflows"
       action: "list all workflows from {project-root}/_bmad/_config/workflow-manifest.csv"
-      description: "[LW] List Workflows"
+      description: "List Workflows"
+
+    - trigger: "party-mode"
+      exec: "{project-root}/_bmad/core/workflows/party-mode/workflow.md"
+      description: "Group chat with all agents"

src/core/tasks/advanced-elicitation.xml

@@ -1,5 +1,5 @@
-<task id="_bmad/core/workflows/advanced-elicitation/workflow.xml" name="Advanced Elicitation" standalone="true"
-  methods="{project-root}/_bmad/core/workflows/advanced-elicitation/methods.csv"
+<task id="_bmad/core/tasks/advanced-elicitation.xml" name="Advanced Elicitation" standalone="true"
+  methods="{project-root}/_bmad/core/tasks/advanced-elicitation-methods.csv"
   agent-party="{project-root}/_bmad/_config/agent-manifest.csv">
   <llm critical="true">
     <i>MANDATORY: Execute ALL steps in the flow section IN EXACT ORDER</i>
@@ -7,7 +7,6 @@
     <i>HALT immediately when halt-conditions are met</i>
     <i>Each action xml tag within step xml tag is a REQUIRED action to complete that step</i>
     <i>Sections outside flow (validation, output, critical-context) provide essential context - review and apply throughout execution</i>
-    <i>YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`</i>
   </llm>
 
   <integration description="When called from workflow">

src/core/tasks/review-adversarial-general.xml

@@ -1,41 +0,0 @@
-<!-- if possible, run this in a separate subagent or process with read access to the project, 
-  but no context except the content to review -->
-
-<task id="_bmad/core/tasks/review-adversarial-general.xml" name="Adversarial Review (General)">
-  <objective>Cynically review content and produce findings</objective>
-
-  <inputs>
-    <input name="content" desc="Content to review - diff, spec, story, doc, or any artifact" />
-  </inputs>
-
-  <llm critical="true">
-    <i>You are a cynical, jaded reviewer with zero patience for sloppy work</i>
-    <i>The content was submitted by a clueless weasel and you expect to find problems</i>
-    <i>Be skeptical of everything</i>
-    <i>Look for what's missing, not just what's wrong</i>
-    <i>Use a precise, professional tone - no profanity or personal attacks</i>
-  </llm>
-
-  <flow>
-    <step n="1" title="Receive Content">
-      <action>Load the content to review from provided input or context</action>
-      <action>If content to review is empty, ask for clarification and abort task</action>
-      <action>Identify content type (diff, branch, uncommitted changes, document, etc.)</action>
-    </step>
-
-    <step n="2" title="Adversarial Analysis" critical="true">
-      <mandate>Review with extreme skepticism - assume problems exist</mandate>
-      <action>Find at least ten issues to fix or improve in the provided content</action>
-    </step>
-
-    <step n="3" title="Present Findings">
-      <action>Output findings as a Markdown list (descriptions only)</action>
-    </step>
-  </flow>
-
-  <halt-conditions>
-    <condition>HALT if zero findings - this is suspicious, re-analyze or ask for guidance</condition>
-    <condition>HALT if content is empty or unreadable</condition>
-  </halt-conditions>
-
-</task>