mdan-cli 2.5.1 → 2.5.2

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

@@ -0,0 +1,123 @@
+---
+title: "Quick Fixes"
+description: How to make quick fixes and ad-hoc changes
+sidebar:
+  order: 5
+---
+
+Use the **DEV agent** directly for bug fixes, refactorings, or small targeted changes that don't require the full BMad Method or Quick Flow.
+
+## When to Use This
+
+- Bug fixes with a clear, known cause
+- Small refactorings (rename, extract, restructure) contained within a few files
+- Minor feature tweaks or configuration changes
+- Exploratory work to understand an unfamiliar codebase
+
+:::note[Prerequisites]
+- BMad Method installed (`npx bmad-method install`)
+- An AI-powered IDE (Claude Code, Cursor, or similar)
+:::
+
+## Choose Your Approach
+
+| Situation | Agent | Why |
+| --- | --- | --- |
+| Fix a specific bug or make a small, scoped change | **DEV agent** | Jumps straight into implementation without planning overhead |
+| Change touches several files or you want a written plan first | **Quick Flow Solo Dev** | Creates a quick-spec before implementation so the agent stays aligned to your standards |
+
+If you are unsure, start with the DEV agent. You can always escalate to Quick Flow if the change grows.
+
+## Steps
+
+### 1. Load the DEV Agent
+
+Start a **fresh chat** in your AI IDE and load the DEV agent with its slash command:
+
+```text
+/bmad-agent-bmm-dev
+```
+
+This loads the agent's persona and capabilities into the session. If you decide you need Quick Flow instead, load the **Quick Flow Solo Dev** agent in a fresh chat:
+
+```text
+/bmad-agent-bmm-quick-flow-solo-dev
+```
+
+Once the Solo Dev agent is loaded, describe your change and ask it to create a **quick-spec**. The agent drafts a lightweight spec capturing what you want to change and how. After you approve the quick-spec, tell the agent to start the **Quick Flow dev cycle** -- it will implement the change, run tests, and perform a self-review, all guided by the spec you just approved.
+
+:::tip[Fresh Chats]
+Always start a new chat session when loading an agent. Reusing a session from a previous workflow can cause context conflicts.
+:::
+
+### 2. Describe the Change
+
+Tell the agent what you need in plain language. Be specific about the problem and, if you know it, where the relevant code lives.
+
+:::note[Example Prompts]
+**Bug fix** -- "Fix the login validation bug that allows empty passwords. The validation logic is in `src/auth/validate.ts`."
+
+**Refactoring** -- "Refactor the UserService to use async/await instead of callbacks."
+
+**Configuration change** -- "Update the CI pipeline to cache node_modules between runs."
+
+**Dependency update** -- "Upgrade the express dependency to the latest v5 release and fix any breaking changes."
+:::
+
+You don't need to provide every detail. The agent will read the relevant source files and ask clarifying questions when needed.
+
+### 3. Let the Agent Work
+
+The agent will:
+
+- Read and analyze the relevant source files
+- Propose a solution and explain its reasoning
+- Implement the change across the affected files
+- Run your project's test suite if one exists
+
+If your project has tests, the agent runs them automatically after making changes and iterates until tests pass. For projects without a test suite, verify the change manually (run the app, hit the endpoint, check the output).
+
+### 4. Review and Verify
+
+Before committing, review what changed:
+
+- Read through the diff to confirm the change matches your intent
+- Run the application or tests yourself to double-check
+- If something looks wrong, tell the agent what to fix -- it can iterate in the same session
+
+Once satisfied, commit the changes with a clear message describing the fix.
+
+:::caution[If Something Breaks]
+If a committed change causes unexpected issues, use `git revert HEAD` to undo the last commit cleanly. Then start a fresh chat with the DEV agent to try a different approach.
+:::
+
+## Learning Your Codebase
+
+The DEV agent is also useful for exploring unfamiliar code. Load it in a fresh chat and ask questions:
+
+:::note[Example Prompts]
+"Explain how the authentication system works in this codebase."
+
+"Show me where error handling happens in the API layer."
+
+"What does the `ProcessOrder` function do and what calls it?"
+:::
+
+Use the agent to learn about your project, understand how components connect, and explore unfamiliar areas before making changes.
+
+## What You Get
+
+- Modified source files with the fix or refactoring applied
+- Passing tests (if your project has a test suite)
+- A clean commit describing the change
+
+No planning artifacts are produced -- that's the point of this approach.
+
+## When to Upgrade to Formal Planning
+
+Consider using [Quick Flow](../explanation/quick-flow.md) or the full BMad Method when:
+
+- The change affects multiple systems or requires coordinated updates across many files
+- You are unsure about the scope and need a spec to think it through
+- The fix keeps growing in complexity as you work on it
+- You need documentation or architectural decisions recorded for the team

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

@@ -0,0 +1,78 @@
+---
+title: "Document Sharding Guide"
+description: Split large markdown files into smaller organized files for better context management
+sidebar:
+  order: 8
+---
+
+Use the `shard-doc` tool if you need to split large markdown files into smaller, organized files for better context management.
+
+:::caution[Deprecated]
+This is no longer recommended, and soon with updated workflows and most major LLMs and tools supporting subprocesses this will be unnecessary.
+:::
+
+## When to Use This
+
+Only use this if you notice your chosen tool / model combination is failing to load and read all the documents as input when needed.
+
+## What is Document Sharding?
+
+Document sharding splits large markdown files into smaller, organized files based on level 2 headings (`## Heading`).
+
+### Architecture
+
+```text
+Before Sharding:
+_bmad-output/planning-artifacts/
+└── PRD.md (large 50k token file)
+
+After Sharding:
+_bmad-output/planning-artifacts/
+└── prd/
+    ├── index.md                    # Table of contents with descriptions
+    ├── overview.md                 # Section 1
+    ├── user-requirements.md        # Section 2
+    ├── technical-requirements.md   # Section 3
+    └── ...                         # Additional sections
+```
+
+## Steps
+
+### 1. Run the Shard-Doc Tool
+
+```bash
+/bmad-shard-doc
+```
+
+### 2. Follow the Interactive Process
+
+```text
+Agent: Which document would you like to shard?
+User: docs/PRD.md
+
+Agent: Default destination: docs/prd/
+       Accept default? [y/n]
+User: y
+
+Agent: Sharding PRD.md...
+       ✓ Created 12 section files
+       ✓ Generated index.md
+       ✓ Complete!
+```
+
+## How Workflow Discovery Works
+
+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
+
+## Workflow Support
+
+All BMM workflows support both formats:
+
+- Whole documents
+- Sharded documents
+- Automatic detection
+- Transparent to user

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

@@ -0,0 +1,97 @@
+---
+title: "How to Upgrade to v6"
+description: Migrate from BMad v4 to v6
+sidebar:
+  order: 3
+---
+
+Use the BMad installer to upgrade from v4 to v6, which includes automatic detection of legacy installations and migration assistance.
+
+## When to Use This
+
+- You have BMad v4 installed (`.bmad-method` folder)
+- You want to migrate to the new v6 architecture
+- You have existing planning artifacts to preserve
+
+:::note[Prerequisites]
+- Node.js 20+
+- Existing BMad v4 installation
+:::
+
+## Steps
+
+### 1. Run the Installer
+
+Follow the [Installer Instructions](./install-bmad.md).
+
+### 2. Handle Legacy Installation
+
+When v4 is detected, you can:
+
+- Allow the installer to back up and remove `.bmad-method`
+- Exit and handle cleanup manually
+
+If you named your bmad method folder something else - you will need to manually remove the folder yourself.
+
+### 3. Clean Up IDE Commands
+
+Manually remove legacy v4 IDE commands - for example if you have claude, look for any nested folders that start with bmad and remove them:
+
+- `.claude/commands/BMad/agents`
+- `.claude/commands/BMad/tasks`
+
+### 4. Migrate Planning Artifacts
+
+**If you have planning documents (Brief/PRD/UX/Architecture):**
+
+Move them to `_bmad-output/planning-artifacts/` with descriptive names:
+
+- Include `PRD` in filename for PRD documents
+- Include `brief`, `architecture`, or `ux-design` accordingly
+- Sharded documents can be in named subfolders
+
+**If you're mid-planning:** Consider restarting with v6 workflows. Use your existing documents as inputs—the new progressive discovery workflows with web search and IDE plan mode produce better results.
+
+### 5. Migrate In-Progress Development
+
+If you have stories created or implemented:
+
+1. Complete the v6 installation
+2. Place `epics.md` or `epics/epic*.md` in `_bmad-output/planning-artifacts/`
+3. Run the Scrum Master's `sprint-planning` workflow
+4. Tell the SM which epics/stories are already complete
+
+## What You Get
+
+**v6 unified structure:**
+
+```text
+your-project/
+├── _bmad/               # Single installation folder
+│   ├── _config/         # Your customizations
+│   │   └── agents/      # Agent customization files
+│   ├── core/            # Universal core framework
+│   ├── bmm/             # BMad Method module
+│   ├── bmb/             # BMad Builder
+│   └── cis/             # Creative Intelligence Suite
+└── _bmad-output/        # Output folder (was doc folder in v4)
+```
+
+## Module Migration
+
+| v4 Module                     | v6 Status                                 |
+| ----------------------------- | ----------------------------------------- |
+| `.bmad-2d-phaser-game-dev`    | Integrated into BMGD Module               |
+| `.bmad-2d-unity-game-dev`     | Integrated into BMGD Module               |
+| `.bmad-godot-game-dev`        | Integrated into BMGD Module               |
+| `.bmad-infrastructure-devops` | Deprecated — new DevOps agent coming soon |
+| `.bmad-creative-writing`      | Not adapted — new v6 module coming soon   |
+
+## Key Changes
+
+| Concept       | v4                                    | v6                                   |
+| ------------- | ------------------------------------- | ------------------------------------ |
+| **Core**      | `_bmad-core` was actually BMad Method | `_bmad/core/` is universal framework |
+| **Method**    | `_bmad-method`                        | `_bmad/bmm/`                         |
+| **Config**    | Modified files directly               | `config.yaml` per module             |
+| **Documents** | Sharded or unsharded required setup   | Fully flexible, auto-scanned         |

package/docs/index.md

@@ -0,0 +1,59 @@
+---
+title: Welcome to MDAN
+description: AI-driven development platform with specialized agents for FinTech, DevOps/Azure, and Database Optimization
+---
+
+MDAN (**M**ulti-**D**omain **A**I **N**etwork) is an AI-driven development platform with specialized agents for FinTech, DevOps/Azure, and Database Optimization. Built on the Better Agents framework, MDAN helps you build software through the whole process from ideation and planning all the way through agentic implementation. It provides specialized AI agents, guided workflows, and intelligent planning that adapts to your project's complexity, whether you're fixing a bug or building an enterprise platform.
+
+If you're comfortable working with AI coding assistants like Claude, Cursor, or GitHub Copilot, you're ready to get started.
+
+:::note[🚀 MDAN v1.0.0 is Here!]
+29 specialized agents, 3 domain packs (FinTech, DevOps/Azure, DB Optimization), and complete Better Agents framework integration. **[Check out the GitHub Repository →](https://github.com/khalilbenaz/MDANV2)**
+:::
+
+## New Here? Start with a Tutorial
+
+The fastest way to understand MDAN is to try it.
+
+- **[Get Started with MDAN](./tutorials/getting-started.md)** — Install and understand how MDAN works
+- **[Workflow Map](./reference/workflow-map.md)** — Visual overview of MMM phases, workflows, and context management
+
+:::tip[Just Want to Dive In?]
+Install MDAN and run `/mdan-help` — it will guide you through everything based on your project and installed modules.
+:::
+
+## How to Use These Docs
+
+These docs are organized into four sections based on what you're trying to do:
+
+| Section           | Purpose                                                                                                    |
+| ----------------- | ---------------------------------------------------------------------------------------------------------- |
+| **Tutorials**     | Learning-oriented. Step-by-step guides that walk you through building something. Start here if you're new. |
+| **How-To Guides** | Task-oriented. Practical guides for solving specific problems. "How do I customize an agent?" lives here.  |
+| **Explanation**   | Understanding-oriented. Deep dives into concepts and architecture. Read when you want to know *why*.       |
+| **Reference**     | Information-oriented. Technical specifications for agents, workflows, and configuration.                   |
+
+## Extend and Customize
+
+Want to expand MDAN with your own agents, workflows, or modules? The **[Better Agents](https://github.com/langwatch/better-agents)** framework provides the foundation for creating custom extensions, whether you're adding new capabilities to MDAN or building entirely new modules from scratch.
+
+## What You'll Need
+
+MDAN works with any AI coding assistant that supports custom system prompts or project context. Popular options include:
+
+- **[Claude Code](https://code.claude.com)** — Anthropic's CLI tool (recommended)
+- **[Cursor](https://cursor.sh)** — AI-first code editor
+- **[Codex CLI](https://github.com/openai/codex)** — OpenAI's terminal coding agent
+
+You should be comfortable with basic software development concepts like version control, project structure, and agile workflows. No prior experience with BMad-style agent systems is required—that's what these docs are for.
+
+## Join the Community
+
+Get help, share what you're building, or contribute to MDAN:
+
+- **[GitHub Repository](https://github.com/khalilbenaz/MDANV2)** — Source code, issues, and contributions
+- **[npm Package](https://www.npmjs.com/package/mdan)** — Install MDAN from npm
+
+## Next Step
+
+Ready to dive in? **[Get Started with MDAN](./tutorials/getting-started.md)** and build your first project.

package/docs/reference/agents.md

@@ -0,0 +1,28 @@
+---
+title: Agents
+description: Default BMM agents with their menu triggers and primary workflows
+sidebar:
+  order: 2
+---
+
+## Default Agents
+
+This page lists the default BMM (Agile suite) agents that install with BMad Method, along with their menu triggers and primary workflows.
+
+## Notes
+
+- Triggers are the short menu codes (e.g., `CP`) and fuzzy matches shown in each agent menu.
+- Slash commands are generated separately. See [Commands](./commands.md) for the slash command list and where they are defined.
+- QA (Quinn) is the lightweight test automation agent in BMM. The full Test Architect (TEA) lives in its own module.
+
+| Agent                       | Triggers                           | Primary workflows                                                                                   |
+| --------------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
+| Analyst (Mary)              | `BP`, `RS`, `CB`, `DP`             | Brainstorm Project, Research, Create Brief, Document Project                                        |
+| Product Manager (John)      | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Create/Validate/Edit PRD, Create Epics and Stories, Implementation Readiness, Correct Course        |
+| Architect (Winston)         | `CA`, `IR`                         | Create Architecture, Implementation Readiness                                                       |
+| Scrum Master (Bob)          | `SP`, `CS`, `ER`, `CC`             | Sprint Planning, Create Story, Epic Retrospective, Correct Course                                   |
+| Developer (Amelia)          | `DS`, `CR`                         | Dev Story, Code Review                                                                              |
+| QA Engineer (Quinn)         | `QA`                               | Automate (generate tests for existing features)                                                     |
+| Quick Flow Solo Dev (Barry) | `QS`, `QD`, `CR`                   | Quick Spec, Quick Dev, Code Review                                                                  |
+| UX Designer (Sally)         | `CU`                               | Create UX Design                                                                                    |
+| Technical Writer (Paige)    | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Document Project, Write Document, Update Standards, Mermaid Generate, Validate Doc, Explain Concept |

package/docs/reference/commands.md

@@ -0,0 +1,151 @@
+---
+title: Commands
+description: Reference for BMad slash commands — what they are, how they work, and where to find them.
+sidebar:
+  order: 3
+---
+
+Slash commands are pre-built prompts that load agents, run workflows, or execute tasks inside your IDE. The BMad installer generates them from your installed modules at install time. If you later add, remove, or change modules, re-run the installer to keep commands in sync (see [Troubleshooting](#troubleshooting)).
+
+## Commands vs. Agent Menu Triggers
+
+BMad offers two ways to start work, and they serve different purposes.
+
+| Mechanism | How you invoke it | What happens |
+| --- | --- | --- |
+| **Slash command** | Type `/bmad-...` in your IDE | Directly loads an agent, runs a workflow, or executes a task |
+| **Agent menu trigger** | Load an agent first, then type a short code (e.g. `DS`) | The agent interprets the code and starts the matching workflow while staying in character |
+
+Agent menu triggers require an active agent session. Use slash commands when you know which workflow you want. Use triggers when you are already working with an agent and want to switch tasks without leaving the conversation.
+
+## How Commands Are Generated
+
+When you run `npx bmad-method install`, the installer reads the manifests for every selected module and writes one command file per agent, workflow, task, and tool. Each file is a short markdown prompt that instructs the AI to load the corresponding source file and follow its instructions.
+
+The installer uses templates for each command type:
+
+| Command type | What the generated file does |
+| --- | --- |
+| **Agent launcher** | Loads the agent persona file, activates its menu, and stays in character |
+| **Workflow command** | Loads the workflow engine (`workflow.xml`) and passes the workflow config |
+| **Task command** | Loads a standalone task file and follows its instructions |
+| **Tool command** | Loads a standalone tool file and follows its instructions |
+
+:::note[Re-running the installer]
+If you add or remove modules, run the installer again. It regenerates all command files to match your current module selection.
+:::
+
+## Where Command Files Live
+
+The installer writes command files into an IDE-specific directory inside your project. The exact path depends on which IDE you selected during installation.
+
+| IDE / CLI | Command directory |
+| --- | --- |
+| Claude Code | `.claude/commands/` |
+| Cursor | `.cursor/commands/` |
+| Windsurf | `.windsurf/workflows/` |
+| Other IDEs | See the installer output for the target path |
+
+All IDEs receive a flat set of command files in their command directory. For example, a Claude Code installation looks like:
+
+```text
+.claude/commands/
+├── bmad-agent-bmm-dev.md
+├── bmad-agent-bmm-pm.md
+├── bmad-bmm-create-prd.md
+├── bmad-editorial-review-prose.md
+├── bmad-help.md
+└── ...
+```
+
+The filename determines the slash command name in your IDE. For example, the file `bmad-agent-bmm-dev.md` registers the command `/bmad-agent-bmm-dev`.
+
+## How to Discover Your Commands
+
+Type `/bmad` in your IDE and use autocomplete to browse available commands.
+
+Run `/bmad-help` for context-aware guidance on your next step.
+
+:::tip[Quick discovery]
+The generated command folders in your project are the canonical list. Open them in your file explorer to see every command with its description.
+:::
+
+## Command Categories
+
+### Agent Commands
+
+Agent commands load a specialized AI persona with a defined role, communication style, and menu of workflows. Once loaded, the agent stays in character and responds to menu triggers.
+
+| Example command | Agent | Role |
+| --- | --- | --- |
+| `/bmad-agent-bmm-dev` | Amelia (Developer) | Implements stories with strict adherence to specs |
+| `/bmad-agent-bmm-pm` | John (Product Manager) | Creates and validates PRDs |
+| `/bmad-agent-bmm-architect` | Winston (Architect) | Designs system architecture |
+| `/bmad-agent-bmm-sm` | Bob (Scrum Master) | Manages sprints and stories |
+
+See [Agents](./agents.md) for the full list of default agents and their triggers.
+
+### Workflow Commands
+
+Workflow commands run a structured, multi-step process without loading an agent persona first. They load the workflow engine and pass a specific workflow configuration.
+
+| Example command | Purpose |
+| --- | --- |
+| `/bmad-bmm-create-prd` | Create a Product Requirements Document |
+| `/bmad-bmm-create-architecture` | Design system architecture |
+| `/bmad-bmm-dev-story` | Implement a story |
+| `/bmad-bmm-code-review` | Run a code review |
+| `/bmad-bmm-quick-spec` | Define an ad-hoc change (Quick Flow) |
+
+See [Workflow Map](./workflow-map.md) for the complete workflow reference organized by phase.
+
+### Task and Tool Commands
+
+Tasks and tools are standalone operations that do not require an agent or workflow context.
+
+#### BMad-Help: Your Intelligent Guide
+
+**`/bmad-help`** is your primary interface for discovering what to do next. It's not just a lookup tool — it's an intelligent assistant that:
+
+- **Inspects your project** to see what's already been done
+- **Understands natural language queries** — ask questions in plain English
+- **Varies by installed modules** — shows options based on what you have
+- **Auto-invokes after workflows** — every workflow ends with clear next steps
+- **Recommends the first required task** — no guessing where to start
+
+**Examples:**
+
+```
+/bmad-help
+/bmad-help I have a SaaS idea and know all the features. Where do I start?
+/bmad-help What are my options for UX design?
+/bmad-help I'm stuck on the PRD workflow
+```
+
+#### Other Tasks and Tools
+
+| Example command | Purpose |
+| --- | --- |
+| `/bmad-shard-doc` | Split a large markdown file into smaller sections |
+| `/bmad-index-docs` | Index project documentation |
+| `/bmad-editorial-review-prose` | Review document prose quality |
+
+## Naming Convention
+
+Command names follow a predictable pattern.
+
+| Pattern | Meaning | Example |
+| --- | --- | --- |
+| `bmad-agent-<module>-<name>` | Agent launcher | `bmad-agent-bmm-dev` |
+| `bmad-<module>-<workflow>` | Workflow command | `bmad-bmm-create-prd` |
+| `bmad-<name>` | Core task or tool | `bmad-help` |
+
+Module codes: `bmm` (Agile suite), `bmb` (Builder), `tea` (Test Architect), `cis` (Creative Intelligence), `gds` (Game Dev Studio). See [Modules](./modules.md) for descriptions.
+
+## Troubleshooting
+
+**Commands not appearing after install.** Restart your IDE or reload the window. Some IDEs cache the command list and require a refresh to pick up new files.
+
+**Expected commands are missing.** The installer only generates commands for modules you selected. Run `npx bmad-method install` again and verify your module selection. Check that the command files exist in the expected directory.
+
+**Commands from a removed module still appear.** The installer does not delete old command files automatically. Remove the stale files from your IDE's command directory, or delete the entire command directory and re-run the installer for a clean set.

package/docs/reference/modules.md

@@ -0,0 +1,76 @@
+---
+title: Official Modules
+description: Add-on modules for building custom agents, creative intelligence, game development, and testing
+sidebar:
+  order: 4
+---
+
+BMad extends through official modules that you select during installation. These add-on modules provide specialized agents, workflows, and tasks for specific domains beyond the built-in core and BMM (Agile suite).
+
+:::tip[Installing Modules]
+Run `npx bmad-method install` and select the modules you want. The installer handles downloading, configuration, and IDE integration automatically.
+:::
+
+## BMad Builder
+
+Create custom agents, workflows, and domain-specific modules with guided assistance. BMad Builder is the meta-module for extending the framework itself.
+
+- **Code:** `bmb`
+- **npm:** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
+- **GitHub:** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
+
+**Provides:**
+
+- Agent Builder -- create specialized AI agents with custom expertise and tool access
+- Workflow Builder -- design structured processes with steps and decision points
+- Module Builder -- package agents and workflows into shareable, publishable modules
+- Interactive setup with YAML configuration and npm publishing support
+
+## Creative Intelligence Suite
+
+AI-powered tools for structured creativity, ideation, and innovation during early-stage development. The suite provides multiple agents that facilitate brainstorming, design thinking, and problem-solving using proven frameworks.
+
+- **Code:** `cis`
+- **npm:** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
+- **GitHub:** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
+
+**Provides:**
+
+- Innovation Strategist, Design Thinking Coach, and Brainstorming Coach agents
+- Problem Solver and Creative Problem Solver for systematic and lateral thinking
+- Storyteller and Presentation Master for narratives and pitches
+- Ideation frameworks including SCAMPER, Reverse Brainstorming, and problem reframing
+
+## Game Dev Studio
+
+Structured game development workflows adapted for Unity, Unreal, Godot, and custom engines. Supports rapid prototyping through Quick Flow and full-scale production with epic-driven sprints.
+
+- **Code:** `gds`
+- **npm:** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
+- **GitHub:** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
+
+**Provides:**
+
+- Game Design Document (GDD) generation workflow
+- Quick Dev mode for rapid prototyping
+- Narrative design support for characters, dialogue, and world-building
+- Coverage for 21+ game types with engine-specific architecture guidance
+
+## Test Architect (TEA)
+
+Enterprise-grade test strategy, automation guidance, and release gate decisions through an expert agent and nine structured workflows. TEA goes well beyond the built-in QA agent with risk-based prioritization and requirements traceability.
+
+- **Code:** `tea`
+- **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
+- **GitHub:** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
+
+**Provides:**
+
+- Murat agent (Master Test Architect and Quality Advisor)
+- Workflows for test design, ATDD, automation, test review, and traceability
+- NFR assessment, CI setup, and framework scaffolding
+- P0-P3 prioritization with optional Playwright Utils and MCP integrations
+
+## Community Modules
+
+Community modules and a module marketplace are coming. Check the [BMad GitHub organization](https://github.com/bmad-code-org) for updates.