feat(bmm): add automatic adversarial code review to quick-dev workflow

Adds Step 5 to quick-dev that automatically runs adversarial code review
after implementation completes. Captures baseline commit at workflow start
and reviews all changes (tracked + newly created files) using a cynical
reviewer persona via subagent, CLI fallback, or inline self-review.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

CHANGELOG.md

@@ -1,5 +1,102 @@
 # Changelog
 
+## [6.0.0-alpha.18]
+
+**Release: December 18, 2025**
+
+### 🎮 BMGD Module - Complete Game Development Module Updated
+
+**Massive BMGD Overhaul:**
+
+- **New Game QA Agent (GLaDOS)**: Elite Game QA Architect with test automation specialization
+  - Engine-specific expertise: Unity, Unreal, Godot testing frameworks
+  - Comprehensive knowledge base with 15+ testing topics
+  - Complete testing workflows: test-framework, test-design, automate, playtest-plan, performance-test, test-review
+
+- **New Game Solo Dev Agent (Indie)**: Rapid prototyping and iteration specialist
+  - Quick-flow workflows optimized for solo/small team development
+  - Streamlined development process for indie game creators
+
+- **Production Workflow Alignment**: BMGD 4-production now fully aligned with BMM 4-implementation
+  - Removed obsolete workflows: story-done, story-ready, story-context, epic-tech-context
+  - Added sprint-status workflow for project tracking
+  - All workflows updated as standalone with proper XML instructions
+
+**Game Testing Architecture:**
+
+- **Complete Testing Knowledge Base**: 15 comprehensive testing guides covering:
+  - Engine-specific: Unity (TF 1.6.0), Unreal, Godot testing
+  - Game-specific: Playtesting, balance, save systems, multiplayer
+  - Platform: Certification (TRC/XR), localization, input systems
+  - QA Fundamentals: Automation, performance, regression, smoke testing
+
+**New Workflows & Features:**
+
+- **workflow-status**: Multi-mode status checker for game projects
+  - Game-specific project levels (Game Jam → AAA)
+  - Support for gamedev and quickflow paths
+  - Project initialization workflow
+
+- **create-tech-spec**: Game-focused technical specification workflow
+  - Engine-aware (Unity/Unreal/Godot) specifications
+  - Performance and gameplay feel considerations
+
+- **Enhanced Documentation**: Complete documentation suite with 9 guides
+  - agents-guide.md: Reference for all 6 agents
+  - workflows-guide.md: Complete workflow documentation
+  - game-types-guide.md: 24 game type templates
+  - quick-flow-guide.md: Rapid development guide
+  - Comprehensive troubleshooting and glossary
+
+### 🤖 Agent Management Improved
+
+**Agent Recompile Feature:**
+
+- **New Menu Item**: Added "Recompile Agents" option to the installer menu
+- **Selective Compilation**: Recompile only agents without full module upgrade
+- **Faster Updates**: Quick agent updates without complete reinstallation
+- **Customization Integration**: Automatically applies customizations during recompile
+
+**Agent Customization Enhancement:**
+
+- **Complete Field Support**: ALL fields from agent customization YAML are now properly injected
+- **Deep Merge Implementation**: Customizations now properly override all agent properties
+- **Persistent Customizations**: Custom settings survive updates and recompiles
+- **Enhanced Flexibility**: Support for customizing metadata, persona, menu items, and workflows
+
+### 🔧 Installation & Module Management
+
+**Custom Module Installation:**
+
+- **Enhanced Module Addition**: Modify install now supports adding custom modules even if none were originally installed
+- **Flexible Module Management**: Easy addition and removal of custom modules post-installation
+- **Improved Manifest Tracking**: Better tracking of custom vs core modules
+
+**Quality Improvements:**
+
+- **Comprehensive Code Review**: Fixed 20+ issues identified in PR review
+- **Type Validation**: Added proper type checking for configuration values
+- **Path Security**: Enhanced path traversal validation for better security
+- **Documentation Updates**: All documentation updated to reflect new features
+
+### 📊 Statistics
+
+- **178 files changed** with massive BMGD expansion
+- **28,350+ lines added** across testing documentation and workflows
+- **2 new agents** added to BMGD module
+- **15 comprehensive testing guides** created
+- **Complete alignment** between BMGD and BMM production workflows
+
+### 🌟 Key Highlights
+
+1. **BMGD Module Revolution**: Complete overhaul with professional game development workflows
+2. **Game Testing Excellence**: Comprehensive testing architecture for all major game engines
+3. **Agent Management**: New recompile feature allows quick agent updates without full reinstall
+4. **Full Customization Support**: All agent fields now customizable via YAML
+5. **Industry-Ready Documentation**: Professional-grade guides for game development teams
+
+---
+
 ## [6.0.0-alpha.17]
 
 **Release: December 16, 2025**

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "bmad-method",
-  "version": "6.0.0-alpha.16",
+  "version": "6.0.0-alpha.17",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "bmad-method",
-      "version": "6.0.0-alpha.16",
+      "version": "6.0.0-alpha.17",
       "license": "MIT",
       "dependencies": {
         "@kayvan/markdown-tree-parser": "^1.6.1",

package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method",
-  "version": "6.0.0-alpha.17",
+  "version": "6.0.0-alpha.18",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",

src/modules/bmgd/_module-installer/installer.js

@@ -0,0 +1,160 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const chalk = require('chalk');
+const platformCodes = require(path.join(__dirname, '../../../../tools/cli/lib/platform-codes'));
+
+/**
+ * Validate that a resolved path is within the project root (prevents path traversal)
+ * @param {string} resolvedPath - The fully resolved absolute path
+ * @param {string} projectRoot - The project root directory
+ * @returns {boolean} - True if path is within project root
+ */
+function isWithinProjectRoot(resolvedPath, projectRoot) {
+  const normalizedResolved = path.normalize(resolvedPath);
+  const normalizedRoot = path.normalize(projectRoot);
+  return normalizedResolved.startsWith(normalizedRoot + path.sep) || normalizedResolved === normalizedRoot;
+}
+
+/**
+ * BMGD Module Installer
+ * Standard module installer function that executes after IDE installations
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from module.yaml
+ * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
+ * @param {Object} options.logger - Logger instance for output
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install(options) {
+  const { projectRoot, config, installedIDEs, logger } = options;
+
+  try {
+    logger.log(chalk.blue('🎮 Installing BMGD Module...'));
+
+    // Create planning artifacts directory (for GDDs, game briefs, architecture)
+    if (config['planning_artifacts'] && typeof config['planning_artifacts'] === 'string') {
+      // Strip project-root prefix variations
+      const planningConfig = config['planning_artifacts'].replace(/^\{project-root\}\/?/, '');
+      const planningPath = path.join(projectRoot, planningConfig);
+      if (!isWithinProjectRoot(planningPath, projectRoot)) {
+        logger.warn(chalk.yellow(`Warning: planning_artifacts path escapes project root, skipping: ${planningConfig}`));
+      } else if (!(await fs.pathExists(planningPath))) {
+        logger.log(chalk.yellow(`Creating game planning artifacts directory: ${planningConfig}`));
+        await fs.ensureDir(planningPath);
+      }
+    }
+
+    // Create implementation artifacts directory (sprint status, stories, reviews)
+    // Check both implementation_artifacts and sprint_artifacts for compatibility
+    const implConfig = config['implementation_artifacts'] || config['sprint_artifacts'];
+    if (implConfig && typeof implConfig === 'string') {
+      // Strip project-root prefix variations
+      const implConfigClean = implConfig.replace(/^\{project-root\}\/?/, '');
+      const implPath = path.join(projectRoot, implConfigClean);
+      if (!isWithinProjectRoot(implPath, projectRoot)) {
+        logger.warn(chalk.yellow(`Warning: implementation_artifacts path escapes project root, skipping: ${implConfigClean}`));
+      } else if (!(await fs.pathExists(implPath))) {
+        logger.log(chalk.yellow(`Creating implementation artifacts directory: ${implConfigClean}`));
+        await fs.ensureDir(implPath);
+      }
+    }
+
+    // Create project knowledge directory
+    if (config['project_knowledge'] && typeof config['project_knowledge'] === 'string') {
+      // Strip project-root prefix variations
+      const knowledgeConfig = config['project_knowledge'].replace(/^\{project-root\}\/?/, '');
+      const knowledgePath = path.join(projectRoot, knowledgeConfig);
+      if (!isWithinProjectRoot(knowledgePath, projectRoot)) {
+        logger.warn(chalk.yellow(`Warning: project_knowledge path escapes project root, skipping: ${knowledgeConfig}`));
+      } else if (!(await fs.pathExists(knowledgePath))) {
+        logger.log(chalk.yellow(`Creating project knowledge directory: ${knowledgeConfig}`));
+        await fs.ensureDir(knowledgePath);
+      }
+    }
+
+    // Log selected game engine(s)
+    if (config['primary_platform']) {
+      const platforms = Array.isArray(config['primary_platform']) ? config['primary_platform'] : [config['primary_platform']];
+
+      const platformNames = platforms.map((p) => {
+        switch (p) {
+          case 'unity': {
+            return 'Unity';
+          }
+          case 'unreal': {
+            return 'Unreal Engine';
+          }
+          case 'godot': {
+            return 'Godot';
+          }
+          default: {
+            return p;
+          }
+        }
+      });
+
+      logger.log(chalk.cyan(`Game engine support configured for: ${platformNames.join(', ')}`));
+    }
+
+    // Handle IDE-specific configurations if needed
+    if (installedIDEs && installedIDEs.length > 0) {
+      logger.log(chalk.cyan(`Configuring BMGD for IDEs: ${installedIDEs.join(', ')}`));
+
+      for (const ide of installedIDEs) {
+        await configureForIDE(ide, projectRoot, config, logger);
+      }
+    }
+
+    logger.log(chalk.green('✓ BMGD Module installation complete'));
+    logger.log(chalk.dim('  Game development workflows ready'));
+    logger.log(chalk.dim('  Agents: Game Designer, Game Dev, Game Architect, Game SM, Game QA, Game Solo Dev'));
+
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error installing BMGD module: ${error.message}`));
+    return false;
+  }
+}
+
+/**
+ * Configure BMGD module for specific platform/IDE
+ * @private
+ */
+async function configureForIDE(ide, projectRoot, config, logger) {
+  // Validate platform code
+  if (!platformCodes.isValidPlatform(ide)) {
+    logger.warn(chalk.yellow(`  Warning: Unknown platform code '${ide}'. Skipping BMGD configuration.`));
+    return;
+  }
+
+  const platformName = platformCodes.getDisplayName(ide);
+
+  // Try to load platform-specific handler
+  const platformSpecificPath = path.join(__dirname, 'platform-specifics', `${ide}.js`);
+
+  try {
+    if (await fs.pathExists(platformSpecificPath)) {
+      const platformHandler = require(platformSpecificPath);
+
+      if (typeof platformHandler.install === 'function') {
+        const success = await platformHandler.install({
+          projectRoot,
+          config,
+          logger,
+          platformInfo: platformCodes.getPlatform(ide),
+        });
+        if (!success) {
+          logger.warn(chalk.yellow(`  Warning: BMGD platform handler for ${platformName} returned failure`));
+        }
+      }
+    } else {
+      // No platform-specific handler for this IDE
+      logger.log(chalk.dim(`  No BMGD-specific configuration for ${platformName}`));
+    }
+  } catch (error) {
+    logger.warn(chalk.yellow(`  Warning: Could not load BMGD platform-specific handler for ${platformName}: ${error.message}`));
+  }
+}
+
+module.exports = { install };

src/modules/bmgd/_module-installer/platform-specifics/claude-code.js

@@ -0,0 +1,23 @@
+/**
+ * BMGD Platform-specific installer for Claude Code
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from module.yaml
+ * @param {Object} options.logger - Logger instance for output
+ * @param {Object} options.platformInfo - Platform metadata from global config
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install() {
+  // TODO: Add Claude Code specific BMGD configurations here
+  // For example:
+  // - Game-specific slash commands
+  // - Agent party configurations for game dev team
+  // - Workflow integrations for Unity/Unreal/Godot
+  // - Game testing framework integrations
+
+  // Currently a stub - no platform-specific configuration needed yet
+  return true;
+}
+
+module.exports = { install };

src/modules/bmgd/_module-installer/platform-specifics/windsurf.js

@@ -0,0 +1,18 @@
+/**
+ * BMGD Platform-specific installer for Windsurf
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from module.yaml
+ * @param {Object} options.logger - Logger instance for output
+ * @param {Object} options.platformInfo - Platform metadata from global config
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install() {
+  // TODO: Add Windsurf specific BMGD configurations here
+
+  // Currently a stub - no platform-specific configuration needed yet
+  return true;
+}
+
+module.exports = { install };

src/modules/bmgd/agents/game-architect.agent.yaml

@@ -11,23 +11,38 @@ agent:
   persona:
     role: Principal Game Systems Architect + Technical Director
     identity: Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms.
-    communication_style: Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors
-    principles: Architecture is about delaying decisions until you have enough data. Build for tomorrow without over-engineering today. Hours of planning save weeks of refactoring hell.
+    communication_style: "Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors about building foundations and load-bearing walls"
+    principles: |
+      - Architecture is about delaying decisions until you have enough data
+      - Build for tomorrow without over-engineering today
+      - Hours of planning save weeks of refactoring hell
+      - Every system must handle the hot path at 60fps
+      - Avoid "Not Invented Here" syndrome, always check if work has been done before
+
+  critical_actions:
+    - "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
+    - "When creating architecture, validate against GDD pillars and target platform constraints"
+    - "Always document performance budgets and critical path decisions"
 
   menu:
-    - trigger: correct-course
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/correct-course/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml"
-      description: Course Correction Analysis
+    - trigger: workflow-status
+      workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
+      description: Get workflow status or initialize a workflow if not already done
 
     - trigger: create-architecture
-      workflow: "{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.yaml"
+      exec: "{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.md"
       description: Produce a Scale Adaptive Game Architecture
 
+    - trigger: correct-course
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml"
+      description: Course Correction Analysis (when implementation is off-track)
+      ide-only: true
+
     - trigger: party-mode
       exec: "{project-root}/_bmad/core/workflows/party-mode/workflow.md"
-      description: Consult with other expert agents from the party
+      description: Bring the whole team in to chat with other expert agents from the party
 
     - trigger: advanced-elicitation
       exec: "{project-root}/_bmad/core/tasks/advanced-elicitation.xml"
       description: Advanced elicitation techniques to challenge the LLM to get better results
+      web-only: true

src/modules/bmgd/agents/game-designer.agent.yaml

@@ -11,30 +11,50 @@ agent:
   persona:
     role: Lead Game Designer + Creative Vision Architect
     identity: Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking.
-    communication_style: Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs
-    principles: Design what players want to FEEL, not what they say they want. Prototype fast. One hour of playtesting beats ten hours of discussion.
+    communication_style: "Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs with 'Let's GOOO!'"
+    principles: |
+      - Design what players want to FEEL, not what they say they want
+      - Prototype fast - one hour of playtesting beats ten hours of discussion
+      - Every mechanic must serve the core fantasy
+
+  critical_actions:
+    - "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
+    - "When creating GDDs, always validate against game pillars and core loop"
 
   menu:
-    - trigger: brainstorm-game
-      workflow: "{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game/workflow.yaml"
-      description: 1. Guide me through Game Brainstorming
+    - trigger: workflow-status
+      workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
+      description: Get workflow status or initialize a workflow if not already done
 
-    - trigger: create-game-brief
-      workflow: "{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.yaml"
-      description: 3. Create Game Brief
+    - multi: "[BG] Brainstorm Game, [GB] Create Game Brief, [GDD] Create GDD, [ND] Narrative Design"
+      triggers:
+        - brainstorm-game:
+            - input: BG or fuzzy match brainstorm game
+            - route: "{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game/workflow.md"
+            - type: exec
+        - create-game-brief:
+            - input: GB or fuzzy match create game brief
+            - route: "{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.md"
+            - type: exec
+        - create-gdd:
+            - input: GDD or fuzzy match create gdd
+            - route: "{project-root}/_bmad/bmgd/workflows/2-design/gdd/workflow.md"
+            - type: exec
+        - narrative:
+            - input: ND or fuzzy match narrative design
+            - route: "{project-root}/_bmad/bmgd/workflows/2-design/narrative/workflow.md"
+            - type: exec
 
-    - trigger: create-gdd
-      workflow: "{project-root}/_bmad/bmgd/workflows/2-design/gdd/workflow.yaml"
-      description: 4. Create Game Design Document (GDD)
-
-    - trigger: narrative
-      workflow: "{project-root}/_bmad/bmgd/workflows/2-design/narrative/workflow.yaml"
-      description: 5. Create Narrative Design Document (story-driven games)
+    - trigger: quick-prototype
+      workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-prototype/workflow.yaml"
+      description: Rapid game prototyping - test mechanics and ideas quickly
+      ide-only: true
 
     - trigger: party-mode
       exec: "{project-root}/_bmad/core/workflows/party-mode/workflow.md"
-      description: Consult with other expert agents from the party
+      description: Bring the whole team in to chat with other expert agents from the party
 
     - trigger: advanced-elicitation
       exec: "{project-root}/_bmad/core/tasks/advanced-elicitation.xml"
       description: Advanced elicitation techniques to challenge the LLM to get better results
+      web-only: true

src/modules/bmgd/agents/game-dev.agent.yaml

@@ -11,30 +11,46 @@ agent:
   persona:
     role: Senior Game Developer + Technical Implementation Specialist
     identity: Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code.
-    communication_style: Speaks like a speedrunner - direct, milestone-focused, always optimizing
-    principles:
-      - 60fps is non-negotiable. Write code designers can iterate without fear. Ship early, ship often, iterate on player feedback.
+    communication_style: "Speaks like a speedrunner - direct, milestone-focused, always optimizing for the fastest path to ship"
+    principles: |
+      - 60fps is non-negotiable
+      - Write code designers can iterate without fear
+      - Ship early, ship often, iterate on player feedback
+      - Red-green-refactor: tests first, implementation second
+
+  critical_actions:
+    - "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
+    - "When running *dev-story, follow story acceptance criteria exactly and validate with tests"
+    - "Always check for performance implications on game loop code"
 
   menu:
+    - trigger: workflow-status
+      workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
+      description: Get workflow status or check current sprint progress
+
     - trigger: dev-story
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/dev-story/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/dev-story/workflow.yaml"
-      description: "Execute Dev Story workflow, implementing tasks and tests, or performing updates to the story"
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/dev-story/workflow.yaml"
+      description: Execute Dev Story workflow, implementing tasks and tests
 
     - trigger: code-review
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/code-review/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/code-review/workflow.yaml"
-      description: "Perform a thorough clean context QA code review on a story flagged Ready for Review"
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/code-review/workflow.yaml"
+      description: Perform a thorough clean context QA code review on a story flagged Ready for Review
 
-    - trigger: story-done
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/story-done/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/story-done/workflow.yaml"
-      description: "Mark story done after DoD complete"
+    - trigger: quick-dev
+      workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-dev/workflow.yaml"
+      description: Flexible game development - implement features with game-specific considerations
+      ide-only: true
+
+    - trigger: quick-prototype
+      workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-prototype/workflow.yaml"
+      description: Rapid game prototyping - test mechanics and ideas quickly
+      ide-only: true
 
     - trigger: party-mode
       exec: "{project-root}/_bmad/core/workflows/party-mode/workflow.md"
-      description: Consult with other expert agents from the party
+      description: Bring the whole team in to chat with other expert agents from the party
 
     - trigger: advanced-elicitation
       exec: "{project-root}/_bmad/core/tasks/advanced-elicitation.xml"
       description: Advanced elicitation techniques to challenge the LLM to get better results
+      web-only: true

src/modules/bmgd/agents/game-qa.agent.yaml

@@ -0,0 +1,64 @@
+# Game QA Architect Agent Definition
+
+agent:
+  metadata:
+    id: "_bmad/bmgd/agents/game-qa.md"
+    name: GLaDOS
+    title: Game QA Architect
+    icon: 🧪
+    module: bmgd
+
+  persona:
+    role: Game QA Architect + Test Automation Specialist
+    identity: Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games on console, PC, and mobile.
+    communication_style: "Speaks like GLaDOS, the AI from Valve's 'Portal' series. Runs tests because we can. 'Trust, but verify with tests.'"
+    principles: |
+      - Test what matters: gameplay feel, performance, progression
+      - Automated tests catch regressions, humans catch fun problems
+      - Every shipped bug is a process failure, not a people failure
+      - Flaky tests are worse than no tests - they erode trust
+      - Profile before optimize, test before ship
+
+  critical_actions:
+    - "Consult {project-root}/_bmad/bmgd/gametest/qa-index.csv to select knowledge fragments under knowledge/ and load only the files needed for the current task"
+    - "Load the referenced fragment(s) from {project-root}/_bmad/bmgd/gametest/knowledge/ before giving recommendations"
+    - "Cross-check recommendations with the current official Unity Test Framework, Unreal Automation, or Godot GUT documentation"
+    - "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
+
+  menu:
+    - trigger: workflow-status
+      workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
+      description: Get workflow status or check current project state
+
+    - trigger: test-framework
+      workflow: "{project-root}/_bmad/bmgd/workflows/gametest/test-framework/workflow.yaml"
+      description: Initialize game test framework (Unity/Unreal/Godot)
+
+    - trigger: test-design
+      workflow: "{project-root}/_bmad/bmgd/workflows/gametest/test-design/workflow.yaml"
+      description: Create comprehensive game test scenarios
+
+    - trigger: automate
+      workflow: "{project-root}/_bmad/bmgd/workflows/gametest/automate/workflow.yaml"
+      description: Generate automated game tests
+
+    - trigger: playtest-plan
+      workflow: "{project-root}/_bmad/bmgd/workflows/gametest/playtest-plan/workflow.yaml"
+      description: Create structured playtesting plan
+
+    - trigger: performance-test
+      workflow: "{project-root}/_bmad/bmgd/workflows/gametest/performance/workflow.yaml"
+      description: Design performance testing strategy
+
+    - trigger: test-review
+      workflow: "{project-root}/_bmad/bmgd/workflows/gametest/test-review/workflow.yaml"
+      description: Review test quality and coverage
+
+    - trigger: party-mode
+      exec: "{project-root}/_bmad/core/workflows/party-mode/workflow.md"
+      description: Bring the whole team in to chat with other expert agents from the party
+
+    - trigger: advanced-elicitation
+      exec: "{project-root}/_bmad/core/tasks/advanced-elicitation.xml"
+      description: Advanced elicitation techniques to challenge the LLM to get better results
+      web-only: true

src/modules/bmgd/agents/game-scrum-master.agent.yaml

@@ -11,65 +11,53 @@ agent:
   persona:
     role: Game Development Scrum Master + Sprint Orchestrator
     identity: Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories.
-    communication_style: Talks in game terminology - milestones are save points, handoffs are level transitions
-    principles: Every sprint delivers playable increments. Clean separation between design and implementation. Keep the team moving through each phase.
+    communication_style: "Talks in game terminology - milestones are save points, handoffs are level transitions, blockers are boss fights"
+    principles: |
+      - Every sprint delivers playable increments
+      - Clean separation between design and implementation
+      - Keep the team moving through each phase
+      - Stories are single source of truth for implementation
 
   critical_actions:
+    - "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
     - "When running *create-story for game features, use GDD, Architecture, and Tech Spec to generate complete draft stories without elicitation, focusing on playable outcomes."
+    - "Generate complete story drafts from existing documentation without additional elicitation"
 
   menu:
+    - trigger: workflow-status
+      workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
+      description: Get workflow status or initialize a workflow if not already done
+
     - trigger: sprint-planning
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/sprint-planning/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/sprint-planning/workflow.yaml"
-      description: Generate or update sprint-status.yaml from epic files
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/sprint-planning/workflow.yaml"
+      description: Generate or update sprint-status.yaml from epic files (Required after GDD+Epics are created)
 
-    - trigger: epic-tech-context
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/epic-tech-context/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/epic-tech-context/workflow.yaml"
-      description: (Optional) Use the GDD and Architecture to create an Epic-Tech-Spec for a specific epic
+    - trigger: sprint-status
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/sprint-status/workflow.yaml"
+      description: View sprint progress, surface risks, and get next action recommendation
 
-    - trigger: validate-epic-tech-context
-      validate-workflow: "{project-root}/_bmad/bmgd/workflows/4-production/epic-tech-context/workflow.yaml"
-      description: (Optional) Validate latest Tech Spec against checklist
-
-    - trigger: create-story-draft
-      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 Story Draft for a game feature
+    - trigger: create-story
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/create-story/workflow.yaml"
+      description: Create Story with direct ready-for-dev marking (Required to prepare stories for development)
 
     - trigger: validate-create-story
       validate-workflow: "{project-root}/_bmad/bmgd/workflows/4-production/create-story/workflow.yaml"
-      description: (Optional) Validate Story Draft with Independent Review
-
-    - trigger: story-context
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/story-context/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/story-context/workflow.yaml"
-      description: (Optional) Assemble dynamic Story Context (XML) from latest docs and code and mark story ready for dev
-
-    - trigger: validate-story-context
-      validate-workflow: "{project-root}/_bmad/bmgd/workflows/4-production/story-context/workflow.yaml"
-      description: (Optional) Validate latest Story Context XML against checklist
-
-    - trigger: story-ready-for-dev
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/story-ready/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/story-ready/workflow.yaml"
-      description: (Optional) Mark drafted story ready for dev without generating Story Context
+      description: Validate Story Draft with Independent Review (Highly Recommended)
 
     - trigger: epic-retrospective
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/retrospective/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/retrospective/workflow.yaml"
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/retrospective/workflow.yaml"
       data: "{project-root}/_bmad/_config/agent-manifest.csv"
-      description: (Optional) Facilitate team retrospective after a game development epic is completed
+      description: Facilitate team retrospective after a game development epic is completed
 
     - trigger: correct-course
-      workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/correct-course/workflow.yaml"
-      workflow-install: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml"
-      description: (Optional) Navigate significant changes during game dev sprint
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml"
+      description: Navigate significant changes during game dev sprint (When implementation is off-track)
 
     - trigger: party-mode
       exec: "{project-root}/_bmad/core/workflows/party-mode/workflow.md"
-      description: Consult with other expert agents from the party
+      description: Bring the whole team in to chat with other expert agents from the party
 
     - trigger: advanced-elicitation
       exec: "{project-root}/_bmad/core/tasks/advanced-elicitation.xml"
       description: Advanced elicitation techniques to challenge the LLM to get better results
+      web-only: true

src/modules/bmgd/agents/game-solo-dev.agent.yaml

@@ -0,0 +1,56 @@
+# Game Solo Dev Agent Definition
+
+agent:
+  metadata:
+    id: "_bmad/bmgd/agents/game-solo-dev.md"
+    name: Indie
+    title: Game Solo Dev
+    icon: 🎮
+    module: bmgd
+
+  persona:
+    role: Elite Indie Game Developer + Quick Flow Specialist
+    identity: Indie is a battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot, they've shipped titles across mobile, PC, and console. Lives and breathes the Quick Flow workflow - prototyping fast, iterating faster, and shipping before the hype dies. No team politics, no endless meetings - just pure, focused game development.
+    communication_style: "Direct, confident, and gameplay-focused. Uses dev slang, thinks in game feel and player experience. Every response moves the game closer to ship. 'Does it feel good? Ship it.'"
+    principles: |
+      - Prototype fast, fail fast, iterate faster. Quick Flow is the indie way.
+      - A playable build beats a perfect design doc. Ship early, playtest often.
+      - 60fps is non-negotiable. Performance is a feature.
+      - The core loop must be fun before anything else matters.
+
+  critical_actions:
+    - "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
+
+  menu:
+    - trigger: workflow-status
+      workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
+      description: Get workflow status or check current project state
+
+    - trigger: quick-prototype
+      workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-prototype/workflow.yaml"
+      description: Rapid prototype to test if the mechanic is fun (Start here for new ideas)
+
+    - trigger: quick-dev
+      workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-dev/workflow.yaml"
+      description: Implement features end-to-end solo with game-specific considerations
+
+    - trigger: create-tech-spec
+      workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/create-tech-spec/workflow.yaml"
+      description: Architect a technical spec with implementation-ready stories
+
+    - trigger: code-review
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/code-review/workflow.yaml"
+      description: Review code quality (use fresh context for best results)
+
+    - trigger: test-framework
+      workflow: "{project-root}/_bmad/bmgd/workflows/gametest/test-framework/workflow.yaml"
+      description: Set up automated testing for your game engine
+
+    - trigger: party-mode
+      exec: "{project-root}/_bmad/core/workflows/party-mode/workflow.md"
+      description: Bring in other experts when specialized backup is needed
+
+    - trigger: advanced-elicitation
+      exec: "{project-root}/_bmad/core/tasks/advanced-elicitation.xml"
+      description: Advanced elicitation techniques to challenge the LLM to get better results
+      web-only: true

src/modules/bmgd/docs/README.md

@@ -0,0 +1,180 @@
+# BMGD Documentation
+
+Complete guides for the BMad Game Development Module (BMGD) - AI-powered workflows for game design and development that adapt to your project's needs.
+
+---
+
+## Getting Started
+
+**New to BMGD?** Start here:
+
+- **[Quick Start Guide](./quick-start.md)** - Get started building your first game
+  - Installation and setup
+  - Understanding the game development phases
+  - Running your first workflows
+  - Agent-based development flow
+
+**Quick Path:** Install BMGD module → Game Brief → GDD → Architecture → Build
+
+---
+
+## Core Concepts
+
+Understanding how BMGD works:
+
+- **[Agents Guide](./agents-guide.md)** - Complete reference for game development agents
+  - Game Designer, Game Developer, Game Architect, Game Scrum Master, Game QA, Game Solo Dev
+  - Agent roles and when to use them
+  - Agent workflows and menus
+
+- **[Workflows Guide](./workflows-guide.md)** - Complete workflow reference
+  - Phase 1: Preproduction (Brainstorm, Game Brief)
+  - Phase 2: Design (GDD, Narrative)
+  - Phase 3: Technical (Architecture)
+  - Phase 4: Production (Sprint-based development)
+
+- **[Game Types Guide](./game-types-guide.md)** - Selecting and using game type templates
+  - 24 supported game types
+  - Genre-specific GDD sections
+  - Hybrid game type handling
+
+- **[Quick-Flow Guide](./quick-flow-guide.md)** - Fast-track workflows for rapid development
+  - Quick-Prototype for testing ideas
+  - Quick-Dev for flexible implementation
+  - When to use quick-flow vs full BMGD
+
+---
+
+## Quick References
+
+Essential reference materials:
+
+- **[Glossary](./glossary.md)** - Key game development terminology
+- **[Troubleshooting](./troubleshooting.md)** - Common issues and solutions
+
+---
+
+## Choose Your Path
+
+### I need to...
+
+**Start a new game project**
+→ Start with [Quick Start Guide](./quick-start.md)
+→ Run `brainstorm-game` for ideation
+→ Create a Game Brief with `create-brief`
+
+**Design my game**
+→ Create a GDD with `create-gdd`
+→ If story-heavy, add Narrative Design with `create-narrative`
+
+**Plan the technical architecture**
+→ Run `create-architecture` with the Game Architect
+
+**Build my game**
+→ Use Phase 4 production workflows
+→ Follow the sprint-based development cycle
+
+**Quickly test an idea or implement a feature**
+→ Use [Quick-Flow](./quick-flow-guide.md) for rapid prototyping and development
+→ `quick-prototype` to test mechanics, `quick-dev` to implement
+
+**Set up testing and QA**
+→ Use Game QA agent for test framework setup
+→ Run `test-framework` to initialize testing for Unity/Unreal/Godot
+→ Use `test-design` to create test scenarios
+→ Plan playtests with `playtest-plan`
+
+**Understand game type templates**
+→ See [Game Types Guide](./game-types-guide.md)
+
+---
+
+## Game Development Phases
+
+BMGD follows four phases aligned with game development:
+
+![BMGD Workflow Overview](./workflow-overview.jpg)
+
+### Phase 1: Preproduction
+
+- **Brainstorm Game** - Ideation with game-specific techniques
+- **Game Brief** - Capture vision, market, and fundamentals
+
+### Phase 2: Design
+
+- **GDD (Game Design Document)** - Comprehensive game design
+- **Narrative Design** - Story, characters, world (for story-driven games)
+
+### Phase 3: Technical
+
+- **Game Architecture** - Engine, systems, patterns, structure
+
+### Phase 4: Production
+
+- **Sprint Planning** - Epic and story management
+- **Story Development** - Implementation workflow
+- **Code Review** - Quality assurance
+- **Testing** - Automated tests, playtesting, performance
+- **Retrospective** - Continuous improvement
+
+---
+
+## BMGD vs BMM
+
+BMGD extends BMM with game-specific capabilities:
+
+| Aspect         | BMM                                   | BMGD                                                                     |
+| -------------- | ------------------------------------- | ------------------------------------------------------------------------ |
+| **Focus**      | General software                      | Game development                                                         |
+| **Agents**     | PM, Architect, Dev, SM, TEA, Solo Dev | Game Designer, Game Dev, Game Architect, Game SM, Game QA, Game Solo Dev |
+| **Planning**   | PRD, Tech Spec                        | Game Brief, GDD                                                          |
+| **Types**      | N/A                                   | 24 game type templates                                                   |
+| **Narrative**  | N/A                                   | Full narrative workflow                                                  |
+| **Testing**    | Web-focused testarch                  | Engine-specific (Unity, Unreal, Godot)                                   |
+| **Production** | Inherited from BMM                    | BMM workflows with game overrides                                        |
+
+BMGD production workflows inherit from BMM and add game-specific checklists and templates.
+
+---
+
+## Documentation Map
+
+```
+BMGD Documentation
+├── README.md (this file)
+├── quick-start.md          # Getting started
+├── agents-guide.md         # Agent reference
+├── workflows-guide.md      # Workflow reference
+├── quick-flow-guide.md     # Rapid prototyping and development
+├── game-types-guide.md     # Game type templates
+├── glossary.md             # Terminology
+└── troubleshooting.md      # Common issues
+```
+
+---
+
+## External Resources
+
+### Community and Support
+
+- **[Discord Community](https://discord.gg/gk8jAdXWmj)** - Get help from the community
+- **[GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)** - Report bugs or request features
+- **[YouTube Channel](https://www.youtube.com/@BMadCode)** - Video tutorials
+
+### Related Documentation
+
+- **[BMM Documentation](../../bmm/docs/README.md)** - Core BMad Method documentation
+- **[IDE Setup Guides](../../../../docs/ide-info/)** - Configure your development environment
+
+---
+
+## Tips for Using This Documentation
+
+1. **Start with Quick Start** if you're new to BMGD
+2. **Check Game Types Guide** when creating your GDD
+3. **Reference Glossary** for game development terminology
+4. **Use Troubleshooting** when you encounter issues
+
+---
+
+**Ready to make games?** → [Start with the Quick Start Guide](./quick-start.md)

src/modules/bmgd/docs/agents-guide.md

@@ -0,0 +1,407 @@
+# BMGD Agents Guide
+
+Complete reference for BMGD's six specialized game development agents.
+
+---
+
+## Agent Overview
+
+BMGD provides six agents, each with distinct expertise:
+
+| Agent                    | Name             | Role                                                        | Phase Focus |
+| ------------------------ | ---------------- | ----------------------------------------------------------- | ----------- |
+| 🎲 **Game Designer**     | Samus Shepard    | Lead Game Designer + Creative Vision Architect              | Phases 1-2  |
+| 🏛️ **Game Architect**    | Cloud Dragonborn | Principal Game Systems Architect + Technical Director       | Phase 3     |
+| 🕹️ **Game Developer**    | Link Freeman     | Senior Game Developer + Technical Implementation Specialist | Phase 4     |
+| 🎯 **Game Scrum Master** | Max              | Game Development Scrum Master + Sprint Orchestrator         | Phase 4     |
+| 🧪 **Game QA**           | GLaDOS           | Game QA Architect + Test Automation Specialist              | All Phases  |
+| 🎮 **Game Solo Dev**     | Indie            | Elite Indie Game Developer + Quick Flow Specialist          | All Phases  |
+
+---
+
+## 🎲 Game Designer (Samus Shepard)
+
+### Role
+
+Lead Game Designer + Creative Vision Architect
+
+### Identity
+
+Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking.
+
+### Communication Style
+
+Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs with "Let's GOOO!"
+
+### Core Principles
+
+- Design what players want to FEEL, not what they say they want
+- Prototype fast - one hour of playtesting beats ten hours of discussion
+- Every mechanic must serve the core fantasy
+
+### When to Use
+
+- Brainstorming game ideas
+- Creating Game Briefs
+- Designing GDDs
+- Developing narrative design
+
+### Available Commands
+
+| Command                | Description                      |
+| ---------------------- | -------------------------------- |
+| `workflow-status`      | Check project status             |
+| `brainstorm-game`      | Guided game ideation             |
+| `create-game-brief`    | Create Game Brief                |
+| `create-gdd`           | Create Game Design Document      |
+| `narrative`            | Create Narrative Design Document |
+| `quick-prototype`      | Rapid prototyping (IDE only)     |
+| `party-mode`           | Multi-agent collaboration        |
+| `advanced-elicitation` | Deep exploration (web only)      |
+
+---
+
+## 🏛️ Game Architect (Cloud Dragonborn)
+
+### Role
+
+Principal Game Systems Architect + Technical Director
+
+### Identity
+
+Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms.
+
+### Communication Style
+
+Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors about building foundations and load-bearing walls.
+
+### Core Principles
+
+- Architecture is about delaying decisions until you have enough data
+- Build for tomorrow without over-engineering today
+- Hours of planning save weeks of refactoring hell
+- Every system must handle the hot path at 60fps
+
+### When to Use
+
+- Planning technical architecture
+- Making engine/framework decisions
+- Designing game systems
+- Course correction during development
+
+### Available Commands
+
+| Command                | Description                           |
+| ---------------------- | ------------------------------------- |
+| `workflow-status`      | Check project status                  |
+| `create-architecture`  | Create Game Architecture              |
+| `correct-course`       | Course correction analysis (IDE only) |
+| `party-mode`           | Multi-agent collaboration             |
+| `advanced-elicitation` | Deep exploration (web only)           |
+
+---
+
+## 🕹️ Game Developer (Link Freeman)
+
+### Role
+
+Senior Game Developer + Technical Implementation Specialist
+
+### Identity
+
+Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code.
+
+### Communication Style
+
+Speaks like a speedrunner - direct, milestone-focused, always optimizing for the fastest path to ship.
+
+### Core Principles
+
+- 60fps is non-negotiable
+- Write code designers can iterate without fear
+- Ship early, ship often, iterate on player feedback
+- Red-green-refactor: tests first, implementation second
+
+### When to Use
+
+- Implementing stories
+- Code reviews
+- Performance optimization
+- Completing story work
+
+### Available Commands
+
+| Command                | Description                     |
+| ---------------------- | ------------------------------- |
+| `workflow-status`      | Check sprint progress           |
+| `dev-story`            | Implement story tasks           |
+| `code-review`          | Perform code review             |
+| `quick-dev`            | Flexible development (IDE only) |
+| `quick-prototype`      | Rapid prototyping (IDE only)    |
+| `party-mode`           | Multi-agent collaboration       |
+| `advanced-elicitation` | Deep exploration (web only)     |
+
+---
+
+## 🎯 Game Scrum Master (Max)
+
+### Role
+
+Game Development Scrum Master + Sprint Orchestrator
+
+### Identity
+
+Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories.
+
+### Communication Style
+
+Talks in game terminology - milestones are save points, handoffs are level transitions, blockers are boss fights.
+
+### Core Principles
+
+- Every sprint delivers playable increments
+- Clean separation between design and implementation
+- Keep the team moving through each phase
+- Stories are single source of truth for implementation
+
+### When to Use
+
+- Sprint planning and management
+- Creating epic tech specs
+- Writing story drafts
+- Assembling story context
+- Running retrospectives
+- Handling course corrections
+
+### Available Commands
+
+| Command                 | Description                                 |
+| ----------------------- | ------------------------------------------- |
+| `workflow-status`       | Check project status                        |
+| `sprint-planning`       | Generate/update sprint status               |
+| `sprint-status`         | View sprint progress, get next action       |
+| `create-story`          | Create story (marks ready-for-dev directly) |
+| `validate-create-story` | Validate story draft                        |
+| `epic-retrospective`    | Facilitate retrospective                    |
+| `correct-course`        | Navigate significant changes                |
+| `party-mode`            | Multi-agent collaboration                   |
+| `advanced-elicitation`  | Deep exploration (web only)                 |
+
+---
+
+## 🧪 Game QA (GLaDOS)
+
+### Role
+
+Game QA Architect + Test Automation Specialist
+
+### Identity
+
+Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games on console, PC, and mobile.
+
+### Communication Style
+
+Speaks like a quality guardian - methodical, data-driven, but understands that "feel" matters in games. Uses metrics to back intuition. "Trust, but verify with tests."
+
+### Core Principles
+
+- Test what matters: gameplay feel, performance, progression
+- Automated tests catch regressions, humans catch fun problems
+- Every shipped bug is a process failure, not a people failure
+- Flaky tests are worse than no tests - they erode trust
+- Profile before optimize, test before ship
+
+### When to Use
+
+- Setting up test frameworks
+- Designing test strategies
+- Creating automated tests
+- Planning playtesting sessions
+- Performance testing
+- Reviewing test coverage
+
+### Available Commands
+
+| Command                | Description                                         |
+| ---------------------- | --------------------------------------------------- |
+| `workflow-status`      | Check project status                                |
+| `test-framework`       | Initialize game test framework (Unity/Unreal/Godot) |
+| `test-design`          | Create comprehensive game test scenarios            |
+| `automate`             | Generate automated game tests                       |
+| `playtest-plan`        | Create structured playtesting plan                  |
+| `performance-test`     | Design performance testing strategy                 |
+| `test-review`          | Review test quality and coverage                    |
+| `party-mode`           | Multi-agent collaboration                           |
+| `advanced-elicitation` | Deep exploration (web only)                         |
+
+### Knowledge Base
+
+GLaDOS has access to a comprehensive game testing knowledge base (`gametest/qa-index.csv`) including:
+
+**Engine-Specific Testing:**
+
+- Unity Test Framework (Edit Mode, Play Mode)
+- Unreal Automation and Gauntlet
+- Godot GUT (Godot Unit Test)
+
+**Game-Specific Testing:**
+
+- Playtesting fundamentals
+- Balance testing
+- Save system testing
+- Multiplayer/network testing
+- Input testing
+- Platform certification (TRC/XR)
+- Localization testing
+
+**General QA:**
+
+- QA automation strategies
+- Performance testing
+- Regression testing
+- Smoke testing
+- Test prioritization (P0-P3)
+
+---
+
+## 🎮 Game Solo Dev (Indie)
+
+### Role
+
+Elite Indie Game Developer + Quick Flow Specialist
+
+### Identity
+
+Battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot, having shipped titles across mobile, PC, and console. Lives and breathes the Quick Flow workflow - prototyping fast, iterating faster, and shipping before the hype dies.
+
+### Communication Style
+
+Direct, confident, and gameplay-focused. Uses dev slang, thinks in game feel and player experience. Every response moves the game closer to ship. "Does it feel good? Ship it."
+
+### Core Principles
+
+- Prototype fast, fail fast, iterate faster
+- A playable build beats a perfect design doc
+- 60fps is non-negotiable - performance is a feature
+- The core loop must be fun before anything else matters
+- Ship early, playtest often
+
+### When to Use
+
+- Solo game development
+- Rapid prototyping
+- Quick iteration without full team workflow
+- Indie projects with tight timelines
+- When you want to handle everything yourself
+
+### Available Commands
+
+| Command            | Description                                            |
+| ------------------ | ------------------------------------------------------ |
+| `quick-prototype`  | Rapid prototype to test if a mechanic is fun           |
+| `quick-dev`        | Implement features end-to-end with game considerations |
+| `create-tech-spec` | Create implementation-ready technical spec             |
+| `code-review`      | Review code quality                                    |
+| `test-framework`   | Set up automated testing                               |
+| `party-mode`       | Bring in specialists when needed                       |
+
+### Quick Flow vs Full BMGD
+
+Use **Game Solo Dev** when:
+
+- You're working alone or in a tiny team
+- Speed matters more than process
+- You want to skip the full planning phases
+- You're prototyping or doing game jams
+
+Use **Full BMGD workflow** when:
+
+- You have a larger team
+- The project needs formal documentation
+- You're working with stakeholders/publishers
+- Long-term maintainability is critical
+
+---
+
+## Agent Selection Guide
+
+### By Phase
+
+| Phase                          | Primary Agent     | Secondary Agent   |
+| ------------------------------ | ----------------- | ----------------- |
+| 1: Preproduction               | Game Designer     | -                 |
+| 2: Design                      | Game Designer     | -                 |
+| 3: Technical                   | Game Architect    | Game QA           |
+| 4: Production (Planning)       | Game Scrum Master | Game Architect    |
+| 4: Production (Implementation) | Game Developer    | Game Scrum Master |
+| Testing (Any Phase)            | Game QA           | Game Developer    |
+
+### By Task
+
+| Task                             | Best Agent        |
+| -------------------------------- | ----------------- |
+| "I have a game idea"             | Game Designer     |
+| "Help me design my game"         | Game Designer     |
+| "How should I build this?"       | Game Architect    |
+| "What's the technical approach?" | Game Architect    |
+| "Plan our sprints"               | Game Scrum Master |
+| "Create implementation stories"  | Game Scrum Master |
+| "Build this feature"             | Game Developer    |
+| "Review this code"               | Game Developer    |
+| "Set up testing framework"       | Game QA           |
+| "Create test plan"               | Game QA           |
+| "Test performance"               | Game QA           |
+| "Plan a playtest"                | Game QA           |
+| "I'm working solo"               | Game Solo Dev     |
+| "Quick prototype this idea"      | Game Solo Dev     |
+| "Ship this feature fast"         | Game Solo Dev     |
+
+---
+
+## Multi-Agent Collaboration
+
+### Party Mode
+
+All agents have access to `party-mode`, which brings multiple agents together for complex decisions. Use this when:
+
+- A decision spans multiple domains (design + technical)
+- You want diverse perspectives
+- You're stuck and need fresh ideas
+
+### Handoffs
+
+Agents naturally hand off to each other:
+
+```
+Game Designer → Game Architect → Game Scrum Master → Game Developer
+    ↓                ↓                  ↓                  ↓
+  GDD          Architecture      Sprint/Stories      Implementation
+                     ↓                                     ↓
+                 Game QA ←──────────────────────────── Game QA
+                     ↓                                     ↓
+              Test Strategy                         Automated Tests
+```
+
+Game QA integrates at multiple points:
+
+- After Architecture: Define test strategy
+- During Implementation: Create automated tests
+- Before Release: Performance and certification testing
+
+---
+
+## Project Context
+
+All agents share the principle:
+
+> "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
+
+The `project-context.md` file (if present) serves as the authoritative source for project decisions and constraints.
+
+---
+
+## Next Steps
+
+- **[Quick Start Guide](./quick-start.md)** - Get started with BMGD
+- **[Workflows Guide](./workflows-guide.md)** - Detailed workflow reference
+- **[Game Types Guide](./game-types-guide.md)** - Game type templates

src/modules/bmgd/docs/game-types-guide.md

@@ -0,0 +1,503 @@
+# BMGD Game Types Guide
+
+Reference for selecting and using BMGD's 24 supported game type templates.
+
+---
+
+## Overview
+
+When creating a GDD, BMGD offers game type templates that provide genre-specific sections. This ensures your design document covers mechanics and systems relevant to your game's genre.
+
+---
+
+## Supported Game Types
+
+### Action & Combat
+
+#### Action Platformer
+
+**Tags:** action, platformer, combat, movement
+
+Side-scrolling or 3D platforming with combat mechanics. Think Hollow Knight, Celeste with combat, or Mega Man.
+
+**GDD sections added:**
+
+- Movement systems (jumps, dashes, wall mechanics)
+- Combat mechanics (melee/ranged, combos)
+- Level design patterns
+- Boss design
+
+---
+
+#### Shooter
+
+**Tags:** shooter, combat, aiming, fps, tps
+
+Projectile combat with aiming mechanics. Covers FPS, TPS, and arena shooters.
+
+**GDD sections added:**
+
+- Weapon systems
+- Aiming and accuracy
+- Enemy AI patterns
+- Level/arena design
+- Multiplayer considerations
+
+---
+
+#### Fighting
+
+**Tags:** fighting, combat, competitive, combos, pvp
+
+1v1 combat with combos and frame data. Traditional fighters and platform fighters.
+
+**GDD sections added:**
+
+- Frame data systems
+- Combo mechanics
+- Character movesets
+- Competitive balance
+- Netcode requirements
+
+---
+
+### Strategy & Tactics
+
+#### Strategy
+
+**Tags:** strategy, tactics, resources, planning
+
+Resource management with tactical decisions. RTS, 4X, and grand strategy.
+
+**GDD sections added:**
+
+- Resource systems
+- Unit/building design
+- AI opponent behavior
+- Map/scenario design
+- Victory conditions
+
+---
+
+#### Turn-Based Tactics
+
+**Tags:** tactics, turn-based, grid, positioning
+
+Grid-based movement with turn order. XCOM-likes and tactical RPGs.
+
+**GDD sections added:**
+
+- Grid and movement systems
+- Turn order mechanics
+- Cover and positioning
+- Unit progression
+- Procedural mission generation
+
+---
+
+#### Tower Defense
+
+**Tags:** tower-defense, waves, placement, strategy
+
+Wave-based defense with tower placement.
+
+**GDD sections added:**
+
+- Tower types and upgrades
+- Wave design and pacing
+- Economy systems
+- Map design patterns
+- Meta-progression
+
+---
+
+### RPG & Progression
+
+#### RPG
+
+**Tags:** rpg, stats, inventory, quests, narrative
+
+Character progression with stats, inventory, and quests.
+
+**GDD sections added:**
+
+- Character stats and leveling
+- Inventory and equipment
+- Quest system design
+- Combat system (action/turn-based)
+- Skill trees and builds
+
+---
+
+#### Roguelike
+
+**Tags:** roguelike, procedural, permadeath, runs
+
+Procedural generation with permadeath and run-based progression.
+
+**GDD sections added:**
+
+- Procedural generation rules
+- Permadeath and persistence
+- Run structure and pacing
+- Item/ability synergies
+- Meta-progression systems
+
+---
+
+#### Metroidvania
+
+**Tags:** metroidvania, exploration, abilities, interconnected
+
+Interconnected world with ability gating.
+
+**GDD sections added:**
+
+- World map connectivity
+- Ability gating design
+- Backtracking flow
+- Secret and collectible placement
+- Power-up progression
+
+---
+
+### Narrative & Story
+
+#### Adventure
+
+**Tags:** adventure, narrative, exploration, story
+
+Story-driven exploration and narrative. Point-and-click and narrative adventures.
+
+**GDD sections added:**
+
+- Puzzle design
+- Narrative delivery
+- Exploration mechanics
+- Dialogue systems
+- Story branching
+
+---
+
+#### Visual Novel
+
+**Tags:** visual-novel, narrative, choices, story
+
+Narrative choices with branching story.
+
+**GDD sections added:**
+
+- Branching narrative structure
+- Choice and consequence
+- Character routes
+- UI/presentation
+- Save/load states
+
+---
+
+#### Text-Based
+
+**Tags:** text, parser, interactive-fiction, mud
+
+Text input/output games. Parser games, choice-based IF, MUDs.
+
+**GDD sections added:**
+
+- Parser or choice systems
+- World model
+- Narrative structure
+- Text presentation
+- Save state management
+
+---
+
+### Simulation & Management
+
+#### Simulation
+
+**Tags:** simulation, management, sandbox, systems
+
+Realistic systems with management and building. Includes tycoons and sim games.
+
+**GDD sections added:**
+
+- Core simulation loops
+- Economy modeling
+- AI agents/citizens
+- Building/construction
+- Failure states
+
+---
+
+#### Sandbox
+
+**Tags:** sandbox, creative, building, freedom
+
+Creative freedom with building and minimal objectives.
+
+**GDD sections added:**
+
+- Creation tools
+- Physics/interaction systems
+- Persistence and saving
+- Sharing/community features
+- Optional objectives
+
+---
+
+### Sports & Racing
+
+#### Racing
+
+**Tags:** racing, vehicles, tracks, speed
+
+Vehicle control with tracks and lap times.
+
+**GDD sections added:**
+
+- Vehicle physics model
+- Track design
+- AI opponents
+- Progression/career mode
+- Multiplayer racing
+
+---
+
+#### Sports
+
+**Tags:** sports, teams, realistic, physics
+
+Team-based or individual sports simulation.
+
+**GDD sections added:**
+
+- Sport-specific rules
+- Player/team management
+- AI opponent behavior
+- Season/career modes
+- Multiplayer modes
+
+---
+
+### Multiplayer
+
+#### MOBA
+
+**Tags:** moba, multiplayer, pvp, heroes, lanes
+
+Multiplayer team battles with hero selection.
+
+**GDD sections added:**
+
+- Hero/champion design
+- Lane and map design
+- Team composition
+- Matchmaking
+- Economy (gold/items)
+
+---
+
+#### Party Game
+
+**Tags:** party, multiplayer, minigames, casual
+
+Local multiplayer with minigames.
+
+**GDD sections added:**
+
+- Minigame design patterns
+- Controller support
+- Round/game structure
+- Scoring systems
+- Player count flexibility
+
+---
+
+### Horror & Survival
+
+#### Survival
+
+**Tags:** survival, crafting, resources, danger
+
+Resource gathering with crafting and persistent threats.
+
+**GDD sections added:**
+
+- Resource gathering
+- Crafting systems
+- Hunger/health/needs
+- Threat systems
+- Base building
+
+---
+
+#### Horror
+
+**Tags:** horror, atmosphere, tension, fear
+
+Atmosphere and tension with limited resources.
+
+**GDD sections added:**
+
+- Fear mechanics
+- Resource scarcity
+- Sound design
+- Lighting and visibility
+- Enemy/threat design
+
+---
+
+### Casual & Progression
+
+#### Puzzle
+
+**Tags:** puzzle, logic, cerebral
+
+Logic-based challenges and problem-solving.
+
+**GDD sections added:**
+
+- Puzzle mechanics
+- Difficulty progression
+- Hint systems
+- Level structure
+- Scoring/rating
+
+---
+
+#### Idle/Incremental
+
+**Tags:** idle, incremental, automation, progression
+
+Passive progression with upgrades and automation.
+
+**GDD sections added:**
+
+- Core loop design
+- Prestige systems
+- Automation unlocks
+- Number scaling
+- Offline progress
+
+---
+
+#### Card Game
+
+**Tags:** card, deck-building, strategy, turns
+
+Deck building with card mechanics.
+
+**GDD sections added:**
+
+- Card design framework
+- Deck building rules
+- Mana/resource systems
+- Rarity and collection
+- Competitive balance
+
+---
+
+### Rhythm
+
+#### Rhythm
+
+**Tags:** rhythm, music, timing, beats
+
+Music synchronization with timing-based gameplay.
+
+**GDD sections added:**
+
+- Note/beat mapping
+- Scoring systems
+- Difficulty levels
+- Music licensing
+- Input methods
+
+---
+
+## Hybrid Game Types
+
+Many games combine multiple genres. BMGD supports hybrid selection:
+
+### Examples
+
+**Action RPG** = Action Platformer + RPG
+
+- Movement and combat systems from Action Platformer
+- Progression and stats from RPG
+
+**Survival Horror** = Survival + Horror
+
+- Resource and crafting from Survival
+- Atmosphere and fear from Horror
+
+**Roguelike Deckbuilder** = Roguelike + Card Game
+
+- Run structure from Roguelike
+- Card mechanics from Card Game
+
+### How to Use Hybrids
+
+During GDD creation, select multiple game types when prompted:
+
+```
+Agent: What game type best describes your game?
+You: It's a roguelike with card game combat
+Agent: I'll include sections for both Roguelike and Card Game...
+```
+
+---
+
+## Game Type Selection Tips
+
+### 1. Start with Core Fantasy
+
+What does the player primarily DO in your game?
+
+- Run and jump? → Platformer types
+- Build and manage? → Simulation types
+- Fight enemies? → Combat types
+- Make choices? → Narrative types
+
+### 2. Consider Your Loop
+
+What's the core gameplay loop?
+
+- Session-based runs? → Roguelike
+- Long-term progression? → RPG
+- Quick matches? → Multiplayer types
+- Creative expression? → Sandbox
+
+### 3. Don't Over-Combine
+
+2-3 game types maximum. More than that usually means your design isn't focused enough.
+
+### 4. Primary vs Secondary
+
+One type should be primary (most gameplay time). Others add flavor:
+
+- **Primary:** Platformer (core movement and exploration)
+- **Secondary:** Metroidvania (ability gating structure)
+
+---
+
+## GDD Section Mapping
+
+When you select a game type, BMGD adds these GDD sections:
+
+| Game Type         | Key Sections Added                     |
+| ----------------- | -------------------------------------- |
+| Action Platformer | Movement, Combat, Level Design         |
+| RPG               | Stats, Inventory, Quests               |
+| Roguelike         | Procedural Gen, Runs, Meta-Progression |
+| Narrative         | Story Structure, Dialogue, Branching   |
+| Multiplayer       | Matchmaking, Netcode, Balance          |
+| Simulation        | Systems, Economy, AI                   |
+
+---
+
+## Next Steps
+
+- **[Quick Start Guide](./quick-start.md)** - Get started with BMGD
+- **[Workflows Guide](./workflows-guide.md)** - GDD workflow details
+- **[Glossary](./glossary.md)** - Game development terminology

src/modules/bmgd/docs/glossary.md

@@ -0,0 +1,294 @@
+# BMGD Glossary
+
+Key game development terminology used in BMGD workflows.
+
+---
+
+## A
+
+### Acceptance Criteria
+
+Specific conditions that must be met for a story to be considered complete. Defines "done" for implementation.
+
+### Act Structure
+
+Story organization into major sections (typically 3 acts: Setup, Confrontation, Resolution).
+
+---
+
+## B
+
+### Backlog
+
+List of pending work items (epics, stories) waiting to be scheduled and implemented.
+
+### Boss Design
+
+Design of significant enemy encounters, typically featuring unique mechanics and increased challenge.
+
+---
+
+## C
+
+### Character Arc
+
+The transformation a character undergoes through the story, from initial state to final state.
+
+### Core Fantasy
+
+The emotional experience players seek from your game. What they want to FEEL.
+
+### Core Loop
+
+The fundamental cycle of actions players repeat throughout gameplay. The heart of your game.
+
+---
+
+## D
+
+### Definition of Done (DoD)
+
+Checklist of requirements that must be satisfied before work is considered complete.
+
+### Design Pillar
+
+Core principle that guides all design decisions. Typically 3-5 pillars define a game's identity.
+
+---
+
+## E
+
+### Environmental Storytelling
+
+Narrative communicated through the game world itself—visual details, audio, found documents—rather than explicit dialogue.
+
+### Epic
+
+Large body of work that can be broken down into smaller stories. Represents a major feature or system.
+
+---
+
+## F
+
+### Frame Data
+
+In fighting games, the precise timing information for moves (startup, active, recovery frames).
+
+### Frontmatter
+
+YAML metadata at the beginning of markdown files, used for workflow state tracking.
+
+---
+
+## G
+
+### Game Brief
+
+Document capturing the game's core vision, pillars, target audience, and scope. Foundation for the GDD.
+
+### Game Design Document (GDD)
+
+Comprehensive document detailing all aspects of game design: mechanics, systems, content, and more.
+
+### Game Type
+
+Genre classification that determines which specialized GDD sections are included.
+
+---
+
+## H
+
+### Hot Path
+
+Code that executes frequently (every frame). Must be optimized for performance.
+
+---
+
+## I
+
+### Idle Progression
+
+Game mechanics where progress continues even when the player isn't actively playing.
+
+---
+
+## K
+
+### Kishotenketsu
+
+Four-act story structure from East Asian narrative tradition (Introduction, Development, Twist, Conclusion).
+
+---
+
+## L
+
+### Localization
+
+Adapting game content for different languages and cultures.
+
+---
+
+## M
+
+### MDA Framework
+
+Mechanics → Dynamics → Aesthetics. Framework for analyzing and designing games.
+
+### Meta-Progression
+
+Persistent progression that carries between individual runs or sessions.
+
+### Metroidvania
+
+Genre featuring interconnected world exploration with ability-gated progression.
+
+---
+
+## N
+
+### Narrative Complexity
+
+How central story is to the game experience (Critical, Heavy, Moderate, Light).
+
+### Netcode
+
+Networking code handling multiplayer communication and synchronization.
+
+---
+
+## P
+
+### Permadeath
+
+Game mechanic where character death is permanent, typically requiring a new run.
+
+### Player Agency
+
+The degree to which players can make meaningful choices that affect outcomes.
+
+### Procedural Generation
+
+Algorithmic creation of game content (levels, items, characters) rather than hand-crafted.
+
+---
+
+## R
+
+### Retrospective
+
+Team meeting after completing work to reflect on what went well and what to improve.
+
+### Roguelike
+
+Genre featuring procedural generation, permadeath, and run-based progression.
+
+### Run
+
+A single playthrough in a roguelike or run-based game, from start to death/completion.
+
+---
+
+## S
+
+### Sprint
+
+Time-boxed period of development work, typically 1-2 weeks.
+
+### Sprint Status
+
+Tracking document showing current sprint progress, story states, and blockers.
+
+### Story
+
+Smallest unit of implementable work with clear acceptance criteria. Part of an epic.
+
+### Story Context
+
+Assembled documentation and code context needed to implement a specific story.
+
+### Story Gates
+
+Points where story progression is blocked until certain gameplay conditions are met.
+
+---
+
+## T
+
+### Tech Spec
+
+Technical specification document detailing how a feature will be implemented.
+
+### TDD (Test-Driven Development)
+
+Development approach: write tests first, then implement code to pass them.
+
+---
+
+## U
+
+### UI/UX
+
+User Interface / User Experience. How players interact with and experience the game.
+
+---
+
+## V
+
+### Visual Novel
+
+Genre focused on narrative with static images, dialogue, and player choices.
+
+### Voice Acting
+
+Recorded spoken dialogue for game characters.
+
+---
+
+## W
+
+### Workflow
+
+Structured process for completing a specific type of work (e.g., GDD creation, story implementation).
+
+### Workflow Status
+
+Current state of project workflows, tracking which phases and documents are complete.
+
+### World Building
+
+Creation of the game's setting, including history, culture, geography, and lore.
+
+---
+
+## BMGD-Specific Terms
+
+### A/P/C Menu
+
+Options presented after content generation:
+
+- **A** - Advanced Elicitation (explore deeper)
+- **P** - Party Mode (multi-agent discussion)
+- **C** - Continue (save and proceed)
+
+### Narrative Complexity Levels
+
+- **Critical** - Story IS the game (visual novels)
+- **Heavy** - Deep narrative with gameplay (RPGs)
+- **Moderate** - Meaningful story supporting gameplay
+- **Light** - Minimal story, gameplay-focused
+
+### Step-File Architecture
+
+BMGD workflow pattern using separate markdown files for each workflow step.
+
+### Workflow-Install Pattern
+
+Phase 4 workflows inherit from BMM base and add BMGD-specific overrides.
+
+---
+
+## Next Steps
+
+- **[Quick Start Guide](./quick-start.md)** - Get started with BMGD
+- **[Game Types Guide](./game-types-guide.md)** - Game genre reference
+- **[Troubleshooting](./troubleshooting.md)** - Common issues and solutions

src/modules/bmgd/docs/quick-flow-guide.md

@@ -0,0 +1,288 @@
+# BMGD Quick-Flow Guide
+
+Fast-track workflows for rapid game prototyping and flexible development.
+
+---
+
+## Game Solo Dev Agent
+
+For dedicated quick-flow development, use the **Game Solo Dev** agent (Indie). This agent is optimized for solo developers and small teams who want to skip the full planning phases and ship fast.
+
+**Switch to Game Solo Dev:** Type `@game-solo-dev` or select the agent from your IDE.
+
+The Game Solo Dev agent includes:
+
+- `quick-prototype` - Rapid mechanic testing
+- `quick-dev` - Flexible feature implementation
+- `create-tech-spec` - Create implementation-ready specs
+- `code-review` - Quality checks
+- `test-framework` - Automated testing setup
+
+---
+
+## Overview
+
+Quick-flow workflows skip the full BMGD planning phases when you need to move fast. Use them for:
+
+- Testing a game mechanic idea
+- Implementing a small feature
+- Rapid prototyping before committing to design
+- Bug fixes and tweaks
+
+```
+Full BMGD Flow:
+Brief → GDD → Architecture → Sprint Planning → Stories → Implementation
+
+Quick-Flow:
+Idea → Quick-Prototype → Quick-Dev → Done
+```
+
+---
+
+## Quick-Prototype
+
+**Command:** `quick-prototype`
+**Agent:** Game Designer, Game Developer
+**Purpose:** Rapidly test gameplay ideas with minimal setup
+
+### When to Use
+
+- You have a mechanic idea and want to test the "feel"
+- You're not sure if something will be fun
+- You want to experiment before committing to design
+- You need a proof of concept
+
+### Workflow Steps
+
+1. **Define Scope** - What are you prototyping? (mechanic, feature, system)
+2. **Set Success Criteria** - How will you know if it works?
+3. **Rapid Implementation** - Build the minimum to test the idea
+4. **Playtest and Evaluate** - Does it feel right?
+
+### Prototype Principles
+
+- **Minimum Viable Prototype** - Only what's needed to test the idea
+- **Hardcode First** - Magic numbers are fine, extract later
+- **Skip Edge Cases** - Happy path only for now
+- **Placeholder Everything** - Cubes, debug text, temp sounds
+- **Comment Intent** - Mark what's temporary vs keeper code
+
+### Example Session
+
+```
+You: quick-prototype
+
+Agent: What are you prototyping?
+
+You: I want to test a grappling hook mechanic. Player should be
+     able to aim at surfaces and pull themselves toward the hook point.
+
+Agent: What makes this prototype successful?
+
+You: 1. Aiming feels responsive and intuitive
+     2. The pull movement feels satisfying, not floaty
+     3. Player can chain hooks without awkward pauses
+
+Agent: [Implements minimal grappling hook]
+
+Agent: Prototype complete! Playtest results:
+     - Aiming: Works, consider adding aim assist
+     - Movement: Pull is smooth, might need speed curve
+     - Chaining: Currently has 0.2s delay, feels sluggish
+
+     Next: [d] Develop further | [i] Iterate | [a] Archive
+```
+
+### After Prototyping
+
+- **Develop** (`d`) - Use `quick-dev` to build production code
+- **Iterate** (`i`) - Adjust and re-test the prototype
+- **Archive** (`a`) - Keep as reference, move on to other ideas
+
+---
+
+## Quick-Dev
+
+**Command:** `quick-dev`
+**Agent:** Game Developer
+**Purpose:** Flexible development with game-specific considerations
+
+### When to Use
+
+- Implementing a feature from a tech-spec
+- Building on a successful prototype
+- Making changes that don't need full story workflow
+- Quick fixes and improvements
+
+### Workflow Modes
+
+**Mode A: Tech-Spec Driven**
+
+```
+You: quick-dev tech-spec-combat.md
+Agent: [Loads spec, extracts tasks, implements]
+```
+
+**Mode B: Direct Instructions**
+
+```
+You: quick-dev implement double-jump for the player
+Agent: [Evaluates complexity, offers planning options]
+```
+
+**Mode C: From Prototype**
+
+```
+You: quick-dev from the grappling hook prototype
+Agent: [Loads prototype, productionizes code]
+```
+
+### Game-Specific Checks
+
+Quick-dev includes automatic consideration of:
+
+- **Performance** - No allocations in hot paths, object pooling
+- **Feel** - Input responsiveness, visual/audio feedback
+- **Integration** - Save/load, multiplayer sync, platform testing
+
+### Example Session
+
+```
+You: quick-dev implement enemy patrol behavior
+
+Agent: This looks like a focused feature. Options:
+       [t] Plan first - Create tech-spec (recommended)
+       [r] Prototype first - Test the idea
+       [e] Execute directly
+
+You: e
+
+Agent: Any additional guidance? (patterns, files, constraints)
+
+You: Use the existing AIController base class. Enemies should
+     patrol between waypoints and return if player leaves range.
+
+Agent: [Implements patrol behavior]
+
+Agent: Implementation Complete!
+       Files Modified: EnemyAI.cs, PatrolBehavior.cs
+       Tests: Unit tests added for patrol state machine
+       Performance: No per-frame allocations
+
+       Recommended: Playtest the changes
+```
+
+### Complexity Routing
+
+Quick-dev automatically detects complex requests and offers alternatives:
+
+| Signals                                | Recommendation         |
+| -------------------------------------- | ---------------------- |
+| Single mechanic, bug fix, tweak        | Execute directly       |
+| Multiple systems, performance-critical | Plan first (tech-spec) |
+| Platform/system level work             | Use full BMGD workflow |
+
+---
+
+## Choosing Between Quick-Flows
+
+| Scenario                | Use                             |
+| ----------------------- | ------------------------------- |
+| "Will this be fun?"     | `quick-prototype`               |
+| "How should this feel?" | `quick-prototype`               |
+| "Build this feature"    | `quick-dev`                     |
+| "Fix this bug"          | `quick-dev`                     |
+| "Test then build"       | `quick-prototype` → `quick-dev` |
+
+---
+
+## Quick-Flow vs Full BMGD
+
+### Use Quick-Flow When
+
+- The scope is small and well-understood
+- You're experimenting or prototyping
+- You have a clear tech-spec already
+- The work doesn't affect core game systems significantly
+
+### Use Full BMGD When
+
+- Building a major feature or system
+- The scope is unclear or large
+- Multiple team members need alignment
+- The work affects game pillars or core loop
+- You need documentation for future reference
+
+---
+
+## Checklists
+
+### Quick-Prototype Checklist
+
+**Before:**
+
+- [ ] Prototype scope defined
+- [ ] Success criteria established (2-3 items)
+
+**During:**
+
+- [ ] Minimum viable code written
+- [ ] Placeholder assets used
+- [ ] Core functionality testable
+
+**After:**
+
+- [ ] Each criterion evaluated
+- [ ] Decision made (develop/iterate/archive)
+
+### Quick-Dev Checklist
+
+**Before:**
+
+- [ ] Context loaded (spec, prototype, or guidance)
+- [ ] Files to modify identified
+- [ ] Patterns understood
+
+**During:**
+
+- [ ] All tasks completed
+- [ ] No allocations in hot paths
+- [ ] Frame rate maintained
+
+**After:**
+
+- [ ] Game runs without errors
+- [ ] Feature works as specified
+- [ ] Manual playtest completed
+
+---
+
+## Tips for Success
+
+### 1. Timebox Prototypes
+
+Set a limit (e.g., 2 hours) for prototyping. If it's not working by then, step back and reconsider.
+
+### 2. Embrace Programmer Art
+
+Prototypes don't need to look good. Focus on feel, not visuals.
+
+### 3. Test on Target Hardware
+
+What feels right on your dev machine might not feel right on target platform.
+
+### 4. Document Learnings
+
+Even failed prototypes teach something. Note what you learned.
+
+### 5. Know When to Graduate
+
+If quick-dev keeps expanding scope, stop and create proper stories.
+
+---
+
+## Next Steps
+
+- **[Workflows Guide](./workflows-guide.md)** - Full workflow reference
+- **[Agents Guide](./agents-guide.md)** - Agent capabilities
+- **[Quick Start Guide](./quick-start.md)** - Getting started with BMGD

src/modules/bmgd/docs/quick-start.md

@@ -0,0 +1,250 @@
+# BMGD Quick Start Guide
+
+Get started building games with the BMad Game Development Module.
+
+---
+
+## Prerequisites
+
+Before starting with BMGD, ensure you have:
+
+1. **BMAD-METHOD installed** - Follow the main installation guide
+2. **A game idea** - Even a rough concept is enough to start
+3. **Your preferred AI tool** - Claude Code, Cursor, or web-based chat
+
+---
+
+## Installation
+
+BMGD is a custom module that extends BMM. Install it using the BMAD installer:
+
+```bash
+# During installation, select BMGD when prompted for custom modules
+npx bmad-cli install
+```
+
+Or add to an existing installation:
+
+```bash
+npx bmad-cli install --add-module bmgd
+```
+
+---
+
+## Understanding the Phases
+
+BMGD follows four game development phases:
+
+![BMGD Workflow Overview](./workflow-overview.jpg)
+
+### Phase 1: Preproduction
+
+**What happens:** Capture your game vision and core concept.
+
+**Workflows:**
+
+- `brainstorm-game` - Guided ideation with game-specific techniques
+- `create-game-brief` - Document vision, market, pillars, and fundamentals
+
+**Output:** Game Brief document
+
+### Phase 2: Design
+
+**What happens:** Detail your game's mechanics, systems, and (optionally) narrative.
+
+**Workflows:**
+
+- `create-gdd` - Create comprehensive Game Design Document
+- `narrative` - Create Narrative Design Document (for story-driven games)
+
+**Output:** GDD (and Narrative Design document if applicable)
+
+### Phase 3: Technical
+
+**What happens:** Plan how you'll build the game.
+
+**Workflows:**
+
+- `create-architecture` - Define engine, systems, patterns, and structure
+
+**Output:** Game Architecture document
+
+### Phase 4: Production
+
+**What happens:** Build your game in sprints.
+
+**Workflows:**
+
+- `sprint-planning` - Plan and track sprints
+- `sprint-status` - View progress and get recommendations
+- `create-story` - Create implementable stories
+- `dev-story` - Implement stories
+- `code-review` - Quality assurance
+- `retrospective` - Learn and improve after epics
+
+**Output:** Working game code
+
+---
+
+## Your First Game Project
+
+### Step 1: Start with Brainstorming (Optional)
+
+If you have a vague idea and want help developing it:
+
+```
+You: brainstorm-game
+Agent: [Guides you through game-specific ideation techniques]
+```
+
+### Step 2: Create Your Game Brief
+
+Capture your game's core vision:
+
+```
+You: create-game-brief
+Agent: [Walks you through game concept, pillars, market, and fundamentals]
+```
+
+**Output:** `{output_folder}/game-brief.md`
+
+### Step 3: Create Your GDD
+
+Detail your game's design:
+
+```
+You: create-gdd
+Agent: [Guides you through mechanics, systems, and game-type-specific sections]
+```
+
+**Output:** `{output_folder}/gdd.md` (or sharded into `{output_folder}/gdd/`)
+
+### Step 4: Add Narrative Design (If Story-Driven)
+
+For games with significant story:
+
+```
+You: narrative
+Agent: [Facilitates story, characters, world, and dialogue design]
+```
+
+**Output:** `{output_folder}/narrative-design.md`
+
+### Step 5: Create Architecture
+
+Plan your technical implementation:
+
+```
+You: create-architecture
+Agent: [Guides engine selection, system design, and technical decisions]
+```
+
+**Output:** `{output_folder}/game-architecture.md`
+
+### Step 6: Start Building
+
+Begin sprint-based development:
+
+```
+You: sprint-planning
+Agent: [Sets up sprint tracking and epic management]
+```
+
+---
+
+## Choosing Your Agent
+
+BMGD provides six specialized agents:
+
+| Agent                 | Icon | When to Use                               |
+| --------------------- | ---- | ----------------------------------------- |
+| **Game Designer**     | 🎲   | Brainstorming, Game Brief, GDD, Narrative |
+| **Game Architect**    | 🏛️   | Architecture, technical decisions         |
+| **Game Developer**    | 🕹️   | Implementation, code reviews              |
+| **Game Scrum Master** | 🎯   | Sprint planning, story management         |
+| **Game QA**           | 🧪   | Test framework, test design, automation   |
+| **Game Solo Dev**     | 🎮   | Quick prototyping, indie development      |
+
+### Typical Flow
+
+1. **Game Designer** (Phases 1-2): Brainstorm → Brief → GDD → Narrative
+2. **Game Architect** (Phase 3): Architecture
+3. **Game Scrum Master** (Phase 4): Sprint planning, story creation
+4. **Game Developer** (Phase 4): Implementation, code reviews
+
+---
+
+## Quick Command Reference
+
+### Phase 1: Preproduction
+
+- `brainstorm-game` - Ideation session
+- `create-game-brief` - Create Game Brief
+
+### Phase 2: Design
+
+- `create-gdd` - Create GDD
+- `narrative` - Create Narrative Design
+
+### Phase 3: Technical
+
+- `create-architecture` - Create Architecture
+
+### Phase 4: Production
+
+- `sprint-planning` - Plan sprints
+- `sprint-status` - View progress and recommendations
+- `create-story` - Create story
+- `dev-story` - Implement story
+- `code-review` - Review code
+- `retrospective` - Team retrospective
+- `correct-course` - Handle sprint changes
+
+### Quick-Flow (Fast-Track)
+
+- `quick-prototype` - Rapid prototyping (IDE only)
+- `quick-dev` - Flexible development (IDE only)
+
+### Utility
+
+- `workflow-status` - Check project status
+- `party-mode` - Multi-agent collaboration
+- `advanced-elicitation` - Deep exploration
+
+---
+
+## Tips for Success
+
+### 1. Start Small
+
+Begin with a simple game concept. You can always expand later.
+
+### 2. Use Game Type Templates
+
+When creating your GDD, BMGD offers 24 game type templates that provide genre-specific sections.
+
+### 3. Iterate
+
+Documents are living artifacts. Return to update them as your vision evolves.
+
+### 4. Trust the Process
+
+Each workflow builds on previous outputs. The Game Brief informs the GDD, which informs the Architecture, which informs implementation.
+
+### 5. Collaborate with Agents
+
+Use `party-mode` to get perspectives from multiple agents when facing complex decisions.
+
+---
+
+## Next Steps
+
+- **[Agents Guide](./agents-guide.md)** - Learn about each agent's capabilities
+- **[Workflows Guide](./workflows-guide.md)** - Detailed workflow reference
+- **[Quick-Flow Guide](./quick-flow-guide.md)** - Rapid prototyping and development
+- **[Game Types Guide](./game-types-guide.md)** - Understand game type templates
+- **[Glossary](./glossary.md)** - Game development terminology
+
+---
+
+**Ready to start?** Chat with the **Game Designer** agent and say `brainstorm-game` or `create-game-brief`!

src/modules/bmgd/docs/troubleshooting.md

@@ -0,0 +1,259 @@
+# BMGD Troubleshooting
+
+Common issues and solutions when using BMGD workflows.
+
+---
+
+## Installation Issues
+
+### BMGD module not appearing
+
+**Symptom:** BMGD agents and workflows are not available after installation.
+
+**Solutions:**
+
+1. Verify BMGD was selected during installation
+2. Check `_bmad/bmgd/` folder exists in your project
+3. Re-run installer with `--add-module bmgd`
+
+---
+
+### Config file missing
+
+**Symptom:** Workflows fail with "config not found" errors.
+
+**Solution:**
+Check for `_bmad/bmgd/config.yaml` in your project. If missing, create it:
+
+```yaml
+# BMGD Configuration
+output_folder: '{project-root}/docs/game-design'
+user_name: 'Your Name'
+communication_language: 'English'
+document_output_language: 'English'
+game_dev_experience: 'intermediate'
+```
+
+---
+
+## Workflow Issues
+
+### "GDD not found" in Narrative workflow
+
+**Symptom:** Narrative workflow can't find the GDD.
+
+**Solutions:**
+
+1. Ensure GDD exists in `{output_folder}`
+2. Check GDD filename contains "gdd" (e.g., `game-gdd.md`, `my-gdd.md`)
+3. If using sharded GDD, verify `{output_folder}/gdd/index.md` exists
+
+---
+
+### Workflow state not persisting
+
+**Symptom:** Returning to a workflow starts from the beginning.
+
+**Solutions:**
+
+1. Check the output document's frontmatter for `stepsCompleted` array
+2. Ensure document was saved before ending session
+3. Use "Continue existing" option when re-entering workflow
+
+---
+
+### Wrong game type sections in GDD
+
+**Symptom:** GDD includes irrelevant sections for your game type.
+
+**Solutions:**
+
+1. Review game type selection at Step 7 of GDD workflow
+2. You can select multiple types for hybrid games
+3. Irrelevant sections can be marked N/A or removed
+
+---
+
+## Agent Issues
+
+### Agent not recognizing commands
+
+**Symptom:** Typing a command like `create-gdd` doesn't trigger the workflow.
+
+**Solutions:**
+
+1. Ensure you're chatting with the correct agent (Game Designer for GDD)
+2. Check exact command spelling (case-sensitive)
+3. Try `workflow-status` to verify agent is loaded correctly
+
+---
+
+### Agent using wrong persona
+
+**Symptom:** Agent responses don't match expected personality.
+
+**Solutions:**
+
+1. Verify correct agent file is loaded
+2. Check `_bmad/bmgd/agents/` for agent definitions
+3. Start a fresh chat session with the correct agent
+
+---
+
+## Document Issues
+
+### Document too large for context
+
+**Symptom:** AI can't process the entire GDD or narrative document.
+
+**Solutions:**
+
+1. Use sharded document structure (index.md + section files)
+2. Request specific sections rather than full document
+3. GDD workflow supports automatic sharding for large documents
+
+---
+
+### Template placeholders not replaced
+
+**Symptom:** Output contains `{{placeholder}}` text.
+
+**Solutions:**
+
+1. Workflow may have been interrupted before completion
+2. Re-run the specific step that generates that section
+3. Manually edit the document to fill in missing values
+
+---
+
+### Frontmatter parsing errors
+
+**Symptom:** YAML errors when loading documents.
+
+**Solutions:**
+
+1. Validate YAML syntax (proper indentation, quotes around special characters)
+2. Check for tabs vs spaces (YAML requires spaces)
+3. Ensure frontmatter is bounded by `---` markers
+
+---
+
+## Phase 4 (Production) Issues
+
+### Sprint status not updating
+
+**Symptom:** Story status changes don't reflect in sprint-status.yaml.
+
+**Solutions:**
+
+1. Run `sprint-planning` to refresh status
+2. Check file permissions on sprint-status.yaml
+3. Verify workflow-install files exist in `_bmad/bmgd/workflows/4-production/`
+
+---
+
+### Story context missing code references
+
+**Symptom:** Generated story context doesn't include relevant code.
+
+**Solutions:**
+
+1. Ensure project-context.md exists and is current
+2. Check that architecture document references correct file paths
+3. Story may need more specific file references in acceptance criteria
+
+---
+
+### Code review not finding issues
+
+**Symptom:** Code review passes but bugs exist.
+
+**Solutions:**
+
+1. Code review is AI-assisted, not comprehensive testing
+2. Always run actual tests before marking story done
+3. Consider manual review for critical code paths
+
+---
+
+## Performance Issues
+
+### Workflows running slowly
+
+**Symptom:** Long wait times between workflow steps.
+
+**Solutions:**
+
+1. Use IDE-based workflows (faster than web)
+2. Keep documents concise (avoid unnecessary detail)
+3. Use sharded documents for large projects
+
+---
+
+### Context limit reached mid-workflow
+
+**Symptom:** Workflow stops or loses context partway through.
+
+**Solutions:**
+
+1. Save progress frequently (workflows auto-save on Continue)
+2. Break complex sections into multiple sessions
+3. Use step-file architecture (workflows resume from last step)
+
+---
+
+## Common Error Messages
+
+### "Input file not found"
+
+**Cause:** Workflow requires a document that doesn't exist.
+
+**Fix:** Complete prerequisite workflow first (e.g., Game Brief before GDD).
+
+---
+
+### "Invalid game type"
+
+**Cause:** Selected game type not in supported list.
+
+**Fix:** Check `game-types.csv` for valid type IDs.
+
+---
+
+### "Validation failed"
+
+**Cause:** Document doesn't meet checklist requirements.
+
+**Fix:** Review the validation output and address flagged items.
+
+---
+
+## Getting Help
+
+### Community Support
+
+- **[Discord Community](https://discord.gg/gk8jAdXWmj)** - Real-time help from the community
+- **[GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)** - Report bugs or request features
+
+### Self-Help
+
+1. Check `workflow-status` to understand current state
+2. Review workflow markdown files for expected behavior
+3. Look at completed example documents in the module
+
+### Reporting Issues
+
+When reporting issues, include:
+
+1. Which workflow and step
+2. Error message (if any)
+3. Relevant document frontmatter
+4. Steps to reproduce
+
+---
+
+## Next Steps
+
+- **[Quick Start Guide](./quick-start.md)** - Getting started
+- **[Workflows Guide](./workflows-guide.md)** - Workflow reference
+- **[Glossary](./glossary.md)** - Terminology

src/modules/bmgd/docs/workflows-guide.md

@@ -0,0 +1,463 @@
+# BMGD Workflows Guide
+
+Complete reference for all BMGD workflows organized by development phase.
+
+---
+
+## Workflow Overview
+
+BMGD workflows are organized into four phases:
+
+![BMGD Workflow Overview](./workflow-overview.jpg)
+
+---
+
+## Phase 1: Preproduction
+
+### Brainstorm Game
+
+**Command:** `brainstorm-game`
+**Agent:** Game Designer
+**Input:** None required
+**Output:** Ideas and concepts (optionally saved)
+
+**Description:**
+Guided ideation session using game-specific brainstorming techniques:
+
+- **MDA Framework** - Mechanics → Dynamics → Aesthetics analysis
+- **Core Loop Workshop** - Define the fundamental gameplay loop
+- **Player Fantasy Mining** - Explore what players want to feel
+- **Genre Mashup** - Combine genres for unique concepts
+
+**Steps:**
+
+1. Initialize brainstorm session
+2. Load game-specific techniques
+3. Execute ideation with selected techniques
+4. Summarize and (optionally) hand off to Game Brief
+
+---
+
+### Game Brief
+
+**Command:** `create-game-brief`
+**Agent:** Game Designer
+**Input:** Ideas from brainstorming (optional)
+**Output:** `{output_folder}/game-brief.md`
+
+**Description:**
+Captures your game's core vision and fundamentals. This is the foundation for all subsequent design work.
+
+**Sections covered:**
+
+- Game concept and vision
+- Design pillars (3-5 core principles)
+- Target audience and market
+- Platform considerations
+- Core gameplay loop
+- Initial scope definition
+
+---
+
+## Phase 2: Design
+
+### GDD (Game Design Document)
+
+**Command:** `create-gdd`
+**Agent:** Game Designer
+**Input:** Game Brief
+**Output:** `{output_folder}/gdd.md` (or sharded into `{output_folder}/gdd/`)
+
+**Description:**
+Comprehensive game design document with genre-specific sections based on 24 supported game types.
+
+**Core sections:**
+
+1. Executive Summary
+2. Gameplay Systems
+3. Core Mechanics
+4. Progression Systems
+5. UI/UX Design
+6. Audio Design
+7. Art Direction
+8. Technical Requirements
+9. Game-Type-Specific Sections
+10. Epic Generation (for sprint planning)
+
+**Features:**
+
+- Game type selection with specialized sections
+- Hybrid game type support
+- Automatic epic generation
+- Scale-adaptive complexity
+
+---
+
+### Narrative Design
+
+**Command:** `narrative`
+**Agent:** Game Designer
+**Input:** GDD (required), Game Brief (optional)
+**Output:** `{output_folder}/narrative-design.md`
+
+**Description:**
+For story-driven games. Creates comprehensive narrative documentation.
+
+**Sections covered:**
+
+1. Story Foundation (premise, themes, tone)
+2. Story Structure (acts, beats, pacing)
+3. Characters (protagonists, antagonists, supporting, arcs)
+4. World Building (setting, history, factions, locations)
+5. Dialogue Framework (style, branching)
+6. Environmental Storytelling
+7. Narrative Delivery Methods
+8. Gameplay-Narrative Integration
+9. Production Planning (scope, localization, voice acting)
+10. Appendices (relationship map, timeline)
+
+**Narrative Complexity Levels:**
+
+- **Critical** - Story IS the game (visual novels, adventure games)
+- **Heavy** - Deep narrative with gameplay (RPGs, story-driven action)
+- **Moderate** - Meaningful story supporting gameplay
+- **Light** - Minimal story, gameplay-focused
+
+---
+
+## Phase 3: Technical
+
+### Game Architecture
+
+**Command:** `create-architecture`
+**Agent:** Game Architect
+**Input:** GDD, Narrative Design (optional)
+**Output:** `{output_folder}/game-architecture.md`
+
+**Description:**
+Technical architecture document covering engine selection, system design, and implementation approach.
+
+**Sections covered:**
+
+1. Executive Summary
+2. Engine/Framework Selection
+3. Core Systems Architecture
+4. Data Architecture
+5. Performance Requirements
+6. Platform-Specific Considerations
+7. Development Environment
+8. Testing Strategy
+9. Build and Deployment
+10. Technical Risks and Mitigations
+
+---
+
+## Phase 4: Production
+
+Production workflows inherit from BMM and add game-specific overrides.
+
+### Sprint Planning
+
+**Command:** `sprint-planning`
+**Agent:** Game Scrum Master
+**Input:** GDD with epics
+**Output:** `{output_folder}/sprint-status.yaml`
+
+**Description:**
+Generates or updates sprint tracking from epic files. Sets up the sprint backlog and tracking.
+
+---
+
+### Sprint Status
+
+**Command:** `sprint-status`
+**Agent:** Game Scrum Master
+**Input:** `sprint-status.yaml`
+**Output:** Sprint summary, risks, next action recommendation
+
+**Description:**
+Summarizes sprint progress, surfaces risks (stale file, orphaned stories, stories in review), and recommends the next workflow to run. Supports three modes:
+
+- **interactive** (default): Displays summary with menu options
+- **validate**: Checks sprint-status.yaml structure
+- **data**: Returns raw data for other workflows
+
+---
+
+### Create Story
+
+**Command:** `create-story`
+**Agent:** Game Scrum Master
+**Input:** GDD, Architecture, Epic context
+**Output:** `{output_folder}/epics/{epic-name}/stories/{story-name}.md`
+
+**Description:**
+Creates implementable story drafts with acceptance criteria, tasks, and technical notes. Stories are marked ready-for-dev directly when created.
+
+**Validation:** `validate-create-story`
+
+---
+
+### Dev Story
+
+**Command:** `dev-story`
+**Agent:** Game Developer
+**Input:** Story (ready for dev)
+**Output:** Implemented code
+
+**Description:**
+Implements story tasks following acceptance criteria. Uses TDD approach (red-green-refactor). Updates sprint-status.yaml automatically on completion.
+
+---
+
+### Code Review
+
+**Command:** `code-review`
+**Agent:** Game Developer
+**Input:** Story (ready for review)
+**Output:** Review feedback, approved/needs changes
+
+**Description:**
+Thorough QA code review with game-specific considerations (performance, 60fps, etc.).
+
+---
+
+### Retrospective
+
+**Command:** `epic-retrospective`
+**Agent:** Game Scrum Master
+**Input:** Completed epic
+**Output:** Retrospective document
+
+**Description:**
+Facilitates team retrospective after epic completion. Captures learnings and improvements.
+
+---
+
+### Correct Course
+
+**Command:** `correct-course`
+**Agent:** Game Scrum Master or Game Architect
+**Input:** Current project state
+**Output:** Correction plan
+
+**Description:**
+Navigates significant changes when implementation is off-track. Analyzes impact and recommends adjustments.
+
+---
+
+## Workflow Status
+
+**Command:** `workflow-status`
+**Agent:** All agents
+**Output:** Project status summary
+
+**Description:**
+Checks current project status across all phases. Shows completed documents, current phase, and next steps.
+
+---
+
+## Quick-Flow Workflows
+
+Fast-track workflows that skip full planning phases. See **[Quick-Flow Guide](./quick-flow-guide.md)** for detailed usage.
+
+### Quick-Prototype
+
+**Command:** `quick-prototype`
+**Agent:** Game Designer, Game Developer
+**Input:** Idea or concept to test
+**Output:** Working prototype, playtest results
+
+**Description:**
+Rapid prototyping workflow for testing game mechanics and ideas quickly. Focuses on "feel" over polish.
+
+**Use when:**
+
+- Testing if a mechanic is fun
+- Proving a concept before committing to design
+- Experimenting with gameplay ideas
+
+---
+
+### Quick-Dev
+
+**Command:** `quick-dev`
+**Agent:** Game Developer
+**Input:** Tech-spec, prototype, or direct instructions
+**Output:** Implemented feature
+
+**Description:**
+Flexible development workflow with game-specific considerations (performance, feel, integration).
+
+**Use when:**
+
+- Implementing features from tech-specs
+- Building on successful prototypes
+- Making changes that don't need full story workflow
+
+---
+
+## Quality Assurance Workflows
+
+Game testing workflows for automated testing, playtesting, and quality assurance across Unity, Unreal, and Godot.
+
+### Test Framework
+
+**Command:** `test-framework`
+**Agent:** Game QA
+**Input:** Game project
+**Output:** Configured test framework
+
+**Description:**
+Initialize a production-ready test framework for your game engine:
+
+- **Unity**: Unity Test Framework with Edit Mode and Play Mode tests
+- **Unreal**: Unreal Automation system with functional tests
+- **Godot**: GUT (Godot Unit Test) framework
+
+**Creates:**
+
+- Test directory structure
+- Framework configuration
+- Sample unit and integration tests
+- Test documentation
+
+---
+
+### Test Design
+
+**Command:** `test-design`
+**Agent:** Game QA
+**Input:** GDD, Architecture
+**Output:** `{output_folder}/game-test-design.md`
+
+**Description:**
+Creates comprehensive test scenarios covering:
+
+- Core gameplay mechanics
+- Progression and save systems
+- Multiplayer (if applicable)
+- Platform certification requirements
+
+Uses GIVEN/WHEN/THEN format with priority levels (P0-P3).
+
+---
+
+### Automate
+
+**Command:** `automate`
+**Agent:** Game QA
+**Input:** Test design, game code
+**Output:** Automated test files
+
+**Description:**
+Generates engine-appropriate automated tests:
+
+- Unit tests for pure logic
+- Integration tests for system interactions
+- Smoke tests for critical path validation
+
+---
+
+### Playtest Plan
+
+**Command:** `playtest-plan`
+**Agent:** Game QA
+**Input:** Build, test objectives
+**Output:** `{output_folder}/playtest-plan.md`
+
+**Description:**
+Creates structured playtesting sessions:
+
+- Session structure (pre/during/post)
+- Observation guides
+- Interview questions
+- Analysis templates
+
+**Playtest Types:**
+
+- Internal (team validation)
+- External (unbiased feedback)
+- Focused (specific feature testing)
+
+---
+
+### Performance Test
+
+**Command:** `performance-test`
+**Agent:** Game QA
+**Input:** Platform targets
+**Output:** `{output_folder}/performance-test-plan.md`
+
+**Description:**
+Designs performance testing strategy:
+
+- Frame rate targets per platform
+- Memory budgets
+- Loading time requirements
+- Benchmark scenarios
+- Profiling methodology
+
+---
+
+### Test Review
+
+**Command:** `test-review`
+**Agent:** Game QA
+**Input:** Existing test suite
+**Output:** `{output_folder}/test-review-report.md`
+
+**Description:**
+Reviews test quality and coverage:
+
+- Test suite metrics
+- Quality assessment
+- Coverage gaps
+- Recommendations
+
+---
+
+## Utility Workflows
+
+### Party Mode
+
+**Command:** `party-mode`
+**Agent:** All agents
+
+**Description:**
+Brings multiple agents together for collaborative discussion on complex decisions.
+
+---
+
+### Advanced Elicitation
+
+**Command:** `advanced-elicitation`
+**Agent:** All agents (web only)
+
+**Description:**
+Deep exploration techniques to challenge assumptions and surface hidden requirements.
+
+---
+
+## Standalone BMGD Workflows
+
+BMGD Phase 4 workflows are standalone implementations tailored for game development:
+
+```yaml
+workflow: '{project-root}/_bmad/bmgd/workflows/4-production/dev-story/workflow.yaml'
+```
+
+This means:
+
+1. BMGD workflows are self-contained with game-specific logic
+2. Game-focused templates, checklists, and instructions
+3. No dependency on BMM workflow files
+
+---
+
+## Next Steps
+
+- **[Quick Start Guide](./quick-start.md)** - Get started with BMGD
+- **[Quick-Flow Guide](./quick-flow-guide.md)** - Rapid prototyping and development
+- **[Agents Guide](./agents-guide.md)** - Agent reference
+- **[Game Types Guide](./game-types-guide.md)** - Game type templates

src/modules/bmgd/gametest/knowledge/balance-testing.md

@@ -0,0 +1,220 @@
+# Balance Testing for Games
+
+## Overview
+
+Balance testing validates that your game's systems create fair, engaging, and appropriately challenging experiences. It covers difficulty, economy, progression, and competitive balance.
+
+## Types of Balance
+
+### Difficulty Balance
+
+- Is the game appropriately challenging?
+- Does difficulty progress smoothly?
+- Are difficulty spikes intentional?
+
+### Economy Balance
+
+- Is currency earned at the right rate?
+- Are prices fair for items/upgrades?
+- Can the economy be exploited?
+
+### Progression Balance
+
+- Does power growth feel satisfying?
+- Are unlocks paced well?
+- Is there meaningful choice in builds?
+
+### Competitive Balance
+
+- Are all options viable?
+- Is there a dominant strategy?
+- Do counters exist for strong options?
+
+## Balance Testing Methods
+
+### Spreadsheet Modeling
+
+Before implementation, model systems mathematically:
+
+- DPS calculations
+- Time-to-kill analysis
+- Economy simulations
+- Progression curves
+
+### Automated Simulation
+
+Run thousands of simulated games:
+
+- AI vs AI battles
+- Economy simulations
+- Progression modeling
+- Monte Carlo analysis
+
+### Telemetry Analysis
+
+Gather data from real players:
+
+- Win rates by character/weapon/strategy
+- Currency flow analysis
+- Completion rates by level
+- Time to reach milestones
+
+### Expert Testing
+
+High-skill players identify issues:
+
+- Exploits and degenerate strategies
+- Underpowered options
+- Skill ceiling concerns
+- Meta predictions
+
+## Key Balance Metrics
+
+### Combat Balance
+
+| Metric                    | Target              | Red Flag                  |
+| ------------------------- | ------------------- | ------------------------- |
+| Win rate (symmetric)      | 50%                 | <45% or >55%              |
+| Win rate (asymmetric)     | Varies by design    | Outliers by >10%          |
+| Time-to-kill              | Design dependent    | Too fast = no counterplay |
+| Damage dealt distribution | Even across options | One option dominates      |
+
+### Economy Balance
+
+| Metric               | Target               | Red Flag                        |
+| -------------------- | -------------------- | ------------------------------- |
+| Currency earned/hour | Design dependent     | Too fast = trivializes content  |
+| Item purchase rate   | Healthy distribution | Nothing bought = bad prices     |
+| Currency on hand     | Healthy churn        | Hoarding = nothing worth buying |
+| Premium currency     | Reasonable value     | Pay-to-win concerns             |
+
+### Progression Balance
+
+| Metric             | Target                 | Red Flag               |
+| ------------------ | ---------------------- | ---------------------- |
+| Time to max level  | Design dependent       | Too fast = no journey  |
+| Power growth curve | Smooth, satisfying     | Flat periods = boring  |
+| Build diversity    | Multiple viable builds | One "best" build       |
+| Content completion | Healthy progression    | Walls or trivial skips |
+
+## Balance Testing Process
+
+### 1. Define Design Intent
+
+- What experience are you creating?
+- What should feel powerful?
+- What trade-offs should exist?
+
+### 2. Model Before Building
+
+- Spreadsheet the math
+- Simulate outcomes
+- Identify potential issues
+
+### 3. Test Incrementally
+
+- Test each system in isolation
+- Then test systems together
+- Then test at scale
+
+### 4. Gather Data
+
+- Internal playtesting
+- Telemetry from beta
+- Expert feedback
+
+### 5. Iterate
+
+- Adjust based on data
+- Re-test changes
+- Document rationale
+
+## Common Balance Issues
+
+### Power Creep
+
+- **Symptom:** New content is always stronger
+- **Cause:** Fear of releasing weak content
+- **Fix:** Sidegrades over upgrades, periodic rebalancing
+
+### Dominant Strategy
+
+- **Symptom:** One approach beats all others
+- **Cause:** Insufficient counters, math oversight
+- **Fix:** Add counters, nerf dominant option, buff alternatives
+
+### Feast or Famine
+
+- **Symptom:** Players either crush or get crushed
+- **Cause:** Snowball mechanics, high variance
+- **Fix:** Comeback mechanics, reduce variance
+
+### Analysis Paralysis
+
+- **Symptom:** Too many options, players can't choose
+- **Cause:** Over-complicated systems
+- **Fix:** Simplify, provide recommendations
+
+## Balance Tools
+
+### Spreadsheets
+
+- Model DPS, TTK, economy
+- Simulate progression
+- Compare options side-by-side
+
+### Simulation Frameworks
+
+- Monte Carlo for variance
+- AI bots for combat testing
+- Economy simulations
+
+### Telemetry Systems
+
+- Track player choices
+- Measure outcomes
+- A/B test changes
+
+### Visualization
+
+- Graphs of win rates over time
+- Heat maps of player deaths
+- Flow charts of progression
+
+## Balance Testing Checklist
+
+### Pre-Launch
+
+- [ ] Core systems modeled in spreadsheets
+- [ ] Internal playtesting complete
+- [ ] No obvious dominant strategies
+- [ ] Difficulty curve feels right
+- [ ] Economy tested for exploits
+- [ ] Progression pacing validated
+
+### Live Service
+
+- [ ] Telemetry tracking key metrics
+- [ ] Regular balance reviews scheduled
+- [ ] Player feedback channels monitored
+- [ ] Hotfix process for critical issues
+- [ ] Communication plan for changes
+
+## Communicating Balance Changes
+
+### Patch Notes Best Practices
+
+- Explain the "why" not just the "what"
+- Use concrete numbers when possible
+- Acknowledge player concerns
+- Set expectations for future changes
+
+### Example
+
+```
+**Sword of Valor - Damage reduced from 100 to 85**
+Win rate for Sword users was 58%, indicating it was
+overperforming. This brings it in line with other weapons
+while maintaining its identity as a high-damage option.
+We'll continue monitoring and adjust if needed.
+```

src/modules/bmgd/gametest/knowledge/certification-testing.md

@@ -0,0 +1,319 @@
+# Platform Certification Testing Guide
+
+## Overview
+
+Certification testing ensures games meet platform holder requirements (Sony TRC, Microsoft XR, Nintendo Guidelines). Failing certification delays launch and costs money—test thoroughly before submission.
+
+## Platform Requirements Overview
+
+### Major Platforms
+
+| Platform        | Requirements Doc                       | Submission Portal         |
+| --------------- | -------------------------------------- | ------------------------- |
+| PlayStation     | TRC (Technical Requirements Checklist) | PlayStation Partners      |
+| Xbox            | XR (Xbox Requirements)                 | Xbox Partner Center       |
+| Nintendo Switch | Guidelines                             | Nintendo Developer Portal |
+| Steam           | Guidelines (less strict)               | Steamworks                |
+| iOS             | App Store Guidelines                   | App Store Connect         |
+| Android         | Play Store Policies                    | Google Play Console       |
+
+## Common Certification Categories
+
+### Account and User Management
+
+```
+REQUIREMENT: User Switching
+  GIVEN user is playing game
+  WHEN system-level user switch occurs
+  THEN game handles transition gracefully
+  AND no data corruption
+  AND correct user data loads
+
+REQUIREMENT: Guest Accounts
+  GIVEN guest user plays game
+  WHEN guest makes progress
+  THEN progress is not saved to other accounts
+  AND appropriate warnings displayed
+
+REQUIREMENT: Parental Controls
+  GIVEN parental controls restrict content
+  WHEN restricted content is accessed
+  THEN content is blocked or modified
+  AND appropriate messaging shown
+```
+
+### System Events
+
+```
+REQUIREMENT: Suspend/Resume (PS4/PS5)
+  GIVEN game is running
+  WHEN console enters rest mode
+  AND console wakes from rest mode
+  THEN game resumes correctly
+  AND network reconnects if needed
+  AND no audio/visual glitches
+
+REQUIREMENT: Controller Disconnect
+  GIVEN player is in gameplay
+  WHEN controller battery dies
+  THEN game pauses immediately
+  AND reconnect prompt appears
+  AND gameplay resumes when connected
+
+REQUIREMENT: Storage Full
+  GIVEN storage is nearly full
+  WHEN game attempts save
+  THEN graceful error handling
+  AND user informed of issue
+  AND no data corruption
+```
+
+### Network Requirements
+
+```
+REQUIREMENT: PSN/Xbox Live Unavailable
+  GIVEN online features
+  WHEN platform network is unavailable
+  THEN offline features still work
+  AND appropriate error messages
+  AND no crashes
+
+REQUIREMENT: Network Transition
+  GIVEN active online session
+  WHEN network connection lost
+  THEN graceful handling
+  AND reconnection attempted
+  AND user informed of status
+
+REQUIREMENT: NAT Type Handling
+  GIVEN various NAT configurations
+  WHEN multiplayer is attempted
+  THEN appropriate feedback on connectivity
+  AND fallback options offered
+```
+
+### Save Data
+
+```
+REQUIREMENT: Save Data Integrity
+  GIVEN save data exists
+  WHEN save is loaded
+  THEN data is validated
+  AND corrupted data handled gracefully
+  AND no crashes on invalid data
+
+REQUIREMENT: Cloud Save Sync
+  GIVEN cloud saves enabled
+  WHEN save conflict occurs
+  THEN user chooses which to keep
+  AND no silent data loss
+
+REQUIREMENT: Save Data Portability (PS4→PS5)
+  GIVEN save from previous generation
+  WHEN loaded on current generation
+  THEN data migrates correctly
+  AND no features lost
+```
+
+## Platform-Specific Requirements
+
+### PlayStation (TRC)
+
+| Requirement | Description                 | Priority |
+| ----------- | --------------------------- | -------- |
+| TRC R4010   | Suspend/resume handling     | Critical |
+| TRC R4037   | User switching              | Critical |
+| TRC R4062   | Parental controls           | Critical |
+| TRC R4103   | PS VR comfort ratings       | VR only  |
+| TRC R4120   | DualSense haptics standards | PS5      |
+| TRC R5102   | PSN sign-in requirements    | Online   |
+
+### Xbox (XR)
+
+| Requirement | Description                   | Priority    |
+| ----------- | ----------------------------- | ----------- |
+| XR-015      | Title timeout handling        | Critical    |
+| XR-045      | User sign-out handling        | Critical    |
+| XR-067      | Active user requirement       | Critical    |
+| XR-074      | Quick Resume support          | Series X/S  |
+| XR-115      | Xbox Accessibility Guidelines | Recommended |
+
+### Nintendo Switch
+
+| Requirement        | Description         | Priority |
+| ------------------ | ------------------- | -------- |
+| Docked/Handheld    | Seamless transition | Critical |
+| Joy-Con detachment | Controller handling | Critical |
+| Home button        | Immediate response  | Critical |
+| Screenshots/Video  | Proper support      | Required |
+| Sleep mode         | Resume correctly    | Critical |
+
+## Automated Test Examples
+
+### System Event Testing
+
+```cpp
+// Unreal - Suspend/Resume Test
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+    FSuspendResumeTest,
+    "Certification.System.SuspendResume",
+    EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::ProductFilter
+)
+
+bool FSuspendResumeTest::RunTest(const FString& Parameters)
+{
+    // Get game state before suspend
+    FGameState StateBefore = GetCurrentGameState();
+
+    // Simulate suspend
+    FCoreDelegates::ApplicationWillEnterBackgroundDelegate.Broadcast();
+
+    // Simulate resume
+    FCoreDelegates::ApplicationHasEnteredForegroundDelegate.Broadcast();
+
+    // Verify state matches
+    FGameState StateAfter = GetCurrentGameState();
+
+    TestEqual("Player position preserved",
+        StateAfter.PlayerPosition, StateBefore.PlayerPosition);
+    TestEqual("Game progress preserved",
+        StateAfter.Progress, StateBefore.Progress);
+
+    return true;
+}
+```
+
+```csharp
+// Unity - Controller Disconnect Test
+[UnityTest]
+public IEnumerator ControllerDisconnect_ShowsPauseMenu()
+{
+    // Simulate gameplay
+    GameManager.Instance.StartGame();
+    yield return new WaitForSeconds(1f);
+
+    // Simulate controller disconnect
+    InputSystem.DisconnectDevice(Gamepad.current);
+    yield return null;
+
+    // Verify pause menu shown
+    Assert.IsTrue(PauseMenu.IsVisible, "Pause menu should appear");
+    Assert.IsTrue(Time.timeScale == 0, "Game should be paused");
+
+    // Simulate reconnect
+    InputSystem.ReconnectDevice(Gamepad.current);
+    yield return null;
+
+    // Verify prompt appears
+    Assert.IsTrue(ReconnectPrompt.IsVisible);
+}
+```
+
+```gdscript
+# Godot - Save Corruption Test
+func test_corrupted_save_handling():
+    # Create corrupted save file
+    var file = FileAccess.open("user://save_corrupt.dat", FileAccess.WRITE)
+    file.store_string("CORRUPTED_GARBAGE_DATA")
+    file.close()
+
+    # Attempt to load
+    var result = SaveManager.load("save_corrupt")
+
+    # Should handle gracefully
+    assert_null(result, "Should return null for corrupted save")
+    assert_false(OS.has_feature("crashed"), "Should not crash")
+
+    # Should show user message
+    var message_shown = ErrorDisplay.current_message != ""
+    assert_true(message_shown, "Should inform user of corruption")
+```
+
+## Pre-Submission Checklist
+
+### General Requirements
+
+- [ ] Game boots to interactive state within platform time limit
+- [ ] Controller disconnect pauses game
+- [ ] User sign-out handled correctly
+- [ ] Save data validates on load
+- [ ] No crashes in 8+ hours of automated testing
+- [ ] Memory usage within platform limits
+- [ ] Load times meet requirements
+
+### Platform Services
+
+- [ ] Achievements/Trophies work correctly
+- [ ] Friends list integration works
+- [ ] Invite system functions
+- [ ] Store/DLC integration validated
+- [ ] Cloud saves sync properly
+
+### Accessibility (Increasingly Required)
+
+- [ ] Text size options
+- [ ] Colorblind modes
+- [ ] Subtitle options
+- [ ] Controller remapping
+- [ ] Screen reader support (where applicable)
+
+### Content Compliance
+
+- [ ] Age rating displayed correctly
+- [ ] Parental controls respected
+- [ ] No prohibited content
+- [ ] Required legal text present
+
+## Common Certification Failures
+
+| Issue                 | Platform     | Fix                                 |
+| --------------------- | ------------ | ----------------------------------- |
+| Home button delay     | All consoles | Respond within required time        |
+| Controller timeout    | PlayStation  | Handle reactivation properly        |
+| Save on suspend       | PlayStation  | Don't save during suspend           |
+| User context loss     | Xbox         | Track active user correctly         |
+| Joy-Con drift         | Switch       | Proper deadzone handling            |
+| Background memory     | Mobile       | Release resources when backgrounded |
+| Crash on corrupt data | All          | Validate all loaded data            |
+
+## Testing Matrix
+
+### Build Configurations to Test
+
+| Configuration   | Scenarios               |
+| --------------- | ----------------------- |
+| First boot      | No save data exists     |
+| Return user     | Save data present       |
+| Upgrade path    | Previous version save   |
+| Fresh install   | After uninstall         |
+| Low storage     | Minimum space available |
+| Network offline | No connectivity         |
+
+### Hardware Variants
+
+| Platform    | Variants to Test                |
+| ----------- | ------------------------------- |
+| PlayStation | PS4, PS4 Pro, PS5               |
+| Xbox        | One, One X, Series S, Series X  |
+| Switch      | Docked, Handheld, Lite          |
+| PC          | Min spec, recommended, high-end |
+
+## Best Practices
+
+### DO
+
+- Read platform requirements document thoroughly
+- Test on actual hardware, not just dev kits
+- Automate certification test scenarios
+- Submit with extra time for re-submission
+- Document all edge case handling
+- Test with real user accounts
+
+### DON'T
+
+- Assume debug builds behave like retail
+- Skip testing on oldest supported hardware
+- Ignore platform-specific features
+- Wait until last minute to test certification items
+- Use placeholder content in submission build
+- Skip testing with real platform services

src/modules/bmgd/gametest/knowledge/compatibility-testing.md

@@ -0,0 +1,228 @@
+# Compatibility Testing for Games
+
+## Overview
+
+Compatibility testing ensures your game works correctly across different hardware, operating systems, and configurations that players use.
+
+## Types of Compatibility Testing
+
+### Hardware Compatibility
+
+- Graphics cards (NVIDIA, AMD, Intel)
+- CPUs (Intel, AMD, Apple Silicon)
+- Memory configurations
+- Storage types (HDD, SSD, NVMe)
+- Input devices (controllers, keyboards, mice)
+
+### Software Compatibility
+
+- Operating system versions
+- Driver versions
+- Background software conflicts
+- Antivirus interference
+
+### Platform Compatibility
+
+- Console SKUs (PS5, Xbox Series X|S)
+- PC storefronts (Steam, Epic, GOG)
+- Mobile devices (iOS, Android)
+- Cloud gaming services
+
+### Configuration Compatibility
+
+- Graphics settings combinations
+- Resolution and aspect ratios
+- Refresh rates (60Hz, 144Hz, etc.)
+- HDR and color profiles
+
+## Testing Matrix
+
+### Minimum Hardware Matrix
+
+| Component | Budget   | Mid-Range | High-End |
+| --------- | -------- | --------- | -------- |
+| GPU       | GTX 1050 | RTX 3060  | RTX 4080 |
+| CPU       | i5-6400  | i7-10700  | i9-13900 |
+| RAM       | 8GB      | 16GB      | 32GB     |
+| Storage   | HDD      | SATA SSD  | NVMe     |
+
+### OS Matrix
+
+- Windows 10 (21H2, 22H2)
+- Windows 11 (22H2, 23H2)
+- macOS (Ventura, Sonoma)
+- Linux (Ubuntu LTS, SteamOS)
+
+### Controller Matrix
+
+- Xbox Controller (wired, wireless, Elite)
+- PlayStation DualSense
+- Nintendo Pro Controller
+- Generic XInput controllers
+- Keyboard + Mouse
+
+## Testing Approach
+
+### 1. Define Supported Configurations
+
+- Minimum specifications
+- Recommended specifications
+- Officially supported platforms
+- Known unsupported configurations
+
+### 2. Create Test Matrix
+
+- Prioritize common configurations
+- Include edge cases
+- Balance coverage vs. effort
+
+### 3. Execute Systematic Testing
+
+- Full playthrough on key configs
+- Spot checks on edge cases
+- Automated smoke tests where possible
+
+### 4. Document Issues
+
+- Repro steps with exact configuration
+- Severity and frequency
+- Workarounds if available
+
+## Common Compatibility Issues
+
+### Graphics Issues
+
+| Issue                | Cause                  | Detection                        |
+| -------------------- | ---------------------- | -------------------------------- |
+| Crashes on launch    | Driver incompatibility | Test on multiple GPUs            |
+| Rendering artifacts  | Shader issues          | Visual inspection across configs |
+| Performance variance | Optimization gaps      | Profile on multiple GPUs         |
+| Resolution bugs      | Aspect ratio handling  | Test non-standard resolutions    |
+
+### Input Issues
+
+| Issue                   | Cause              | Detection                      |
+| ----------------------- | ------------------ | ------------------------------ |
+| Controller not detected | Missing driver/API | Test all supported controllers |
+| Wrong button prompts    | Platform detection | Swap controllers mid-game      |
+| Stick drift handling    | Deadzone issues    | Test worn controllers          |
+| Mouse acceleration      | Raw input issues   | Test at different DPIs         |
+
+### Audio Issues
+
+| Issue          | Cause            | Detection                   |
+| -------------- | ---------------- | --------------------------- |
+| No sound       | Device selection | Test multiple audio devices |
+| Crackling      | Buffer issues    | Test under CPU load         |
+| Wrong channels | Surround setup   | Test stereo vs 5.1 vs 7.1   |
+
+## Platform-Specific Considerations
+
+### PC
+
+- **Steam:** Verify Steam Input, Steamworks features
+- **Epic:** Test EOS features if used
+- **GOG:** Test offline/DRM-free functionality
+- **Game Pass:** Test Xbox services integration
+
+### Console
+
+- **Certification Requirements:** Study TRCs/XRs early
+- **SKU Differences:** Test on all variants (S vs X)
+- **External Storage:** Test on USB drives
+- **Quick Resume:** Test suspend/resume cycles
+
+### Mobile
+
+- **Device Fragmentation:** Test across screen sizes
+- **OS Versions:** Test min supported to latest
+- **Permissions:** Test permission flows
+- **App Lifecycle:** Test background/foreground
+
+## Automated Compatibility Testing
+
+### Smoke Tests
+
+```yaml
+# Run on matrix of configurations
+compatibility_test:
+  matrix:
+    os: [windows-10, windows-11, ubuntu-22]
+    gpu: [nvidia, amd, intel]
+  script:
+    - launch_game --headless
+    - verify_main_menu_reached
+    - check_no_errors
+```
+
+### Screenshot Comparison
+
+- Capture screenshots on different GPUs
+- Compare for rendering differences
+- Flag significant deviations
+
+### Cloud Testing Services
+
+- AWS Device Farm
+- BrowserStack (web games)
+- LambdaTest
+- Sauce Labs
+
+## Compatibility Checklist
+
+### Pre-Alpha
+
+- [ ] Minimum specs defined
+- [ ] Key platforms identified
+- [ ] Test matrix created
+- [ ] Test hardware acquired/rented
+
+### Alpha
+
+- [ ] Full playthrough on min spec
+- [ ] Controller support verified
+- [ ] Major graphics issues found
+- [ ] Platform SDK integrated
+
+### Beta
+
+- [ ] All matrix configurations tested
+- [ ] Edge cases explored
+- [ ] Certification pre-check done
+- [ ] Store page requirements met
+
+### Release
+
+- [ ] Final certification passed
+- [ ] Known issues documented
+- [ ] Workarounds communicated
+- [ ] Support matrix published
+
+## Documenting Compatibility
+
+### System Requirements
+
+```
+MINIMUM:
+- OS: Windows 10 64-bit
+- Processor: Intel Core i5-6400 or AMD equivalent
+- Memory: 8 GB RAM
+- Graphics: NVIDIA GTX 1050 or AMD RX 560
+- Storage: 50 GB available space
+
+RECOMMENDED:
+- OS: Windows 11 64-bit
+- Processor: Intel Core i7-10700 or AMD equivalent
+- Memory: 16 GB RAM
+- Graphics: NVIDIA RTX 3060 or AMD RX 6700 XT
+- Storage: 50 GB SSD
+```
+
+### Known Issues
+
+Maintain a public-facing list of known compatibility issues with:
+
+- Affected configurations
+- Symptoms
+- Workarounds
+- Fix status

src/modules/bmgd/gametest/knowledge/godot-testing.md

@@ -0,0 +1,376 @@
+# Godot GUT Testing Guide
+
+## Overview
+
+GUT (Godot Unit Test) is the standard unit testing framework for Godot. It provides a full-featured testing framework with assertions, mocking, and CI integration.
+
+## Installation
+
+### Via Asset Library
+
+1. Open AssetLib in Godot
+2. Search for "GUT"
+3. Download and install
+4. Enable the plugin in Project Settings
+
+### Via Git Submodule
+
+```bash
+git submodule add https://github.com/bitwes/Gut.git addons/gut
+```
+
+## Project Structure
+
+```
+project/
+├── addons/
+│   └── gut/
+├── src/
+│   ├── player/
+│   │   └── player.gd
+│   └── combat/
+│       └── damage_calculator.gd
+└── tests/
+    ├── unit/
+    │   └── test_damage_calculator.gd
+    └── integration/
+        └── test_player_combat.gd
+```
+
+## Basic Test Structure
+
+### Simple Test Class
+
+```gdscript
+# tests/unit/test_damage_calculator.gd
+extends GutTest
+
+var calculator: DamageCalculator
+
+func before_each():
+    calculator = DamageCalculator.new()
+
+func after_each():
+    calculator.free()
+
+func test_calculate_base_damage():
+    var result = calculator.calculate(100.0, 1.0)
+    assert_eq(result, 100.0, "Base damage should equal input")
+
+func test_calculate_critical_hit():
+    var result = calculator.calculate(100.0, 2.0)
+    assert_eq(result, 200.0, "Critical hit should double damage")
+
+func test_calculate_with_zero_multiplier():
+    var result = calculator.calculate(100.0, 0.0)
+    assert_eq(result, 0.0, "Zero multiplier should result in zero damage")
+```
+
+### Parameterized Tests
+
+```gdscript
+func test_damage_scenarios():
+    var scenarios = [
+        {"base": 100.0, "mult": 1.0, "expected": 100.0},
+        {"base": 100.0, "mult": 2.0, "expected": 200.0},
+        {"base": 50.0, "mult": 1.5, "expected": 75.0},
+        {"base": 0.0, "mult": 2.0, "expected": 0.0},
+    ]
+
+    for scenario in scenarios:
+        var result = calculator.calculate(scenario.base, scenario.mult)
+        assert_eq(
+            result,
+            scenario.expected,
+            "Base %s * %s should equal %s" % [
+                scenario.base, scenario.mult, scenario.expected
+            ]
+        )
+```
+
+## Testing Nodes
+
+### Scene Testing
+
+```gdscript
+# tests/integration/test_player.gd
+extends GutTest
+
+var player: Player
+var player_scene = preload("res://src/player/player.tscn")
+
+func before_each():
+    player = player_scene.instantiate()
+    add_child(player)
+
+func after_each():
+    player.queue_free()
+
+func test_player_initial_health():
+    assert_eq(player.health, 100, "Player should start with 100 health")
+
+func test_player_takes_damage():
+    player.take_damage(30)
+    assert_eq(player.health, 70, "Health should be reduced by damage")
+
+func test_player_dies_at_zero_health():
+    player.take_damage(100)
+    assert_true(player.is_dead, "Player should be dead at 0 health")
+```
+
+### Testing with Signals
+
+```gdscript
+func test_damage_emits_signal():
+    watch_signals(player)
+
+    player.take_damage(10)
+
+    assert_signal_emitted(player, "health_changed")
+    assert_signal_emit_count(player, "health_changed", 1)
+
+func test_death_emits_signal():
+    watch_signals(player)
+
+    player.take_damage(100)
+
+    assert_signal_emitted(player, "died")
+```
+
+### Testing with Await
+
+```gdscript
+func test_attack_cooldown():
+    player.attack()
+    assert_true(player.is_attacking)
+
+    # Wait for cooldown
+    await get_tree().create_timer(player.attack_cooldown).timeout
+
+    assert_false(player.is_attacking)
+    assert_true(player.can_attack)
+```
+
+## Mocking and Doubles
+
+### Creating Doubles
+
+```gdscript
+func test_enemy_uses_pathfinding():
+    var mock_pathfinding = double(Pathfinding).new()
+    stub(mock_pathfinding, "find_path").to_return([Vector2(0, 0), Vector2(10, 10)])
+
+    var enemy = Enemy.new()
+    enemy.pathfinding = mock_pathfinding
+
+    enemy.move_to(Vector2(10, 10))
+
+    assert_called(mock_pathfinding, "find_path")
+```
+
+### Partial Doubles
+
+```gdscript
+func test_player_inventory():
+    var player_double = partial_double(Player).new()
+    stub(player_double, "save_to_disk").to_do_nothing()
+
+    player_double.add_item("sword")
+
+    assert_eq(player_double.inventory.size(), 1)
+    assert_called(player_double, "save_to_disk")
+```
+
+## Physics Testing
+
+### Testing Collision
+
+```gdscript
+func test_projectile_hits_enemy():
+    var projectile = Projectile.new()
+    var enemy = Enemy.new()
+
+    add_child(projectile)
+    add_child(enemy)
+
+    projectile.global_position = Vector2(0, 0)
+    enemy.global_position = Vector2(100, 0)
+
+    projectile.velocity = Vector2(200, 0)
+
+    # Simulate physics frames
+    for i in range(60):
+        await get_tree().physics_frame
+
+    assert_true(enemy.was_hit, "Enemy should be hit by projectile")
+
+    projectile.queue_free()
+    enemy.queue_free()
+```
+
+### Testing Area2D
+
+```gdscript
+func test_pickup_collected():
+    var pickup = Pickup.new()
+    var player = player_scene.instantiate()
+
+    add_child(pickup)
+    add_child(player)
+
+    pickup.global_position = Vector2(50, 50)
+    player.global_position = Vector2(50, 50)
+
+    # Wait for physics to process overlap
+    await get_tree().physics_frame
+    await get_tree().physics_frame
+
+    assert_true(pickup.is_queued_for_deletion(), "Pickup should be collected")
+
+    player.queue_free()
+```
+
+## Input Testing
+
+### Simulating Input
+
+```gdscript
+func test_jump_on_input():
+    var input_event = InputEventKey.new()
+    input_event.keycode = KEY_SPACE
+    input_event.pressed = true
+
+    Input.parse_input_event(input_event)
+    await get_tree().process_frame
+
+    player._unhandled_input(input_event)
+
+    assert_true(player.is_jumping, "Player should jump on space press")
+```
+
+### Testing Input Actions
+
+```gdscript
+func test_attack_action():
+    # Simulate action press
+    Input.action_press("attack")
+    await get_tree().process_frame
+
+    player._process(0.016)
+
+    assert_true(player.is_attacking)
+
+    Input.action_release("attack")
+```
+
+## Resource Testing
+
+### Testing Custom Resources
+
+```gdscript
+func test_weapon_stats_resource():
+    var weapon = WeaponStats.new()
+    weapon.base_damage = 10.0
+    weapon.attack_speed = 2.0
+
+    assert_eq(weapon.dps, 20.0, "DPS should be damage * speed")
+
+func test_save_load_resource():
+    var original = PlayerData.new()
+    original.level = 5
+    original.gold = 1000
+
+    ResourceSaver.save(original, "user://test_save.tres")
+    var loaded = ResourceLoader.load("user://test_save.tres")
+
+    assert_eq(loaded.level, 5)
+    assert_eq(loaded.gold, 1000)
+
+    DirAccess.remove_absolute("user://test_save.tres")
+```
+
+## GUT Configuration
+
+### gut_config.json
+
+```json
+{
+  "dirs": ["res://tests/"],
+  "include_subdirs": true,
+  "prefix": "test_",
+  "suffix": ".gd",
+  "should_exit": true,
+  "should_exit_on_success": true,
+  "log_level": 1,
+  "junit_xml_file": "results.xml",
+  "font_size": 16
+}
+```
+
+## CI Integration
+
+### Command Line Execution
+
+```bash
+# Run all tests
+godot --headless -s addons/gut/gut_cmdln.gd
+
+# Run specific tests
+godot --headless -s addons/gut/gut_cmdln.gd \
+  -gdir=res://tests/unit \
+  -gprefix=test_
+
+# With JUnit output
+godot --headless -s addons/gut/gut_cmdln.gd \
+  -gjunit_xml_file=results.xml
+```
+
+### GitHub Actions
+
+```yaml
+test:
+  runs-on: ubuntu-latest
+  container:
+    image: barichello/godot-ci:4.2
+  steps:
+    - uses: actions/checkout@v4
+
+    - name: Run Tests
+      run: |
+        godot --headless -s addons/gut/gut_cmdln.gd \
+          -gjunit_xml_file=results.xml
+
+    - name: Publish Results
+      uses: mikepenz/action-junit-report@v4
+      with:
+        report_paths: results.xml
+```
+
+## Best Practices
+
+### DO
+
+- Use `before_each`/`after_each` for setup/teardown
+- Free nodes after tests to prevent leaks
+- Use meaningful assertion messages
+- Group related tests in the same file
+- Use `watch_signals` for signal testing
+- Await physics frames when testing physics
+
+### DON'T
+
+- Don't test Godot's built-in functionality
+- Don't rely on execution order between test files
+- Don't leave orphan nodes
+- Don't use `yield` (use `await` in Godot 4)
+- Don't test private methods directly
+
+## Troubleshooting
+
+| Issue                | Cause              | Fix                                  |
+| -------------------- | ------------------ | ------------------------------------ |
+| Tests not found      | Wrong prefix/path  | Check gut_config.json                |
+| Orphan nodes warning | Missing cleanup    | Add `queue_free()` in `after_each`   |
+| Signal not detected  | Signal not watched | Call `watch_signals()` before action |
+| Physics not working  | Missing frames     | Await `physics_frame`                |
+| Flaky tests          | Timing issues      | Use proper await/signals             |

src/modules/bmgd/gametest/knowledge/input-testing.md

@@ -0,0 +1,315 @@
+# Input Testing Guide
+
+## Overview
+
+Input testing validates that all supported input devices work correctly across platforms. Poor input handling frustrates players instantly—responsive, accurate input is foundational to game feel.
+
+## Input Categories
+
+### Device Types
+
+| Device            | Platforms      | Key Concerns                        |
+| ----------------- | -------------- | ----------------------------------- |
+| Keyboard + Mouse  | PC             | Key conflicts, DPI sensitivity      |
+| Gamepad (Xbox/PS) | PC, Console    | Deadzone, vibration, button prompts |
+| Touch             | Mobile, Switch | Multi-touch, gesture recognition    |
+| Motion Controls   | Switch, VR     | Calibration, drift, fatigue         |
+| Specialty         | Various        | Flight sticks, wheels, fight sticks |
+
+### Input Characteristics
+
+| Characteristic | Description                  | Test Focus                       |
+| -------------- | ---------------------------- | -------------------------------- |
+| Responsiveness | Input-to-action delay        | Should feel instant (< 100ms)    |
+| Accuracy       | Input maps to correct action | No ghost inputs or missed inputs |
+| Consistency    | Same input = same result     | Deterministic behavior           |
+| Accessibility  | Alternative input support    | Remapping, assist options        |
+
+## Test Scenarios
+
+### Keyboard and Mouse
+
+```
+SCENARIO: All Keybinds Functional
+  GIVEN default keyboard bindings
+  WHEN each bound key is pressed
+  THEN corresponding action triggers
+  AND no key conflicts exist
+
+SCENARIO: Key Remapping
+  GIVEN player remaps "Jump" from Space to F
+  WHEN F is pressed
+  THEN jump action triggers
+  AND Space no longer triggers jump
+  AND remapping persists after restart
+
+SCENARIO: Mouse Sensitivity
+  GIVEN sensitivity set to 5 (mid-range)
+  WHEN mouse moves 10cm
+  THEN camera rotation matches expected degrees
+  AND movement feels consistent at different frame rates
+
+SCENARIO: Mouse Button Support
+  GIVEN mouse with 5+ buttons
+  WHEN side buttons are pressed
+  THEN they can be bound to actions
+  AND they function correctly in gameplay
+```
+
+### Gamepad
+
+```
+SCENARIO: Analog Stick Deadzone
+  GIVEN controller with slight stick drift
+  WHEN stick is in neutral position
+  THEN no movement occurs (deadzone filters drift)
+  AND intentional small movements still register
+
+SCENARIO: Trigger Pressure
+  GIVEN analog triggers
+  WHEN trigger is partially pressed
+  THEN partial values are read (e.g., 0.5 for half-press)
+  AND full press reaches 1.0
+
+SCENARIO: Controller Hot-Swap
+  GIVEN game running with keyboard
+  WHEN gamepad is connected
+  THEN input prompts switch to gamepad icons
+  AND gamepad input works immediately
+  AND keyboard still works if used
+
+SCENARIO: Vibration Feedback
+  GIVEN rumble-enabled controller
+  WHEN damage is taken
+  THEN controller vibrates appropriately
+  AND vibration intensity matches damage severity
+```
+
+### Touch Input
+
+```
+SCENARIO: Multi-Touch Accuracy
+  GIVEN virtual joystick and buttons
+  WHEN left thumb on joystick AND right thumb on button
+  THEN both inputs register simultaneously
+  AND no interference between touch points
+
+SCENARIO: Gesture Recognition
+  GIVEN swipe-to-attack mechanic
+  WHEN player swipes right
+  THEN attack direction matches swipe
+  AND swipe is distinguished from tap
+
+SCENARIO: Touch Target Size
+  GIVEN minimum touch target of 44x44 points
+  WHEN buttons are placed
+  THEN all interactive elements meet minimum size
+  AND elements have adequate spacing
+```
+
+## Platform-Specific Testing
+
+### PC
+
+- Multiple keyboard layouts (QWERTY, AZERTY, QWERTZ)
+- Different mouse DPI settings (400-3200+)
+- Multiple monitors (cursor confinement)
+- Background application conflicts
+- Steam Input API integration
+
+### Console
+
+| Platform    | Specific Tests                             |
+| ----------- | ------------------------------------------ |
+| PlayStation | Touchpad, adaptive triggers, haptics       |
+| Xbox        | Impulse triggers, Elite controller paddles |
+| Switch      | Joy-Con detachment, gyro, HD rumble        |
+
+### Mobile
+
+- Different screen sizes and aspect ratios
+- Notch/cutout avoidance
+- External controller support
+- Apple MFi / Android gamepad compatibility
+
+## Automated Test Examples
+
+### Unity
+
+```csharp
+using UnityEngine.InputSystem;
+
+[UnityTest]
+public IEnumerator Movement_WithGamepad_RespondsToStick()
+{
+    var gamepad = InputSystem.AddDevice<Gamepad>();
+
+    yield return null;
+
+    // Simulate stick input
+    Set(gamepad.leftStick, new Vector2(1, 0));
+    yield return new WaitForSeconds(0.1f);
+
+    Assert.Greater(player.transform.position.x, 0f,
+        "Player should move right");
+
+    InputSystem.RemoveDevice(gamepad);
+}
+
+[UnityTest]
+public IEnumerator InputLatency_UnderLoad_StaysAcceptable()
+{
+    float inputTime = Time.realtimeSinceStartup;
+    bool actionTriggered = false;
+
+    player.OnJump += () => {
+        float latency = (Time.realtimeSinceStartup - inputTime) * 1000;
+        Assert.Less(latency, 100f, "Input latency should be under 100ms");
+        actionTriggered = true;
+    };
+
+    var keyboard = InputSystem.AddDevice<Keyboard>();
+    Press(keyboard.spaceKey);
+
+    yield return new WaitForSeconds(0.2f);
+
+    Assert.IsTrue(actionTriggered, "Jump should have triggered");
+}
+
+[Test]
+public void Deadzone_FiltersSmallInputs()
+{
+    var settings = new InputSettings { stickDeadzone = 0.2f };
+
+    // Input below deadzone
+    var filtered = InputProcessor.ApplyDeadzone(new Vector2(0.1f, 0.1f), settings);
+    Assert.AreEqual(Vector2.zero, filtered);
+
+    // Input above deadzone
+    filtered = InputProcessor.ApplyDeadzone(new Vector2(0.5f, 0.5f), settings);
+    Assert.AreNotEqual(Vector2.zero, filtered);
+}
+```
+
+### Unreal
+
+```cpp
+bool FInputTest::RunTest(const FString& Parameters)
+{
+    // Test gamepad input mapping
+    APlayerController* PC = GetWorld()->GetFirstPlayerController();
+
+    // Simulate gamepad stick input
+    FInputKeyParams Params;
+    Params.Key = EKeys::Gamepad_LeftX;
+    Params.Delta = FVector(1.0f, 0, 0);
+    PC->InputKey(Params);
+
+    // Verify movement
+    APawn* Pawn = PC->GetPawn();
+    FVector Velocity = Pawn->GetVelocity();
+
+    TestTrue("Pawn should be moving", Velocity.SizeSquared() > 0);
+
+    return true;
+}
+```
+
+### Godot
+
+```gdscript
+func test_input_action_mapping():
+    # Verify action exists
+    assert_true(InputMap.has_action("jump"))
+
+    # Simulate input
+    var event = InputEventKey.new()
+    event.keycode = KEY_SPACE
+    event.pressed = true
+
+    Input.parse_input_event(event)
+    await get_tree().process_frame
+
+    assert_true(Input.is_action_just_pressed("jump"))
+
+func test_gamepad_deadzone():
+    var input = Vector2(0.15, 0.1)
+    var deadzone = 0.2
+
+    var processed = input_processor.apply_deadzone(input, deadzone)
+
+    assert_eq(processed, Vector2.ZERO, "Small input should be filtered")
+
+func test_controller_hotswap():
+    # Simulate controller connect
+    Input.joy_connection_changed(0, true)
+    await get_tree().process_frame
+
+    var prompt_icon = ui.get_action_prompt("jump")
+
+    assert_true(prompt_icon.texture.resource_path.contains("gamepad"),
+        "Should show gamepad prompts after controller connect")
+```
+
+## Accessibility Testing
+
+### Requirements Checklist
+
+- [ ] Full keyboard navigation (no mouse required)
+- [ ] Remappable controls for all actions
+- [ ] Button hold alternatives to rapid press
+- [ ] Toggle options for hold actions
+- [ ] One-handed control schemes
+- [ ] Colorblind-friendly UI indicators
+- [ ] Screen reader support for menus
+
+### Accessibility Test Scenarios
+
+```
+SCENARIO: Keyboard-Only Navigation
+  GIVEN mouse is disconnected
+  WHEN navigating through all menus
+  THEN all menu items are reachable via keyboard
+  AND focus indicators are clearly visible
+
+SCENARIO: Button Hold Toggle
+  GIVEN "sprint requires hold" is toggled OFF
+  WHEN sprint button is tapped once
+  THEN sprint activates
+  AND sprint stays active until tapped again
+
+SCENARIO: Reduced Button Mashing
+  GIVEN QTE assist mode enabled
+  WHEN QTE sequence appears
+  THEN single press advances sequence
+  AND no rapid input required
+```
+
+## Performance Metrics
+
+| Metric                  | Target          | Maximum Acceptable |
+| ----------------------- | --------------- | ------------------ |
+| Input-to-render latency | < 50ms          | 100ms              |
+| Polling rate match      | 1:1 with device | No input loss      |
+| Deadzone processing     | < 1ms           | 5ms                |
+| Rebind save/load        | < 100ms         | 500ms              |
+
+## Best Practices
+
+### DO
+
+- Test with actual hardware, not just simulated input
+- Support simultaneous keyboard + gamepad
+- Provide sensible default deadzones
+- Show device-appropriate button prompts
+- Allow complete control remapping
+- Test at different frame rates
+
+### DON'T
+
+- Assume controller layout (Xbox vs PlayStation)
+- Hard-code input mappings
+- Ignore analog input precision
+- Skip accessibility considerations
+- Forget about input during loading/cutscenes
+- Neglect testing with worn/drifting controllers

src/modules/bmgd/gametest/knowledge/localization-testing.md

@@ -0,0 +1,304 @@
+# Localization Testing Guide
+
+## Overview
+
+Localization testing ensures games work correctly across languages, regions, and cultures. Beyond translation, it validates text display, cultural appropriateness, and regional compliance.
+
+## Test Categories
+
+### Linguistic Testing
+
+| Category             | Focus                   | Examples                       |
+| -------------------- | ----------------------- | ------------------------------ |
+| Translation accuracy | Meaning preserved       | Idioms, game terminology       |
+| Grammar/spelling     | Language correctness    | Verb tense, punctuation        |
+| Consistency          | Same terms throughout   | "Health" vs "HP" vs "Life"     |
+| Context              | Meaning in game context | Item names, skill descriptions |
+
+### Functional Testing
+
+| Category       | Focus                   | Examples                    |
+| -------------- | ----------------------- | --------------------------- |
+| Text display   | Fits in UI              | Button labels, dialog boxes |
+| Font support   | Characters render       | CJK, Cyrillic, Arabic       |
+| Text expansion | Longer translations     | German is ~30% longer       |
+| RTL support    | Right-to-left languages | Arabic, Hebrew layouts      |
+
+### Cultural Testing
+
+| Category             | Focus              | Examples                  |
+| -------------------- | ------------------ | ------------------------- |
+| Cultural sensitivity | Offensive content  | Gestures, symbols, colors |
+| Regional compliance  | Legal requirements | Ratings, gambling laws    |
+| Date/time formats    | Local conventions  | DD/MM/YYYY vs MM/DD/YYYY  |
+| Number formats       | Decimal separators | 1,000.00 vs 1.000,00      |
+
+## Test Scenarios
+
+### Text Display
+
+```
+SCENARIO: Text Fits UI Elements
+  GIVEN all localized strings
+  WHEN displayed in target language
+  THEN text fits within UI boundaries
+  AND no truncation or overflow occurs
+  AND text remains readable
+
+SCENARIO: Dynamic Text Insertion
+  GIVEN template "Player {name} scored {points} points"
+  WHEN name="Alexander" and points=1000
+  THEN German: "Spieler Alexander hat 1.000 Punkte erzielt"
+  AND text fits UI element
+  AND variables are correctly formatted for locale
+
+SCENARIO: Plural Forms
+  GIVEN English "1 coin" / "5 coins"
+  WHEN displaying in Polish (4 plural forms)
+  THEN correct plural form is used
+  AND all plural forms are translated
+```
+
+### Character Support
+
+```
+SCENARIO: CJK Character Rendering
+  GIVEN Japanese localization
+  WHEN displaying text with kanji/hiragana/katakana
+  THEN all characters render correctly
+  AND no missing glyphs (tofu boxes)
+  AND line breaks respect CJK rules
+
+SCENARIO: Special Characters
+  GIVEN text with accented characters (é, ñ, ü)
+  WHEN displayed in-game
+  THEN all characters render correctly
+  AND sorting works correctly
+
+SCENARIO: User-Generated Content
+  GIVEN player can name character
+  WHEN name includes non-Latin characters
+  THEN name displays correctly
+  AND name saves/loads correctly
+  AND name appears correctly to other players
+```
+
+### Layout and Direction
+
+```
+SCENARIO: Right-to-Left Layout
+  GIVEN Arabic localization
+  WHEN viewing UI
+  THEN text reads right-to-left
+  AND UI elements mirror appropriately
+  AND numbers remain left-to-right
+  AND mixed content (Arabic + English) displays correctly
+
+SCENARIO: Text Expansion Accommodation
+  GIVEN English UI "OK" / "Cancel" buttons
+  WHEN localized to German "OK" / "Abbrechen"
+  THEN button expands or text size adjusts
+  AND button remains clickable
+  AND layout doesn't break
+```
+
+## Locale-Specific Formatting
+
+### Date and Time
+
+| Locale | Date Format    | Time Format |
+| ------ | -------------- | ----------- |
+| en-US  | 12/25/2024     | 3:30 PM     |
+| en-GB  | 25/12/2024     | 15:30       |
+| de-DE  | 25.12.2024     | 15:30 Uhr   |
+| ja-JP  | 2024年12月25日 | 15時30分    |
+
+### Numbers and Currency
+
+| Locale | Number   | Currency   |
+| ------ | -------- | ---------- |
+| en-US  | 1,234.56 | $1,234.56  |
+| de-DE  | 1.234,56 | 1.234,56 € |
+| fr-FR  | 1 234,56 | 1 234,56 € |
+| ja-JP  | 1,234.56 | ¥1,235     |
+
+## Automated Test Examples
+
+### Unity
+
+```csharp
+using UnityEngine.Localization;
+
+[Test]
+public void Localization_AllKeysHaveTranslations([Values("en", "de", "ja", "zh-CN")] string locale)
+{
+    var stringTable = LocalizationSettings.StringDatabase
+        .GetTable("GameStrings", new Locale(locale));
+
+    foreach (var entry in stringTable)
+    {
+        Assert.IsFalse(string.IsNullOrEmpty(entry.Value.LocalizedValue),
+            $"Missing translation for '{entry.Key}' in {locale}");
+    }
+}
+
+[Test]
+public void TextFits_AllUIElements()
+{
+    var languages = new[] { "en", "de", "fr", "ja" };
+
+    foreach (var lang in languages)
+    {
+        LocalizationSettings.SelectedLocale = new Locale(lang);
+
+        foreach (var textElement in FindObjectsOfType<LocalizedText>())
+        {
+            var rectTransform = textElement.GetComponent<RectTransform>();
+            var textComponent = textElement.GetComponent<Text>();
+
+            Assert.LessOrEqual(
+                textComponent.preferredWidth,
+                rectTransform.rect.width,
+                $"Text overflows in {lang}: {textElement.name}");
+        }
+    }
+}
+
+[TestCase("en", 1, "1 coin")]
+[TestCase("en", 5, "5 coins")]
+[TestCase("ru", 1, "1 монета")]
+[TestCase("ru", 2, "2 монеты")]
+[TestCase("ru", 5, "5 монет")]
+public void Pluralization_ReturnsCorrectForm(string locale, int count, string expected)
+{
+    var result = Localization.GetPlural("coin", count, locale);
+    Assert.AreEqual(expected, result);
+}
+```
+
+### Unreal
+
+```cpp
+bool FLocalizationTest::RunTest(const FString& Parameters)
+{
+    TArray<FString> Cultures = {"en", "de", "ja", "ko"};
+
+    for (const FString& Culture : Cultures)
+    {
+        FInternationalization::Get().SetCurrentCulture(Culture);
+
+        // Test critical strings exist
+        FText LocalizedText = NSLOCTEXT("Game", "StartButton", "Start");
+        TestFalse(
+            FString::Printf(TEXT("Missing StartButton in %s"), *Culture),
+            LocalizedText.IsEmpty());
+
+        // Test number formatting
+        FText NumberText = FText::AsNumber(1234567);
+        TestTrue(
+            TEXT("Number should be formatted"),
+            NumberText.ToString().Len() > 7); // Has separators
+    }
+
+    return true;
+}
+```
+
+### Godot
+
+```gdscript
+func test_all_translations_complete():
+    var locales = ["en", "de", "ja", "es"]
+    var keys = TranslationServer.get_all_keys()
+
+    for locale in locales:
+        TranslationServer.set_locale(locale)
+        for key in keys:
+            var translated = tr(key)
+            assert_ne(translated, key,
+                "Missing translation for '%s' in %s" % [key, locale])
+
+func test_plural_forms():
+    TranslationServer.set_locale("ru")
+
+    assert_eq(tr_n("coin", "coins", 1), "1 монета")
+    assert_eq(tr_n("coin", "coins", 2), "2 монеты")
+    assert_eq(tr_n("coin", "coins", 5), "5 монет")
+    assert_eq(tr_n("coin", "coins", 21), "21 монета")
+
+func test_text_fits_buttons():
+    var locales = ["en", "de", "fr"]
+
+    for locale in locales:
+        TranslationServer.set_locale(locale)
+        await get_tree().process_frame  # Allow UI update
+
+        for button in get_tree().get_nodes_in_group("localized_buttons"):
+            var label = button.get_node("Label")
+            assert_lt(label.size.x, button.size.x,
+                "Button text overflows in %s: %s" % [locale, button.name])
+```
+
+## Visual Verification Checklist
+
+### Text Display
+
+- [ ] No truncation in any language
+- [ ] Consistent font sizing
+- [ ] Proper line breaks
+- [ ] No overlapping text
+
+### UI Layout
+
+- [ ] Buttons accommodate longer text
+- [ ] Dialog boxes resize appropriately
+- [ ] Menu items align correctly
+- [ ] Scrollbars appear when needed
+
+### Cultural Elements
+
+- [ ] Icons are culturally appropriate
+- [ ] Colors don't have negative connotations
+- [ ] Gestures are region-appropriate
+- [ ] No unintended political references
+
+## Regional Compliance
+
+### Ratings Requirements
+
+| Region        | Rating Board | Special Requirements      |
+| ------------- | ------------ | ------------------------- |
+| North America | ESRB         | Content descriptors       |
+| Europe        | PEGI         | Age-appropriate icons     |
+| Japan         | CERO         | Strict content guidelines |
+| Germany       | USK          | Violence restrictions     |
+| China         | GRAC         | Approval process          |
+
+### Common Regional Issues
+
+| Issue            | Regions Affected | Solution                 |
+| ---------------- | ---------------- | ------------------------ |
+| Blood color      | Japan, Germany   | Option for green/disable |
+| Gambling imagery | Many regions     | Remove or modify         |
+| Skulls/bones     | China            | Alternative designs      |
+| Nazi imagery     | Germany          | Remove entirely          |
+
+## Best Practices
+
+### DO
+
+- Test with native speakers
+- Plan for text expansion (reserve 30% extra space)
+- Use placeholder text during development (Lorem ipsum-style)
+- Support multiple input methods (IME for CJK)
+- Test all language combinations (UI language + audio language)
+- Validate string format parameters
+
+### DON'T
+
+- Hard-code strings in source code
+- Assume left-to-right layout
+- Concatenate translated strings
+- Use machine translation without review
+- Forget about date/time/number formatting
+- Ignore cultural context of images and icons

src/modules/bmgd/gametest/knowledge/multiplayer-testing.md

@@ -0,0 +1,322 @@
+# Multiplayer Testing Guide
+
+## Overview
+
+Multiplayer testing validates network code, synchronization, and the player experience under real-world conditions. Network bugs are notoriously hard to reproduce—systematic testing is essential.
+
+## Test Categories
+
+### Synchronization Testing
+
+| Test Type           | Description                              | Priority |
+| ------------------- | ---------------------------------------- | -------- |
+| State sync          | All clients see consistent game state    | P0       |
+| Position sync       | Character positions match across clients | P0       |
+| Event ordering      | Actions occur in correct sequence        | P0       |
+| Conflict resolution | Simultaneous actions handled correctly   | P1       |
+| Late join           | New players sync correctly mid-game      | P1       |
+
+### Network Conditions
+
+| Condition       | Simulation Method | Test Focus               |
+| --------------- | ----------------- | ------------------------ |
+| High latency    | 200-500ms delay   | Input responsiveness     |
+| Packet loss     | 5-20% drop rate   | State recovery           |
+| Jitter          | Variable delay    | Interpolation smoothness |
+| Bandwidth limit | Throttle to 1Mbps | Data prioritization      |
+| Disconnection   | Kill connection   | Reconnection handling    |
+
+## Test Scenarios
+
+### Basic Multiplayer
+
+```
+SCENARIO: Player Join/Leave
+  GIVEN host has started multiplayer session
+  WHEN Player 2 joins
+  THEN Player 2 appears in host's game
+  AND Player 1 appears in Player 2's game
+  AND player counts sync across all clients
+
+SCENARIO: State Synchronization
+  GIVEN 4 players in match
+  WHEN Player 1 picks up item at position (10, 5)
+  THEN item disappears for all players
+  AND Player 1's inventory updates for all players
+  AND no duplicate pickups possible
+
+SCENARIO: Combat Synchronization
+  GIVEN Player 1 attacks Player 2
+  WHEN attack hits
+  THEN damage is consistent on all clients
+  AND hit effects play for all players
+  AND health updates sync within 100ms
+```
+
+### Network Degradation
+
+```
+SCENARIO: High Latency Gameplay
+  GIVEN 200ms latency between players
+  WHEN Player 1 moves forward
+  THEN movement is smooth on Player 1's screen
+  AND other players see interpolated movement
+  AND position converges within 500ms
+
+SCENARIO: Packet Loss Recovery
+  GIVEN 10% packet loss
+  WHEN important game event occurs (goal, kill, etc.)
+  THEN event is eventually delivered
+  AND game state remains consistent
+  AND no duplicate events processed
+
+SCENARIO: Player Disconnection
+  GIVEN Player 2 disconnects unexpectedly
+  WHEN 5 seconds pass
+  THEN other players are notified
+  AND Player 2's character handles gracefully (despawn/AI takeover)
+  AND game continues without crash
+```
+
+### Edge Cases
+
+```
+SCENARIO: Simultaneous Actions
+  GIVEN Player 1 and Player 2 grab same item simultaneously
+  WHEN both inputs arrive at server
+  THEN only one player receives item
+  AND other player sees consistent state
+  AND no item duplication
+
+SCENARIO: Host Migration
+  GIVEN host disconnects
+  WHEN migration begins
+  THEN new host is selected
+  AND game state transfers correctly
+  AND gameplay resumes within 10 seconds
+
+SCENARIO: Reconnection
+  GIVEN Player 2 disconnects temporarily
+  WHEN Player 2 reconnects within 60 seconds
+  THEN Player 2 rejoins same session
+  AND state is synchronized
+  AND progress is preserved
+```
+
+## Network Simulation Tools
+
+### Unity
+
+```csharp
+// Using Unity Transport with Network Simulator
+using Unity.Netcode;
+
+public class NetworkSimulator : MonoBehaviour
+{
+    [SerializeField] private int latencyMs = 100;
+    [SerializeField] private float packetLossPercent = 5f;
+    [SerializeField] private int jitterMs = 20;
+
+    void Start()
+    {
+        var transport = NetworkManager.Singleton.GetComponent<UnityTransport>();
+        var simulator = transport.GetSimulatorParameters();
+
+        simulator.PacketDelayMS = latencyMs;
+        simulator.PacketDropRate = (int)(packetLossPercent * 100);
+        simulator.PacketJitterMS = jitterMs;
+    }
+}
+
+// Test
+[UnityTest]
+public IEnumerator Position_UnderLatency_ConvergesWithinThreshold()
+{
+    EnableNetworkSimulation(latencyMs: 200);
+
+    // Move player
+    player1.Move(Vector3.forward * 10);
+
+    yield return new WaitForSeconds(1f);
+
+    // Check other client's view
+    var player1OnClient2 = client2.GetPlayerPosition(player1.Id);
+    var actualPosition = player1.transform.position;
+
+    Assert.Less(Vector3.Distance(player1OnClient2, actualPosition), 0.5f);
+}
+```
+
+### Unreal
+
+```cpp
+// Using Network Emulation
+void UNetworkTestHelper::EnableLatencySimulation(int32 LatencyMs)
+{
+    if (UNetDriver* NetDriver = GetWorld()->GetNetDriver())
+    {
+        FPacketSimulationSettings Settings;
+        Settings.PktLag = LatencyMs;
+        Settings.PktLagVariance = LatencyMs / 10;
+        Settings.PktLoss = 0;
+
+        NetDriver->SetPacketSimulationSettings(Settings);
+    }
+}
+
+// Functional test for sync
+void AMultiplayerSyncTest::StartTest()
+{
+    Super::StartTest();
+
+    // Spawn item on server
+    APickupItem* Item = GetWorld()->SpawnActor<APickupItem>(
+        ItemClass, FVector(0, 0, 100));
+
+    // Wait for replication
+    FTimerHandle TimerHandle;
+    GetWorld()->GetTimerManager().SetTimer(TimerHandle, [this, Item]()
+    {
+        // Verify client has item
+        if (VerifyItemExistsOnAllClients(Item))
+        {
+            FinishTest(EFunctionalTestResult::Succeeded, "Item replicated");
+        }
+        else
+        {
+            FinishTest(EFunctionalTestResult::Failed, "Item not found on clients");
+        }
+    }, 2.0f, false);
+}
+```
+
+### Godot
+
+```gdscript
+# Network simulation
+extends Node
+
+var simulated_latency_ms := 0
+var packet_loss_percent := 0.0
+
+func _ready():
+    # Hook into network to simulate conditions
+    multiplayer.peer_packet_received.connect(_on_packet_received)
+
+func _on_packet_received(id: int, packet: PackedByteArray):
+    if packet_loss_percent > 0 and randf() < packet_loss_percent / 100:
+        return  # Drop packet
+
+    if simulated_latency_ms > 0:
+        await get_tree().create_timer(simulated_latency_ms / 1000.0).timeout
+
+    _process_packet(id, packet)
+
+# Test
+func test_position_sync_under_latency():
+    NetworkSimulator.simulated_latency_ms = 200
+
+    # Move player on host
+    host_player.position = Vector3(100, 0, 100)
+
+    await get_tree().create_timer(1.0).timeout
+
+    # Check client view
+    var client_view_position = client.get_remote_player_position(host_player.id)
+    var distance = host_player.position.distance_to(client_view_position)
+
+    assert_lt(distance, 1.0, "Position should converge within 1 unit")
+```
+
+## Dedicated Server Testing
+
+### Test Matrix
+
+| Scenario              | Test Focus                           |
+| --------------------- | ------------------------------------ |
+| Server startup        | Clean initialization, port binding   |
+| Client authentication | Login validation, session management |
+| Server tick rate      | Consistent updates under load        |
+| Maximum players       | Performance at player cap            |
+| Server crash recovery | State preservation, reconnection     |
+
+### Load Testing
+
+```
+SCENARIO: Maximum Players
+  GIVEN server configured for 64 players
+  WHEN 64 players connect
+  THEN all connections succeed
+  AND server tick rate stays above 60Hz
+  AND latency stays below 50ms
+
+SCENARIO: Stress Test
+  GIVEN 64 players performing actions simultaneously
+  WHEN running for 10 minutes
+  THEN no memory leaks
+  AND no desync events
+  AND server CPU below 80%
+```
+
+## Matchmaking Testing
+
+```
+SCENARIO: Skill-Based Matching
+  GIVEN players with skill ratings [1000, 1050, 2000, 2100]
+  WHEN matchmaking runs
+  THEN [1000, 1050] are grouped together
+  AND [2000, 2100] are grouped together
+
+SCENARIO: Region Matching
+  GIVEN players from US-East, US-West, EU
+  WHEN matchmaking runs
+  THEN players prefer same-region matches
+  AND cross-region only when necessary
+  AND latency is acceptable for all players
+
+SCENARIO: Queue Timeout
+  GIVEN player waiting in queue
+  WHEN 3 minutes pass without match
+  THEN matchmaking expands search criteria
+  AND player is notified of expanded search
+```
+
+## Security Testing
+
+| Vulnerability    | Test Method                 |
+| ---------------- | --------------------------- |
+| Speed hacking    | Validate movement on server |
+| Teleportation    | Check position delta limits |
+| Damage hacking   | Server-authoritative damage |
+| Packet injection | Validate packet checksums   |
+| Replay attacks   | Use unique session tokens   |
+
+## Performance Metrics
+
+| Metric                | Good      | Acceptable | Poor       |
+| --------------------- | --------- | ---------- | ---------- |
+| Round-trip latency    | < 50ms    | < 100ms    | > 150ms    |
+| Sync delta            | < 100ms   | < 200ms    | > 500ms    |
+| Packet loss tolerance | < 5%      | < 10%      | > 15%      |
+| Bandwidth per player  | < 10 KB/s | < 50 KB/s  | > 100 KB/s |
+| Server tick rate      | 60+ Hz    | 30+ Hz     | < 20 Hz    |
+
+## Best Practices
+
+### DO
+
+- Test with real network conditions, not just localhost
+- Simulate worst-case scenarios (high latency + packet loss)
+- Use server-authoritative design for competitive games
+- Implement lag compensation for fast-paced games
+- Test host migration paths
+- Log network events for debugging
+
+### DON'T
+
+- Trust client data for important game state
+- Assume stable connections
+- Skip testing with maximum player counts
+- Ignore edge cases (simultaneous actions)
+- Test only in ideal network conditions
+- Forget to test reconnection flows

src/modules/bmgd/gametest/knowledge/performance-testing.md

@@ -0,0 +1,204 @@
+# Performance Testing for Games
+
+## Overview
+
+Performance testing ensures your game runs smoothly on target hardware. Frame rate, load times, and memory usage directly impact player experience.
+
+## Key Performance Metrics
+
+### Frame Rate
+
+- **Target:** 30fps, 60fps, 120fps depending on platform/genre
+- **Measure:** Average, minimum, 1% low, 0.1% low
+- **Goal:** Consistent frame times, no stutters
+
+### Frame Time Budget
+
+At 60fps, you have 16.67ms per frame:
+
+```
+Rendering:     8ms  (48%)
+Game Logic:    4ms  (24%)
+Physics:       2ms  (12%)
+Audio:         1ms  (6%)
+UI:            1ms  (6%)
+Headroom:      0.67ms (4%)
+```
+
+### Memory
+
+- **RAM:** Total allocation, peak usage, fragmentation
+- **VRAM:** Texture memory, render targets, buffers
+- **Goal:** Stay within platform limits with headroom
+
+### Load Times
+
+- **Initial Load:** Time to main menu
+- **Level Load:** Time between scenes
+- **Streaming:** Asset loading during gameplay
+- **Goal:** Meet platform certification requirements
+
+## Profiling Tools by Engine
+
+### Unity
+
+- **Profiler Window** - CPU, GPU, memory, rendering
+- **Frame Debugger** - Draw call analysis
+- **Memory Profiler** - Heap snapshots
+- **Profile Analyzer** - Compare captures
+
+### Unreal Engine
+
+- **Unreal Insights** - Comprehensive profiling
+- **Stat Commands** - Runtime statistics
+- **GPU Visualizer** - GPU timing breakdown
+- **Memory Report** - Allocation tracking
+
+### Godot
+
+- **Debugger** - Built-in profiler
+- **Monitors** - Real-time metrics
+- **Remote Debugger** - Profile on device
+
+### Platform Tools
+
+- **PIX** (Xbox/Windows) - GPU debugging
+- **RenderDoc** - GPU capture and replay
+- **Instruments** (iOS/macOS) - Apple profiling
+- **Android Profiler** - Android Studio tools
+
+## Performance Testing Process
+
+### 1. Establish Baselines
+
+- Profile on target hardware
+- Record key metrics
+- Create benchmark scenes
+
+### 2. Set Budgets
+
+- Define frame time budgets per system
+- Set memory limits
+- Establish load time targets
+
+### 3. Monitor Continuously
+
+- Integrate profiling in CI
+- Track metrics over time
+- Alert on regressions
+
+### 4. Optimize When Needed
+
+- Profile before optimizing
+- Target biggest bottlenecks
+- Verify improvements
+
+## Common Performance Issues
+
+### CPU Bottlenecks
+
+| Issue                 | Symptoms          | Solution                          |
+| --------------------- | ----------------- | --------------------------------- |
+| Too many game objects | Slow update loop  | Object pooling, LOD               |
+| Expensive AI          | Spiky frame times | Budget AI, spread over frames     |
+| Physics overload      | Physics spikes    | Simplify colliders, reduce bodies |
+| GC stutter            | Regular hitches   | Avoid runtime allocations         |
+
+### GPU Bottlenecks
+
+| Issue               | Symptoms          | Solution                         |
+| ------------------- | ----------------- | -------------------------------- |
+| Overdraw            | Fill rate limited | Occlusion culling, reduce layers |
+| Too many draw calls | CPU-GPU bound     | Batching, instancing, atlasing   |
+| Shader complexity   | Long GPU times    | Simplify shaders, LOD            |
+| Resolution too high | Fill rate limited | Dynamic resolution, FSR/DLSS     |
+
+### Memory Issues
+
+| Issue         | Symptoms          | Solution                     |
+| ------------- | ----------------- | ---------------------------- |
+| Texture bloat | High VRAM         | Compress, mipmap, stream     |
+| Leaks         | Growing memory    | Track allocations, fix leaks |
+| Fragmentation | OOM despite space | Pool allocations, defrag     |
+
+## Benchmark Scenes
+
+Create standardized test scenarios:
+
+### Stress Test Scene
+
+- Maximum entities on screen
+- Complex visual effects
+- Worst-case for performance
+
+### Typical Gameplay Scene
+
+- Representative of normal play
+- Average entity count
+- Baseline for comparison
+
+### Isolated System Tests
+
+- Combat only (no rendering)
+- Rendering only (no game logic)
+- AI only (pathfinding stress)
+
+## Automated Performance Testing
+
+### CI Integration
+
+```yaml
+# Example: Fail build if frame time exceeds budget
+performance_test:
+  script:
+    - run_benchmark --scene stress_test
+    - check_metrics --max-frame-time 16.67ms --max-memory 2GB
+  artifacts:
+    - performance_report.json
+```
+
+### Regression Detection
+
+- Compare against previous builds
+- Alert on significant changes (>10%)
+- Track trends over time
+
+## Platform-Specific Considerations
+
+### Console
+
+- Fixed hardware targets
+- Strict certification requirements
+- Thermal throttling concerns
+
+### PC
+
+- Wide hardware range
+- Scalable quality settings
+- Min/recommended specs
+
+### Mobile
+
+- Thermal throttling
+- Battery impact
+- Memory constraints
+- Background app pressure
+
+## Performance Testing Checklist
+
+### Before Release
+
+- [ ] Profiled on all target platforms
+- [ ] Frame rate targets met
+- [ ] No memory leaks
+- [ ] Load times acceptable
+- [ ] No GC stutters in gameplay
+- [ ] Thermal tests passed (mobile/console)
+- [ ] Certification requirements met
+
+### Ongoing
+
+- [ ] Performance tracked in CI
+- [ ] Regression alerts configured
+- [ ] Benchmark scenes maintained
+- [ ] Budgets documented and enforced

src/modules/bmgd/gametest/knowledge/playtesting.md

@@ -0,0 +1,384 @@
+# Playtesting Fundamentals
+
+## Overview
+
+Playtesting is the process of having people play your game to gather feedback and identify issues. It's distinct from QA testing in that it focuses on player experience, fun factor, and design validation rather than bug hunting.
+
+## Types of Playtesting
+
+### Internal Playtesting
+
+- **Developer Testing** - Daily testing during development
+- **Team Testing** - Cross-discipline team plays together
+- **Best for:** Rapid iteration, catching obvious issues
+
+### External Playtesting
+
+- **Friends & Family** - Trusted external testers
+- **Focus Groups** - Targeted demographic testing
+- **Public Beta** - Large-scale community testing
+- **Best for:** Fresh perspectives, UX validation
+
+### Specialized Playtesting
+
+- **Accessibility Testing** - Players with disabilities
+- **Localization Testing** - Regional/cultural validation
+- **Competitive Testing** - Balance and meta testing
+
+## Playtesting Process
+
+### 1. Define Goals
+
+Before each playtest session, define:
+
+- What questions are you trying to answer?
+- What features are you testing?
+- What metrics will you gather?
+
+### 2. Prepare the Build
+
+- Create a stable, playable build
+- Include telemetry/logging if needed
+- Prepare any necessary documentation
+
+### 3. Brief Testers
+
+- Explain what to test (or don't, for blind testing)
+- Set expectations for bugs/polish level
+- Provide feedback mechanisms
+
+### 4. Observe and Record
+
+- Watch players without intervening
+- Note confusion points, frustration, delight
+- Record gameplay if possible
+
+### 5. Gather Feedback
+
+- Structured surveys for quantitative data
+- Open discussion for qualitative insights
+- Allow time for "what else?" comments
+
+### 6. Analyze and Act
+
+- Identify patterns across testers
+- Prioritize issues by frequency and severity
+- Create actionable tasks from findings
+
+## Key Metrics to Track
+
+### Engagement Metrics
+
+- Session length
+- Return rate
+- Completion rate
+- Drop-off points
+
+### Difficulty Metrics
+
+- Deaths/failures per section
+- Time to complete sections
+- Hint/help usage
+- Difficulty setting distribution
+
+### UX Metrics
+
+- Time to first action
+- Tutorial completion rate
+- Menu navigation patterns
+- Control scheme preferences
+
+## Playtesting by Game Type
+
+Different genres require different playtesting approaches and focus areas.
+
+### Action/Platformer Games
+
+**Focus Areas:**
+
+- Control responsiveness and "game feel"
+- Difficulty curve across levels
+- Checkpoint placement and frustration points
+- Visual clarity during fast-paced action
+
+**Key Questions:**
+
+- Does the character feel good to control?
+- Are deaths feeling fair or cheap?
+- Is the player learning organically or hitting walls?
+
+### RPG/Story Games
+
+**Focus Areas:**
+
+- Narrative pacing and engagement
+- Quest clarity and tracking
+- Character/dialogue believability
+- Progression and reward timing
+
+**Key Questions:**
+
+- Do players understand their current objective?
+- Are choices feeling meaningful?
+- Is the story holding attention or being skipped?
+
+### Puzzle Games
+
+**Focus Areas:**
+
+- Solution discoverability
+- "Aha moment" timing
+- Hint system effectiveness
+- Difficulty progression
+
+**Key Questions:**
+
+- Are players solving puzzles the intended way?
+- How long before frustration sets in?
+- Do solutions feel satisfying or arbitrary?
+
+### Multiplayer/Competitive Games
+
+**Focus Areas:**
+
+- Balance across characters/builds/strategies
+- Meta development and dominant strategies
+- Social dynamics and toxicity vectors
+- Matchmaking feel
+
+**Key Questions:**
+
+- Are there "must-pick" or "never-pick" options?
+- Do losing players understand why they lost?
+- Is the skill ceiling high enough for mastery?
+
+### Survival/Sandbox Games
+
+**Focus Areas:**
+
+- Early game onboarding and survival
+- Goal clarity vs. freedom balance
+- Resource economy and pacing
+- Emergent gameplay moments
+
+**Key Questions:**
+
+- Do players know what to do first?
+- Is the loop engaging beyond the first hour?
+- Are players creating their own goals?
+
+### Mobile/Casual Games
+
+**Focus Areas:**
+
+- Session length appropriateness
+- One-hand playability (if applicable)
+- Interruption handling (calls, notifications)
+- Monetization friction points
+
+**Key Questions:**
+
+- Can players play in 2-minute sessions?
+- Is the core loop immediately understandable?
+- Where do players churn?
+
+### Horror Games
+
+**Focus Areas:**
+
+- Tension and release pacing
+- Scare effectiveness and desensitization
+- Safe space placement
+- Audio/visual atmosphere
+
+**Key Questions:**
+
+- When do players feel safe vs. threatened?
+- Are scares landing or becoming predictable?
+- Is anxiety sustainable or exhausting?
+
+## Processing Feedback Effectively
+
+Raw feedback is noise. Processed feedback is signal.
+
+### The Feedback Processing Pipeline
+
+```
+Raw Feedback → Categorize → Pattern Match → Root Cause → Prioritize → Action
+```
+
+### Step 1: Categorize Feedback
+
+Sort all feedback into buckets:
+
+| Category      | Examples                           |
+| ------------- | ---------------------------------- |
+| **Bugs**      | Crashes, glitches, broken features |
+| **Usability** | Confusing UI, unclear objectives   |
+| **Balance**   | Too hard, too easy, unfair         |
+| **Feel**      | Controls, pacing, satisfaction     |
+| **Content**   | Wants more of X, dislikes Y        |
+| **Polish**    | Audio, visuals, juice              |
+
+### Step 2: Pattern Matching
+
+Individual feedback is anecdotal. Patterns are data.
+
+**Threshold Guidelines:**
+
+- 1 person mentions it → Note it
+- 3+ people mention it → Investigate
+- 50%+ mention it → Priority issue
+
+**Watch for:**
+
+- Same complaint, different words
+- Same area, different complaints (signals deeper issue)
+- Contradictory feedback (may indicate preference split)
+
+### Step 3: Root Cause Analysis
+
+Players report symptoms, not diseases.
+
+**Example:**
+
+- **Symptom:** "The boss is too hard"
+- **Possible Root Causes:**
+  - Boss mechanics unclear
+  - Player didn't learn required skill earlier
+  - Checkpoint too far from boss
+  - Health/damage tuning off
+  - Boss pattern has no safe windows
+
+**Ask "Why?" five times** to get to root cause.
+
+### Step 4: Separate Fact from Opinion
+
+| Fact (Actionable)                 | Opinion (Context)       |
+| --------------------------------- | ----------------------- |
+| "I died 12 times on level 3"      | "Level 3 is too hard"   |
+| "I didn't use the shield ability" | "The shield is useless" |
+| "I quit after 20 minutes"         | "The game is boring"    |
+
+**Facts tell you WHAT happened. Opinions tell you how they FELT about it.**
+
+Both matter, but facts drive solutions.
+
+### Step 5: The Feedback Matrix
+
+Plot issues on impact vs. effort:
+
+```
+        High Impact
+             │
+   Quick     │    Major
+   Wins      │    Projects
+             │
+─────────────┼─────────────
+             │
+   Fill      │    Reconsider
+   Time      │
+             │
+        Low Impact
+   Low Effort ──────── High Effort
+```
+
+### Step 6: Validate Before Acting
+
+Before making changes based on feedback:
+
+1. **Reproduce** - Can you see the issue yourself?
+2. **Quantify** - How many players affected?
+3. **Contextualize** - Is this your target audience?
+4. **Test solutions** - Will the fix create new problems?
+
+### Handling Contradictory Feedback
+
+When Player A wants X and Player B wants the opposite:
+
+1. **Check sample size** - Is it really split or just 2 loud voices?
+2. **Segment audiences** - Are these different player types?
+3. **Find the underlying need** - Both may want the same thing differently
+4. **Consider options** - Difficulty settings, toggles, multiple paths
+5. **Make a decision** - You can't please everyone; know your target
+
+### Feedback Red Flags
+
+**Dismiss or investigate carefully:**
+
+- "Make it like [other game]" - They want a feeling, not a clone
+- "Add multiplayer" - Feature creep disguised as feedback
+- "I would have bought it if..." - Hypothetical customers aren't real
+- Feedback from non-target audience - Know who you're building for
+
+**Take seriously:**
+
+- Confusion about core mechanics
+- Consistent drop-off at same point
+- "I wanted to like it but..."
+- Silent quitting (no feedback, just gone)
+
+### Documentation Best Practices
+
+**For each playtest session, record:**
+
+- Date and build version
+- Tester demographics/experience
+- Session length
+- Key observations (timestamped if recorded)
+- Quantitative survey results
+- Top 3 issues identified
+- Actions taken as result
+
+**Maintain a living document** that tracks:
+
+- Issue → First reported → Times reported → Status → Resolution
+- This prevents re-discovering the same issues
+
+## Common Playtesting Pitfalls
+
+### Leading Questions
+
+**Bad:** "Did you find the combat exciting?"
+**Good:** "How would you describe the combat?"
+
+### Intervening Too Soon
+
+Let players struggle before helping. Confusion is valuable data.
+
+### Testing Too Late
+
+Start playtesting early with paper prototypes and gray boxes.
+
+### Ignoring Negative Feedback
+
+Negative feedback is often the most valuable. Don't dismiss it.
+
+### Over-Relying on Verbal Feedback
+
+Watch what players DO, not just what they SAY. Actions reveal truth.
+
+## Playtesting Checklist
+
+### Pre-Session
+
+- [ ] Goals defined
+- [ ] Build stable and deployed
+- [ ] Recording setup (if applicable)
+- [ ] Feedback forms ready
+- [ ] Testers briefed
+
+### During Session
+
+- [ ] Observing without intervening
+- [ ] Taking notes on behavior
+- [ ] Tracking time markers for notable moments
+- [ ] Noting emotional reactions
+
+### Post-Session
+
+- [ ] Feedback collected
+- [ ] Patterns identified
+- [ ] Priority issues flagged
+- [ ] Action items created
+- [ ] Results shared with team

src/modules/bmgd/gametest/knowledge/qa-automation.md

@@ -0,0 +1,190 @@
+# QA Automation for Games
+
+## Overview
+
+Automated testing in games requires different approaches than traditional software. Games have complex state, real-time interactions, and subjective quality measures that challenge automation.
+
+## Testing Pyramid for Games
+
+```
+        /\
+       /  \     Manual Playtesting
+      /----\    (Experience, Feel, Fun)
+     /      \
+    /--------\  Integration Tests
+   /          \ (Systems, Workflows)
+  /------------\
+ /              \ Unit Tests
+/________________\ (Pure Logic, Math, Data)
+```
+
+### Unit Tests (Foundation)
+
+Test pure logic that doesn't depend on engine runtime:
+
+- Math utilities (vectors, transforms, curves)
+- Data validation (save files, configs)
+- State machines (isolated logic)
+- Algorithm correctness
+
+### Integration Tests (Middle Layer)
+
+Test system interactions:
+
+- Combat system + inventory
+- Save/load round-trips
+- Scene transitions
+- Network message handling
+
+### Manual Testing (Top)
+
+What can't be automated:
+
+- "Does this feel good?"
+- "Is this fun?"
+- "Is the difficulty right?"
+
+## Automation Strategies by Engine
+
+### Unity
+
+```csharp
+// Unity Test Framework
+[Test]
+public void DamageCalculation_CriticalHit_DoublesDamage()
+{
+    var baseDamage = 100;
+    var result = DamageCalculator.Calculate(baseDamage, isCritical: true);
+    Assert.AreEqual(200, result);
+}
+
+// Play Mode Tests (runtime)
+[UnityTest]
+public IEnumerator PlayerJump_WhenGrounded_BecomesAirborne()
+{
+    var player = CreateTestPlayer();
+    player.Jump();
+    yield return new WaitForFixedUpdate();
+    Assert.IsFalse(player.IsGrounded);
+}
+```
+
+### Unreal Engine
+
+```cpp
+// Automation Framework
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FDamageTest, "Game.Combat.Damage",
+    EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::ProductFilter)
+
+bool FDamageTest::RunTest(const FString& Parameters)
+{
+    float BaseDamage = 100.f;
+    float Result = UDamageCalculator::Calculate(BaseDamage, true);
+    TestEqual("Critical hit doubles damage", Result, 200.f);
+    return true;
+}
+```
+
+### Godot
+
+```gdscript
+# GUT Testing Framework
+func test_damage_critical_hit():
+    var base_damage = 100
+    var result = DamageCalculator.calculate(base_damage, true)
+    assert_eq(result, 200, "Critical hit should double damage")
+```
+
+## What to Automate
+
+### High Value Targets
+
+- **Save/Load** - Data integrity is critical
+- **Economy** - Currency, items, progression math
+- **Combat Math** - Damage, stats, modifiers
+- **Localization** - String loading, formatting
+- **Network Serialization** - Message encoding/decoding
+
+### Medium Value Targets
+
+- **State Machines** - Character states, game states
+- **Pathfinding** - Known scenarios
+- **Spawning** - Wave generation, loot tables
+- **UI Data Binding** - Correct values displayed
+
+### Low Value / Avoid
+
+- **Visual Quality** - Screenshots drift, hard to maintain
+- **Input Feel** - Timing-sensitive, needs human judgment
+- **Audio** - Subjective, context-dependent
+- **Fun** - Cannot be automated
+
+## Continuous Integration for Games
+
+### Build Pipeline
+
+1. **Compile** - Build game executable
+2. **Unit Tests** - Fast, isolated tests
+3. **Integration Tests** - Longer, system tests
+4. **Smoke Test** - Can the game launch and reach main menu?
+5. **Nightly** - Extended test suites, performance benchmarks
+
+### CI Gotchas for Games
+
+- **Long build times** - Games take longer than web apps
+- **GPU requirements** - Some tests need graphics hardware
+- **Asset dependencies** - Large files, binary formats
+- **Platform builds** - Multiple targets to maintain
+
+## Regression Testing
+
+### Automated Regression
+
+- Run full test suite on every commit
+- Flag performance regressions (frame time, memory)
+- Track test stability (flaky tests)
+
+### Save File Regression
+
+- Maintain library of save files from previous versions
+- Test that new builds can load old saves
+- Alert on schema changes
+
+## Test Data Management
+
+### Test Fixtures
+
+```
+tests/
+├── fixtures/
+│   ├── save_files/
+│   │   ├── new_game.sav
+│   │   ├── mid_game.sav
+│   │   └── endgame.sav
+│   ├── configs/
+│   │   └── test_balance.json
+│   └── scenarios/
+│       └── boss_fight_setup.scene
+```
+
+### Deterministic Testing
+
+- Seed random number generators
+- Control time/delta time
+- Mock external services
+
+## Metrics and Reporting
+
+### Track Over Time
+
+- Test count (growing is good)
+- Pass rate (should be ~100%)
+- Execution time (catch slow tests)
+- Code coverage (where applicable)
+- Flaky test rate (should be ~0%)
+
+### Alerts
+
+- Immediate: Any test failure on main branch
+- Daily: Coverage drops, new flaky tests
+- Weekly: Trend analysis, slow test growth

src/modules/bmgd/gametest/knowledge/regression-testing.md

@@ -0,0 +1,280 @@
+# Regression Testing for Games
+
+## Overview
+
+Regression testing catches bugs introduced by new changes. In games, this includes functional regressions, performance regressions, and design regressions.
+
+## Types of Regression
+
+### Functional Regression
+
+- Features that worked before now break
+- New bugs introduced by unrelated changes
+- Broken integrations between systems
+
+### Performance Regression
+
+- Frame rate drops
+- Memory usage increases
+- Load time increases
+- Battery drain (mobile)
+
+### Design Regression
+
+- Balance changes with unintended side effects
+- UX changes that hurt usability
+- Art changes that break visual consistency
+
+### Save Data Regression
+
+- Old save files no longer load
+- Progression lost or corrupted
+- Achievements/unlocks reset
+
+## Regression Testing Strategy
+
+### Test Suite Layers
+
+```
+High-Frequency (Every Commit)
+├── Unit Tests - Fast, isolated
+├── Smoke Tests - Can game launch and run?
+└── Critical Path - Core gameplay works
+
+Medium-Frequency (Nightly)
+├── Integration Tests - System interactions
+├── Full Playthrough - Automated or manual
+└── Performance Benchmarks - Frame time, memory
+
+Low-Frequency (Release)
+├── Full Matrix - All platforms/configs
+├── Certification Tests - Platform requirements
+└── Localization - All languages
+```
+
+### What to Test
+
+#### Critical Path (Must Not Break)
+
+- Game launches
+- New game starts
+- Save/load works
+- Core gameplay loop completes
+- Main menu navigation
+
+#### High Priority
+
+- All game systems function
+- Progression works end-to-end
+- Multiplayer connects and syncs
+- In-app purchases process
+- Achievements trigger
+
+#### Medium Priority
+
+- Edge cases in systems
+- Optional content accessible
+- Settings persist correctly
+- Localization displays
+
+## Automated Regression Tests
+
+### Smoke Tests
+
+```python
+# Run on every commit
+def test_game_launches():
+    process = launch_game()
+    assert wait_for_main_menu(timeout=30)
+    process.terminate()
+
+def test_new_game_starts():
+    launch_game()
+    click_new_game()
+    assert wait_for_gameplay(timeout=60)
+
+def test_save_load_roundtrip():
+    launch_game()
+    start_new_game()
+    perform_actions()
+    save_game()
+    load_game()
+    assert verify_state_matches()
+```
+
+### Playthrough Bots
+
+```python
+# Automated player that plays through content
+class PlaythroughBot:
+    def run_level(self, level):
+        self.load_level(level)
+        while not self.level_complete:
+            self.perform_action()
+            self.check_for_softlocks()
+            self.record_metrics()
+```
+
+### Visual Regression
+
+```python
+# Compare screenshots against baselines
+def test_main_menu_visual():
+    launch_game()
+    screenshot = capture_screen()
+    assert compare_to_baseline(screenshot, 'main_menu', threshold=0.01)
+```
+
+## Performance Regression Detection
+
+### Metrics to Track
+
+- Average frame time
+- 1% low frame time
+- Memory usage (peak, average)
+- Load times
+- Draw calls
+- Texture memory
+
+### Automated Benchmarks
+
+```yaml
+performance_benchmark:
+  script:
+    - run_benchmark_scene --duration 60s
+    - collect_metrics
+    - compare_to_baseline
+  fail_conditions:
+    - frame_time_avg > baseline * 1.1 # 10% tolerance
+    - memory_peak > baseline * 1.05 # 5% tolerance
+```
+
+### Trend Tracking
+
+- Graph metrics over time
+- Alert on upward trends
+- Identify problematic commits
+
+## Save Compatibility Testing
+
+### Version Matrix
+
+Maintain save files from:
+
+- Previous major version
+- Previous minor version
+- Current development build
+
+### Automated Validation
+
+```python
+def test_save_compatibility():
+    for save_file in LEGACY_SAVES:
+        load_save(save_file)
+        assert no_errors()
+        assert progress_preserved()
+        assert inventory_intact()
+```
+
+### Schema Versioning
+
+- Version your save format
+- Implement upgrade paths
+- Log migration issues
+
+## Regression Bug Workflow
+
+### 1. Detection
+
+- Automated test fails
+- Manual tester finds issue
+- Player report comes in
+
+### 2. Verification
+
+- Confirm it worked before
+- Identify when it broke
+- Find the breaking commit
+
+### 3. Triage
+
+- Assess severity
+- Determine fix urgency
+- Assign to appropriate developer
+
+### 4. Fix and Verify
+
+- Implement fix
+- Add regression test
+- Verify fix doesn't break other things
+
+### 5. Post-Mortem
+
+- Why wasn't this caught?
+- How can we prevent similar issues?
+- Do we need new tests?
+
+## Bisecting Regressions
+
+When a regression is found, identify the breaking commit:
+
+### Git Bisect
+
+```bash
+git bisect start
+git bisect bad HEAD          # Current is broken
+git bisect good v1.2.0       # Known good version
+# Git will checkout commits to test
+# Run test, mark good/bad
+git bisect good/bad
+# Repeat until culprit found
+```
+
+### Automated Bisect
+
+```bash
+git bisect start HEAD v1.2.0
+git bisect run ./run_regression_test.sh
+```
+
+## Regression Testing Checklist
+
+### Per Commit
+
+- [ ] Unit tests pass
+- [ ] Smoke tests pass
+- [ ] Build succeeds on all platforms
+
+### Per Merge to Main
+
+- [ ] Integration tests pass
+- [ ] Performance benchmarks within tolerance
+- [ ] Save compatibility verified
+
+### Per Release
+
+- [ ] Full playthrough completed
+- [ ] All platforms tested
+- [ ] Legacy saves load correctly
+- [ ] No new critical regressions
+- [ ] All previous hotfix issues still resolved
+
+## Building a Regression Suite
+
+### Start Small
+
+1. Add tests for bugs as they're fixed
+2. Cover critical path first
+3. Expand coverage over time
+
+### Maintain Quality
+
+- Delete flaky tests
+- Keep tests fast
+- Update tests with design changes
+
+### Measure Effectiveness
+
+- Track bugs caught by tests
+- Track bugs that slipped through
+- Identify coverage gaps

src/modules/bmgd/gametest/knowledge/save-testing.md

@@ -0,0 +1,280 @@
+# Save System Testing Guide
+
+## Overview
+
+Save system testing ensures data persistence, integrity, and compatibility across game versions. Save bugs are among the most frustrating for players—data loss destroys trust.
+
+## Test Categories
+
+### Data Integrity
+
+| Test Type            | Description                                 | Priority |
+| -------------------- | ------------------------------------------- | -------- |
+| Round-trip           | Save → Load → Verify all data matches       | P0       |
+| Corruption detection | Tampered/corrupted files handled gracefully | P0       |
+| Partial write        | Power loss during save doesn't corrupt      | P0       |
+| Large saves          | Performance with max-size save files        | P1       |
+| Edge values          | Min/max values for all saved fields         | P1       |
+
+### Version Compatibility
+
+| Scenario                | Expected Behavior                     |
+| ----------------------- | ------------------------------------- |
+| Current → Current       | Full compatibility                    |
+| Old → New (upgrade)     | Migration with data preservation      |
+| New → Old (downgrade)   | Graceful rejection or limited support |
+| Corrupted version field | Fallback to recovery mode             |
+
+## Test Scenarios
+
+### Core Save/Load Tests
+
+```
+SCENARIO: Basic Save Round-Trip
+  GIVEN player has 100 health, 50 gold, position (10, 5, 20)
+  AND player has inventory: ["sword", "potion", "key"]
+  WHEN game is saved
+  AND game is reloaded
+  THEN player health equals 100
+  AND player gold equals 50
+  AND player position equals (10, 5, 20)
+  AND inventory contains exactly ["sword", "potion", "key"]
+
+SCENARIO: Save During Gameplay
+  GIVEN player is in combat
+  AND enemy has 50% health remaining
+  WHEN autosave triggers
+  AND game is reloaded
+  THEN combat state is restored
+  AND enemy health equals 50%
+
+SCENARIO: Multiple Save Slots
+  GIVEN save slot 1 has character "Hero" at level 10
+  AND save slot 2 has character "Mage" at level 5
+  WHEN switching between slots
+  THEN correct character data loads for each slot
+  AND no cross-contamination between slots
+```
+
+### Edge Cases
+
+```
+SCENARIO: Maximum Inventory Save
+  GIVEN player has 999 items in inventory
+  WHEN game is saved
+  AND game is reloaded
+  THEN all 999 items are preserved
+  AND save/load completes within 5 seconds
+
+SCENARIO: Unicode Character Names
+  GIVEN player name is "プレイヤー名"
+  WHEN game is saved
+  AND game is reloaded
+  THEN player name displays correctly
+
+SCENARIO: Extreme Play Time
+  GIVEN play time is 9999:59:59
+  WHEN game is saved
+  AND game is reloaded
+  THEN play time displays correctly
+  AND timer continues from saved value
+```
+
+### Corruption Recovery
+
+```
+SCENARIO: Corrupted Save Detection
+  GIVEN save file has been manually corrupted
+  WHEN game attempts to load
+  THEN error is detected before loading
+  AND user is informed of corruption
+  AND game does not crash
+
+SCENARIO: Missing Save File
+  GIVEN save file has been deleted externally
+  WHEN game attempts to load
+  THEN graceful error handling
+  AND option to start new game or restore backup
+
+SCENARIO: Interrupted Save (Power Loss)
+  GIVEN save operation is interrupted mid-write
+  WHEN game restarts
+  THEN backup save is detected and offered
+  AND no data loss from previous valid save
+```
+
+## Platform-Specific Testing
+
+### PC (Steam/Epic)
+
+- Cloud save sync conflicts
+- Multiple Steam accounts on same PC
+- Offline → Online sync
+- Save location permissions (Program Files issues)
+
+### Console (PlayStation/Xbox/Switch)
+
+- System-level save management
+- Storage full scenarios
+- User switching mid-game
+- Suspend/resume with unsaved changes
+- Cloud save quota limits
+
+### Mobile
+
+- App termination during save
+- Low storage warnings
+- iCloud/Google Play sync
+- Device migration
+
+## Automated Test Examples
+
+### Unity
+
+```csharp
+[Test]
+public void SaveLoad_PlayerStats_PreservesAllValues()
+{
+    var original = new PlayerData
+    {
+        Health = 75,
+        MaxHealth = 100,
+        Gold = 1234567,
+        Position = new Vector3(100.5f, 0, -50.25f),
+        PlayTime = 36000f // 10 hours
+    };
+
+    SaveManager.Save(original, "test_slot");
+    var loaded = SaveManager.Load("test_slot");
+
+    Assert.AreEqual(original.Health, loaded.Health);
+    Assert.AreEqual(original.Gold, loaded.Gold);
+    Assert.AreEqual(original.Position, loaded.Position);
+    Assert.AreEqual(original.PlayTime, loaded.PlayTime, 0.01f);
+}
+
+[Test]
+public void SaveLoad_CorruptedFile_HandlesGracefully()
+{
+    File.WriteAllText(SaveManager.GetPath("corrupt"), "INVALID DATA");
+
+    Assert.Throws<SaveCorruptedException>(() =>
+        SaveManager.Load("corrupt"));
+
+    // Game should not crash
+    Assert.IsTrue(SaveManager.IsValidSaveSlot("corrupt") == false);
+}
+```
+
+### Unreal
+
+```cpp
+bool FSaveSystemTest::RunTest(const FString& Parameters)
+{
+    // Create test save
+    USaveGame* SaveGame = UGameplayStatics::CreateSaveGameObject(
+        UMySaveGame::StaticClass());
+    UMySaveGame* MySave = Cast<UMySaveGame>(SaveGame);
+
+    MySave->PlayerLevel = 50;
+    MySave->Gold = 999999;
+    MySave->QuestsCompleted = {"Quest1", "Quest2", "Quest3"};
+
+    // Save
+    UGameplayStatics::SaveGameToSlot(MySave, "TestSlot", 0);
+
+    // Load
+    USaveGame* Loaded = UGameplayStatics::LoadGameFromSlot("TestSlot", 0);
+    UMySaveGame* LoadedSave = Cast<UMySaveGame>(Loaded);
+
+    TestEqual("Level preserved", LoadedSave->PlayerLevel, 50);
+    TestEqual("Gold preserved", LoadedSave->Gold, 999999);
+    TestEqual("Quests count", LoadedSave->QuestsCompleted.Num(), 3);
+
+    return true;
+}
+```
+
+### Godot
+
+```gdscript
+func test_save_load_round_trip():
+    var original = {
+        "health": 100,
+        "position": Vector3(10, 0, 20),
+        "inventory": ["sword", "shield"],
+        "quest_flags": {"intro_complete": true, "boss_defeated": false}
+    }
+
+    SaveManager.save_game(original, "test_save")
+    var loaded = SaveManager.load_game("test_save")
+
+    assert_eq(loaded.health, 100)
+    assert_eq(loaded.position, Vector3(10, 0, 20))
+    assert_eq(loaded.inventory.size(), 2)
+    assert_true(loaded.quest_flags.intro_complete)
+    assert_false(loaded.quest_flags.boss_defeated)
+
+func test_corrupted_save_detection():
+    var file = FileAccess.open("user://saves/corrupt.sav", FileAccess.WRITE)
+    file.store_string("CORRUPTED GARBAGE DATA")
+    file.close()
+
+    var result = SaveManager.load_game("corrupt")
+
+    assert_null(result, "Should return null for corrupted save")
+    assert_false(SaveManager.is_valid_save("corrupt"))
+```
+
+## Migration Testing
+
+### Version Upgrade Matrix
+
+| From Version   | To Version       | Test Focus                   |
+| -------------- | ---------------- | ---------------------------- |
+| 1.0 → 1.1      | Minor update     | New fields default correctly |
+| 1.x → 2.0      | Major update     | Schema migration works       |
+| Beta → Release | Launch migration | All beta saves convert       |
+
+### Migration Test Template
+
+```
+SCENARIO: Save Migration v1.0 to v2.0
+  GIVEN save file from version 1.0
+  AND save contains old inventory format (array)
+  WHEN game version 2.0 loads the save
+  THEN inventory is migrated to new format (dictionary)
+  AND all items are preserved
+  AND migration is logged
+  AND backup of original is created
+```
+
+## Performance Benchmarks
+
+| Metric                   | Target          | Maximum |
+| ------------------------ | --------------- | ------- |
+| Save time (typical)      | < 500ms         | 2s      |
+| Save time (large)        | < 2s            | 5s      |
+| Load time (typical)      | < 1s            | 3s      |
+| Save file size (typical) | < 1MB           | 10MB    |
+| Memory during save       | < 50MB overhead | 100MB   |
+
+## Best Practices
+
+### DO
+
+- Use atomic saves (write to temp, then rename)
+- Keep backup of previous save
+- Version your save format
+- Encrypt sensitive data
+- Test on minimum-spec hardware
+- Compress large saves
+
+### DON'T
+
+- Store absolute file paths
+- Save derived/calculated data
+- Trust save file contents blindly
+- Block gameplay during save
+- Forget to handle storage-full scenarios
+- Skip testing save migration paths

src/modules/bmgd/gametest/knowledge/smoke-testing.md

@@ -0,0 +1,404 @@
+# Smoke Testing Guide
+
+## Overview
+
+Smoke testing (Build Verification Testing) validates that a build's critical functionality works before investing time in detailed testing. A failed smoke test means "stop, this build is broken."
+
+## Purpose
+
+| Goal                | Description                                    |
+| ------------------- | ---------------------------------------------- |
+| Fast feedback       | Know within minutes if build is viable         |
+| Block bad builds    | Prevent broken builds from reaching QA/players |
+| Critical path focus | Test only what matters most                    |
+| CI/CD integration   | Automated gate before deployment               |
+
+## Smoke Test Principles
+
+### What Makes a Good Smoke Test
+
+- **Fast**: Complete in 5-15 minutes
+- **Critical**: Tests only essential functionality
+- **Deterministic**: Same result every run
+- **Automated**: No human intervention required
+- **Clear**: Pass/fail with actionable feedback
+
+### What to Include
+
+| Category          | Examples                       |
+| ----------------- | ------------------------------ |
+| Boot sequence     | Game launches without crash    |
+| Core loop         | Player can perform main action |
+| Save/Load         | Data persists correctly        |
+| Critical UI       | Menus are navigable            |
+| Platform services | Connects to required services  |
+
+### What NOT to Include
+
+- Edge cases and boundary conditions
+- Performance benchmarks (separate tests)
+- Full feature coverage
+- Content verification
+- Balance testing
+
+## Smoke Test Scenarios
+
+### Boot and Load
+
+```
+TEST: Game Launches
+  WHEN game executable is started
+  THEN main menu appears within 60 seconds
+  AND no crashes occur
+  AND required services connect
+
+TEST: New Game Start
+  GIVEN game at main menu
+  WHEN "New Game" is selected
+  THEN gameplay loads within 30 seconds
+  AND player can control character
+
+TEST: Continue Game
+  GIVEN existing save file
+  WHEN "Continue" is selected
+  THEN correct save loads
+  AND game state matches saved state
+```
+
+### Core Gameplay
+
+```
+TEST: Player Movement
+  GIVEN player in game world
+  WHEN movement input applied
+  THEN player moves in expected direction
+  AND no physics glitches occur
+
+TEST: Core Action (Game-Specific)
+  GIVEN player can perform primary action
+  WHEN action is triggered
+  THEN action executes correctly
+  AND expected results occur
+
+  Examples:
+  - Shooter: Can fire weapon, bullets hit targets
+  - RPG: Can attack enemy, damage is applied
+  - Puzzle: Can interact with puzzle elements
+  - Platformer: Can jump, platforms are solid
+```
+
+### Save System
+
+```
+TEST: Save Creates File
+  GIVEN player makes progress
+  WHEN save is triggered
+  THEN save file is created
+  AND save completes without error
+
+TEST: Load Restores State
+  GIVEN valid save file exists
+  WHEN load is triggered
+  THEN saved state is restored
+  AND gameplay can continue
+```
+
+### Critical UI
+
+```
+TEST: Menu Navigation
+  GIVEN main menu is displayed
+  WHEN each menu option is selected
+  THEN correct screen/action occurs
+  AND navigation back works
+
+TEST: Settings Persist
+  GIVEN settings are changed
+  WHEN game is restarted
+  THEN settings remain changed
+```
+
+## Automated Smoke Test Examples
+
+### Unity
+
+```csharp
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.TestTools;
+using UnityEngine.SceneManagement;
+
+[TestFixture]
+public class SmokeTests
+{
+    [UnityTest, Timeout(60000)]
+    public IEnumerator Game_Launches_ToMainMenu()
+    {
+        // Load main menu scene
+        SceneManager.LoadScene("MainMenu");
+        yield return new WaitForSeconds(5f);
+
+        // Verify menu is active
+        var mainMenu = GameObject.Find("MainMenuCanvas");
+        Assert.IsNotNull(mainMenu, "Main menu should be present");
+        Assert.IsTrue(mainMenu.activeInHierarchy, "Main menu should be active");
+    }
+
+    [UnityTest, Timeout(120000)]
+    public IEnumerator NewGame_LoadsGameplay()
+    {
+        // Start from main menu
+        SceneManager.LoadScene("MainMenu");
+        yield return new WaitForSeconds(2f);
+
+        // Click new game
+        var newGameButton = GameObject.Find("NewGameButton")
+            .GetComponent<Button>();
+        newGameButton.onClick.Invoke();
+
+        yield return new WaitForSeconds(10f);
+
+        // Verify gameplay scene loaded
+        Assert.AreEqual("GameplayScene", SceneManager.GetActiveScene().name);
+
+        // Verify player exists and can be controlled
+        var player = GameObject.FindWithTag("Player");
+        Assert.IsNotNull(player, "Player should exist");
+    }
+
+    [UnityTest, Timeout(30000)]
+    public IEnumerator Player_CanMove()
+    {
+        // Load gameplay
+        SceneManager.LoadScene("GameplayScene");
+        yield return new WaitForSeconds(3f);
+
+        var player = GameObject.FindWithTag("Player");
+        var startPos = player.transform.position;
+
+        // Simulate movement input
+        var controller = player.GetComponent<PlayerController>();
+        controller.SetMoveInput(Vector2.right);
+
+        yield return new WaitForSeconds(1f);
+
+        // Verify movement occurred
+        Assert.Greater(player.transform.position.x, startPos.x,
+            "Player should have moved");
+    }
+
+    [UnityTest, Timeout(30000)]
+    public IEnumerator SaveLoad_RoundTrip_Works()
+    {
+        // Setup test state
+        SceneManager.LoadScene("GameplayScene");
+        yield return new WaitForSeconds(2f);
+
+        var player = GameObject.FindWithTag("Player");
+        player.transform.position = new Vector3(100, 0, 100);
+
+        // Save
+        SaveManager.Save("smoke_test");
+        yield return null;
+
+        // Reset position
+        player.transform.position = Vector3.zero;
+
+        // Load
+        SaveManager.Load("smoke_test");
+        yield return null;
+
+        // Verify
+        Assert.AreEqual(100f, player.transform.position.x, 1f);
+    }
+}
+```
+
+### Unreal
+
+```cpp
+// SmokeTests.cpp
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+    FGameLaunchTest,
+    "Smoke.Launch.MainMenu",
+    EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::SmokeFilter
+)
+
+bool FGameLaunchTest::RunTest(const FString& Parameters)
+{
+    // Verify main menu widget exists
+    UWorld* World = GEngine->GetWorldContexts()[0].World();
+    APlayerController* PC = World->GetFirstPlayerController();
+
+    TestNotNull("Player controller exists", PC);
+
+    // Check main menu is visible
+    AMyHUD* HUD = Cast<AMyHUD>(PC->GetHUD());
+    TestTrue("Main menu is visible", HUD->IsMainMenuVisible());
+
+    return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+    FPlayerMovementTest,
+    "Smoke.Gameplay.Movement",
+    EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::SmokeFilter
+)
+
+bool FPlayerMovementTest::RunTest(const FString& Parameters)
+{
+    APawn* Player = GetTestPlayer();
+    FVector StartPos = Player->GetActorLocation();
+
+    // Apply movement
+    APlayerController* PC = Cast<APlayerController>(Player->GetController());
+    PC->AddMovementInput(FVector::ForwardVector, 1.0f);
+
+    // Wait for physics
+    ADD_LATENT_AUTOMATION_COMMAND(FWaitForSeconds(0.5f));
+    // Note: FVerifyPlayerMoved is a custom latent command - implement to verify player position changed
+    ADD_LATENT_AUTOMATION_COMMAND(FVerifyPlayerMoved(StartPos));
+
+    return true;
+}
+```
+
+### Godot
+
+```gdscript
+# test_smoke.gd
+extends GutTest
+
+func test_game_launches():
+    # Switch to main menu
+    get_tree().change_scene_to_file("res://scenes/main_menu.tscn")
+    await get_tree().process_frame
+    await get_tree().create_timer(2.0).timeout
+
+    # Verify main menu loaded
+    var menu = get_tree().current_scene
+    assert_not_null(menu, "Main menu should load")
+    assert_eq(menu.name, "MainMenu", "Should be main menu scene")
+
+func test_new_game_starts():
+    get_tree().change_scene_to_file("res://scenes/main_menu.tscn")
+    await get_tree().process_frame
+
+    # Find and click new game button
+    var button = get_tree().current_scene.get_node("NewGameButton")
+    button.pressed.emit()
+
+    await get_tree().create_timer(5.0).timeout
+
+    # Verify gameplay loaded
+    var scene = get_tree().current_scene
+    assert_eq(scene.name, "GameWorld", "Should load gameplay scene")
+
+    var player = scene.get_node("Player")
+    assert_not_null(player, "Player should exist")
+
+func test_player_can_move():
+    get_tree().change_scene_to_file("res://scenes/game_world.tscn")
+    await get_tree().create_timer(1.0).timeout
+
+    var player = get_tree().current_scene.get_node("Player")
+    var start_pos = player.position
+
+    # Simulate input
+    Input.action_press("move_right")
+    await get_tree().create_timer(0.5).timeout
+    Input.action_release("move_right")
+
+    assert_gt(player.position.x, start_pos.x, "Player should have moved right")
+
+func test_save_load_works():
+    get_tree().change_scene_to_file("res://scenes/game_world.tscn")
+    await get_tree().create_timer(1.0).timeout
+
+    var player = get_tree().current_scene.get_node("Player")
+    player.position = Vector2(500, 300)
+
+    # Save
+    SaveManager.save_game("smoke_test")
+    await get_tree().process_frame
+
+    # Reset
+    player.position = Vector2.ZERO
+
+    # Load
+    SaveManager.load_game("smoke_test")
+    await get_tree().process_frame
+
+    assert_almost_eq(player.position.x, 500.0, 1.0, "Position should restore")
+```
+
+## CI/CD Integration
+
+### GitHub Actions Example
+
+```yaml
+name: Smoke Tests
+
+on: [push, pull_request]
+
+jobs:
+  smoke-test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build Game
+        run: ./build.sh --configuration Release
+
+      - name: Run Smoke Tests
+        run: |
+          ./game --headless --run-tests=Smoke --test-timeout=600
+
+      - name: Upload Results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: smoke-test-results
+          path: test-results/
+```
+
+### Test Execution Order
+
+1. **Build verification** - Binary exists and is valid
+2. **Launch test** - Game starts without crash
+3. **Menu navigation** - Can navigate to gameplay
+4. **Core loop** - Primary mechanic works
+5. **Save/Load** - Persistence functions
+6. **Cleanup** - No resource leaks
+
+## Smoke Test Metrics
+
+| Metric         | Target   | Action if Failed   |
+| -------------- | -------- | ------------------ |
+| Pass rate      | 100%     | Block deployment   |
+| Execution time | < 15 min | Optimize tests     |
+| Flakiness      | 0%       | Fix or remove test |
+
+## Best Practices
+
+### DO
+
+- Run smoke tests on every build
+- Keep tests fast and focused
+- Fail loudly and clearly
+- Test on target platform, not just dev environment
+- Include platform service connectivity
+- Run before any manual QA begins
+
+### DON'T
+
+- Include slow or flaky tests
+- Test edge cases or rare scenarios
+- Allow smoke test failures to ship
+- Skip smoke tests for "small" changes
+- Make smoke tests depend on external services
+- Let smoke suite grow beyond 15 minutes

src/modules/bmgd/gametest/knowledge/test-priorities.md

@@ -0,0 +1,271 @@
+# Test Priorities Matrix
+
+## Overview
+
+Not all tests are equal. This guide provides a framework for prioritizing test creation, execution, and maintenance based on risk, impact, and resources.
+
+## Priority Levels
+
+### P0 - Critical (Ship Blockers)
+
+**Definition**: Failures that prevent the game from being playable or shippable.
+
+| Criteria               | Examples                       |
+| ---------------------- | ------------------------------ |
+| Game cannot start      | Crash on launch, infinite load |
+| Core loop broken       | Cannot perform primary action  |
+| Data loss              | Saves corrupted, progress lost |
+| Platform certification | TRC/XR failures                |
+| Legal/compliance       | Rating violations              |
+
+**Testing Approach**:
+
+- Automated smoke tests on every build
+- Manual verification before any release
+- Zero tolerance for P0 bugs in release builds
+
+### P1 - High (Major Features)
+
+**Definition**: Significant functionality that affects most players' experience.
+
+| Criteria              | Examples                         |
+| --------------------- | -------------------------------- |
+| Major features broken | Multiplayer, progression systems |
+| Frequent player paths | Main story, common actions       |
+| Significant UX issues | Confusing UI, missing feedback   |
+| Performance problems  | Unplayable frame rates           |
+
+**Testing Approach**:
+
+- Comprehensive automated tests
+- Regular regression testing
+- Full coverage in release candidates
+
+### P2 - Medium (Standard Features)
+
+**Definition**: Important functionality that affects significant portions of gameplay.
+
+| Criteria           | Examples                      |
+| ------------------ | ----------------------------- |
+| Secondary features | Side quests, optional content |
+| Edge cases         | Unusual player actions        |
+| Platform-specific  | Single-platform issues        |
+| Minor progression  | Non-critical collectibles     |
+
+**Testing Approach**:
+
+- Selective automation
+- Milestone regression testing
+- Coverage prioritized by usage data
+
+### P3 - Low (Polish Items)
+
+**Definition**: Issues that are noticeable but don't significantly impact gameplay.
+
+| Criteria       | Examples                       |
+| -------------- | ------------------------------ |
+| Visual polish  | Minor clipping, texture issues |
+| Audio polish   | Volume inconsistencies         |
+| Rare scenarios | Edge cases with workarounds    |
+| Nice-to-have   | QoL improvements               |
+
+**Testing Approach**:
+
+- Manual exploratory testing
+- Automated only if easy/cheap
+- Fixed as time permits
+
+## Risk-Based Prioritization
+
+### Risk Factors
+
+| Factor              | High Risk           | Low Risk        |
+| ------------------- | ------------------- | --------------- |
+| Usage frequency     | Core loop           | Rarely accessed |
+| Player visibility   | Always visible      | Hidden/optional |
+| Data impact         | Saves, progression  | Cosmetic only   |
+| Recovery difficulty | No workaround       | Easy to retry   |
+| Change frequency    | Frequently modified | Stable code     |
+
+### Risk Assessment Matrix
+
+```
+                    IMPACT
+                Low      High
+            ┌─────────┬─────────┐
+      High  │   P2    │   P0    │
+LIKELIHOOD  ├─────────┼─────────┤
+      Low   │   P3    │   P1    │
+            └─────────┴─────────┘
+```
+
+## Coverage Targets by Priority
+
+| Priority | Unit Test | Integration | E2E/Smoke | Manual      |
+| -------- | --------- | ----------- | --------- | ----------- |
+| P0       | 100%      | 100%        | Required  | Pre-release |
+| P1       | 80%+      | 80%+        | As needed | Milestone   |
+| P2       | 60%+      | Key paths   | Optional  | Sprint      |
+| P3       | Optional  | Optional    | No        | Ad-hoc      |
+
+## Test Type Distribution
+
+### Recommended Test Pyramid (Games)
+
+```
+                    ▲
+                   /│\
+                  / │ \    E2E/Smoke Tests (5%)
+                 /  │  \   - Full game flow
+                /   │   \  - Platform certification
+               ───────────
+              /     │     \
+             /      │      \   Integration Tests (25%)
+            /       │       \  - System interactions
+           /        │        \ - Network, save, audio
+          ─────────────────────
+         /          │          \
+        /           │           \  Unit Tests (70%)
+       /            │            \ - Pure logic
+      /             │             \- Algorithms, calculations
+     ───────────────────────────────
+```
+
+### Game-Specific Considerations
+
+Unlike web apps, games have unique testing needs:
+
+| Test Type   | Standard App   | Game-Specific              |
+| ----------- | -------------- | -------------------------- |
+| Unit        | Business logic | Damage calc, AI decisions  |
+| Integration | API + DB       | Physics, audio, network    |
+| E2E         | User flows     | Gameplay scenarios         |
+| Additional  | N/A            | Playtesting, balance, feel |
+
+## Execution Order
+
+### CI Pipeline (Every Commit)
+
+1. P0 smoke tests (5-10 minutes)
+2. P0/P1 unit tests (10-15 minutes)
+3. P0 integration tests (5-10 minutes)
+
+### Daily/Nightly
+
+1. Full P0 suite
+2. Full P1 suite
+3. P2 regression suite
+4. Performance benchmarks
+
+### Milestone/Release
+
+1. All automated tests
+2. Full P0-P2 manual testing
+3. Platform certification tests
+4. Exploratory testing
+5. Performance profiling
+
+## Bug Triage Criteria
+
+### Priority Assignment
+
+| Question                   | P0   | P1        | P2   | P3   |
+| -------------------------- | ---- | --------- | ---- | ---- |
+| Can player complete game?  | No   | Affected  | No   | No   |
+| How many players affected? | All  | Most      | Some | Few  |
+| Is there a workaround?     | No   | Difficult | Yes  | Easy |
+| Data at risk?              | Yes  | Possible  | No   | No   |
+| Platform certification?    | Fail | Risk      | Pass | Pass |
+
+### Severity vs Priority
+
+```
+SEVERITY: How bad is the bug?
+  Critical → Crash, data loss
+  Major    → Feature broken
+  Minor    → Incorrect behavior
+  Trivial  → Cosmetic
+
+PRIORITY: How soon to fix?
+  P0 → Immediately (blocks release)
+  P1 → This sprint
+  P2 → This milestone
+  P3 → Backlog
+```
+
+## Resource Allocation
+
+### QA Time Distribution
+
+| Activity         | Percentage |
+| ---------------- | ---------- |
+| P0 verification  | 30%        |
+| P1 testing       | 30%        |
+| P2 testing       | 20%        |
+| Exploratory      | 15%        |
+| Test maintenance | 5%         |
+
+### Automation Investment
+
+| Priority | Automation Value | ROI            |
+| -------- | ---------------- | -------------- |
+| P0       | Essential        | Highest        |
+| P1       | High             | High           |
+| P2       | Medium           | Medium         |
+| P3       | Low              | Often negative |
+
+## Platform Priority Matrix
+
+### Multi-Platform Prioritization
+
+| Platform                | Player Base | Certification | Testing Priority  |
+| ----------------------- | ----------- | ------------- | ----------------- |
+| Primary (e.g., PC)      | 60%         | Light         | P0: All, P1: All  |
+| Secondary (e.g., PS5)   | 25%         | Heavy         | P0: All, P1: Most |
+| Tertiary (e.g., Switch) | 15%         | Medium        | P0: All, P1: Core |
+
+### Cross-Platform Testing Strategy
+
+```
+         Platform Testing Coverage
+
+         PC    PS5   Xbox  Switch  Mobile
+P0       ████  ████  ████  ████    ████
+P1       ████  ███░  ███░  ██░░    ██░░
+P2       ███░  ██░░  ██░░  █░░░    █░░░
+P3       ██░░  █░░░  █░░░  ░░░░    ░░░░
+
+████ = Full coverage
+███░ = High coverage
+██░░ = Medium coverage
+█░░░ = Low coverage
+░░░░ = Minimal/none
+```
+
+## Best Practices
+
+### DO
+
+- Reassess priorities as development progresses
+- Weight user-facing features higher
+- Consider platform certification requirements
+- Focus automation on stable, high-value areas
+- Track bug escape rates by priority
+
+### DON'T
+
+- Treat all tests equally
+- Automate P3 before P0/P1 coverage is solid
+- Skip P0 testing for "small changes"
+- Ignore platform-specific requirements
+- Let P1/P2 bugs accumulate
+
+## Metrics to Track
+
+| Metric              | Target        | Purpose              |
+| ------------------- | ------------- | -------------------- |
+| P0 test pass rate   | 100%          | Build quality        |
+| P0 bug escape rate  | 0%            | Test effectiveness   |
+| P1 coverage         | 80%+          | Feature coverage     |
+| Test execution time | < 30 min (CI) | Development velocity |
+| Flaky test rate     | < 1%          | Test reliability     |

src/modules/bmgd/gametest/knowledge/unity-testing.md

@@ -0,0 +1,383 @@
+# Unity Test Framework Guide
+
+## Overview
+
+Unity provides a built-in Test Framework based on NUnit for writing and running automated tests. It supports Edit Mode tests (run without playing) and Play Mode tests (run during gameplay simulation).
+
+## Test Framework Setup
+
+### Package Installation
+
+```json
+// manifest.json - usually pre-installed
+{
+  "dependencies": {
+    "com.unity.test-framework": "1.6.0"
+  }
+}
+```
+
+### Project Structure
+
+```
+Assets/
+├── Scripts/
+│   └── Runtime/
+│       ├── Player/
+│       │   └── PlayerController.cs
+│       └── Combat/
+│           └── DamageCalculator.cs
+└── Tests/
+    ├── EditMode/
+    │   └── DamageCalculatorTests.cs
+    └── PlayMode/
+        └── PlayerMovementTests.cs
+```
+
+### Assembly Definitions
+
+Create `.asmdef` files for test assemblies:
+
+```json
+// Tests/EditMode/EditModeTests.asmdef
+{
+  "name": "EditModeTests",
+  "references": ["GameAssembly"],
+  "includePlatforms": ["Editor"],
+  "defineConstraints": ["UNITY_INCLUDE_TESTS"]
+}
+
+// Tests/PlayMode/PlayModeTests.asmdef
+{
+  "name": "PlayModeTests",
+  "references": ["GameAssembly"],
+  "includePlatforms": [],
+  "defineConstraints": ["UNITY_INCLUDE_TESTS"]
+}
+```
+
+## Edit Mode Tests
+
+Edit Mode tests run in the Editor without entering Play Mode. Best for testing pure logic.
+
+### Basic Test Structure
+
+```csharp
+using NUnit.Framework;
+
+[TestFixture]
+public class DamageCalculatorTests
+{
+    private DamageCalculator _calculator;
+
+    [SetUp]
+    public void Setup()
+    {
+        _calculator = new DamageCalculator();
+    }
+
+    [Test]
+    public void Calculate_BaseDamage_ReturnsCorrectValue()
+    {
+        float result = _calculator.Calculate(100f, 1f);
+        Assert.AreEqual(100f, result);
+    }
+
+    [Test]
+    public void Calculate_CriticalHit_DoublesDamage()
+    {
+        float result = _calculator.Calculate(100f, multiplier: 2f);
+        Assert.AreEqual(200f, result);
+    }
+
+    [TestCase(100f, 0.5f, 50f)]
+    [TestCase(100f, 1.5f, 150f)]
+    [TestCase(50f, 2f, 100f)]
+    public void Calculate_Parameterized_ReturnsExpected(
+        float base_, float mult, float expected)
+    {
+        Assert.AreEqual(expected, _calculator.Calculate(base_, mult));
+    }
+}
+```
+
+### Testing ScriptableObjects
+
+```csharp
+[Test]
+public void WeaponStats_DPS_CalculatesCorrectly()
+{
+    var weapon = ScriptableObject.CreateInstance<WeaponStats>();
+    weapon.baseDamage = 10f;
+    weapon.attacksPerSecond = 2f;
+
+    Assert.AreEqual(20f, weapon.DPS);
+
+    // Cleanup
+    Object.DestroyImmediate(weapon);
+}
+```
+
+## Play Mode Tests
+
+Play Mode tests run during gameplay simulation. Required for testing MonoBehaviours, physics, and runtime behavior.
+
+### Basic Play Mode Test
+
+```csharp
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+public class PlayerMovementTests
+{
+    private GameObject _player;
+    private PlayerController _controller;
+
+    [SetUp]
+    public void Setup()
+    {
+        _player = new GameObject("Player");
+        _controller = _player.AddComponent<PlayerController>();
+        _player.AddComponent<Rigidbody>();
+        _player.AddComponent<CapsuleCollider>();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        Object.Destroy(_player);
+    }
+
+    [UnityTest]
+    public IEnumerator Move_WhenInputApplied_ChangesPosition()
+    {
+        Vector3 startPos = _player.transform.position;
+
+        _controller.SetInput(Vector2.right);
+
+        yield return new WaitForSeconds(0.5f);
+
+        Assert.Greater(_player.transform.position.x, startPos.x);
+    }
+
+    [UnityTest]
+    public IEnumerator Jump_WhenGrounded_BecomesAirborne()
+    {
+        // Setup ground
+        var ground = GameObject.CreatePrimitive(PrimitiveType.Plane);
+        _player.transform.position = Vector3.up;
+
+        yield return new WaitForFixedUpdate();
+
+        _controller.Jump();
+
+        yield return new WaitForSeconds(0.1f);
+
+        Assert.IsFalse(_controller.IsGrounded);
+
+        Object.Destroy(ground);
+    }
+}
+```
+
+### Testing Coroutines
+
+```csharp
+[UnityTest]
+public IEnumerator Attack_Cooldown_PreventsSpam()
+{
+    _controller.Attack();
+    Assert.IsTrue(_controller.IsAttacking);
+
+    _controller.Attack(); // Should be blocked
+    Assert.AreEqual(1, _controller.AttackCount);
+
+    yield return new WaitForSeconds(_controller.AttackCooldown + 0.1f);
+
+    _controller.Attack();
+    Assert.AreEqual(2, _controller.AttackCount);
+}
+```
+
+### Scene Testing
+
+```csharp
+using UnityEngine.SceneManagement;
+
+[UnityTest]
+public IEnumerator MainMenu_StartButton_LoadsGameScene()
+{
+    SceneManager.LoadScene("MainMenu");
+    yield return null; // Wait for scene load
+
+    var startButton = GameObject.Find("StartButton")
+        .GetComponent<Button>();
+    startButton.onClick.Invoke();
+
+    yield return new WaitForSeconds(1f);
+
+    Assert.AreEqual("GameScene", SceneManager.GetActiveScene().name);
+}
+```
+
+## Integration Test Patterns
+
+### Prefab Testing
+
+```csharp
+[UnityTest]
+public IEnumerator EnemyPrefab_Spawns_WithCorrectComponents()
+{
+    var prefab = Resources.Load<GameObject>("Prefabs/Enemy");
+    var instance = Object.Instantiate(prefab);
+
+    yield return null;
+
+    Assert.IsNotNull(instance.GetComponent<EnemyAI>());
+    Assert.IsNotNull(instance.GetComponent<Health>());
+    Assert.IsNotNull(instance.GetComponent<NavMeshAgent>());
+
+    Object.Destroy(instance);
+}
+```
+
+### Input System Testing
+
+```csharp
+using UnityEngine.InputSystem;
+
+[UnityTest]
+public IEnumerator InputAction_Fire_TriggersWeapon()
+{
+    var keyboard = InputSystem.AddDevice<Keyboard>();
+
+    yield return null;
+
+    Press(keyboard.spaceKey);
+    yield return null;
+
+    Assert.IsTrue(_controller.IsFiring);
+
+    Release(keyboard.spaceKey);
+    yield return null;
+
+    Assert.IsFalse(_controller.IsFiring);
+}
+```
+
+## Test Utilities
+
+### Custom Assertions
+
+```csharp
+public static class GameAssert
+{
+    public static void AreApproximatelyEqual(
+        Vector3 expected, Vector3 actual, float tolerance = 0.001f)
+    {
+        Assert.AreEqual(expected.x, actual.x, tolerance);
+        Assert.AreEqual(expected.y, actual.y, tolerance);
+        Assert.AreEqual(expected.z, actual.z, tolerance);
+    }
+
+    public static void IsWithinRange(float value, float min, float max)
+    {
+        Assert.GreaterOrEqual(value, min);
+        Assert.LessOrEqual(value, max);
+    }
+}
+```
+
+### Test Fixtures
+
+```csharp
+public class TestScene : IDisposable
+{
+    public GameObject Player { get; private set; }
+    public GameObject Ground { get; private set; }
+
+    public TestScene()
+    {
+        Ground = GameObject.CreatePrimitive(PrimitiveType.Plane);
+        Player = Object.Instantiate(Resources.Load<GameObject>("Player"));
+        Player.transform.position = Vector3.up;
+    }
+
+    public void Dispose()
+    {
+        Object.Destroy(Player);
+        Object.Destroy(Ground);
+    }
+}
+
+[UnityTest]
+public IEnumerator Player_FallsToGround()
+{
+    using var scene = new TestScene();
+
+    yield return new WaitForSeconds(1f);
+
+    Assert.Less(scene.Player.transform.position.y, 0.5f);
+}
+```
+
+## CI Integration
+
+### Command Line Execution
+
+```bash
+# Run Edit Mode tests
+Unity -runTests -batchmode -projectPath . \
+  -testPlatform EditMode \
+  -testResults results.xml
+
+# Run Play Mode tests
+Unity -runTests -batchmode -projectPath . \
+  -testPlatform PlayMode \
+  -testResults results.xml
+```
+
+### GitHub Actions
+
+```yaml
+test:
+  runs-on: ubuntu-latest
+  steps:
+    - uses: game-ci/unity-test-runner@v4
+      with:
+        projectPath: .
+        testMode: all
+        artifactsPath: TestResults
+```
+
+## Best Practices
+
+### DO
+
+- Test pure logic in Edit Mode (faster execution)
+- Use Play Mode only when needed (physics, coroutines, MonoBehaviour)
+- Create test fixtures for common setups
+- Clean up created GameObjects in TearDown
+- Use `[Category]` attributes for test organization
+- Run tests before every commit
+
+### DON'T
+
+- Don't test Unity's built-in functionality
+- Don't rely on specific frame timing (use WaitForSeconds)
+- Don't leave test objects in scenes
+- Don't test private methods directly (test through public API)
+- Don't create tests that depend on execution order
+
+## Troubleshooting
+
+### Common Issues
+
+| Issue                  | Cause              | Fix                                        |
+| ---------------------- | ------------------ | ------------------------------------------ |
+| Tests not appearing    | Missing asmdef     | Create test assembly definition            |
+| NullReferenceException | Missing Setup      | Ensure [SetUp] initializes all fields      |
+| Tests hang             | Infinite coroutine | Add timeout or max iterations              |
+| Flaky physics tests    | Timing dependent   | Use WaitForFixedUpdate, increase tolerance |

src/modules/bmgd/gametest/knowledge/unreal-testing.md

@@ -0,0 +1,388 @@
+# Unreal Engine Automation Testing Guide
+
+## Overview
+
+Unreal Engine provides a comprehensive automation system for testing games, including:
+
+- **Automation Framework** - Low-level test infrastructure
+- **Functional Tests** - In-game scenario testing
+- **Gauntlet** - Extended testing and automation
+
+## Automation Framework
+
+### Test Types
+
+| Type          | Flag            | Use Case                   |
+| ------------- | --------------- | -------------------------- |
+| Unit Tests    | `SmokeFilter`   | Fast, isolated logic tests |
+| Feature Tests | `ProductFilter` | Feature validation         |
+| Stress Tests  | `StressFilter`  | Performance under load     |
+| Perf Tests    | `PerfFilter`    | Benchmark comparisons      |
+
+### Basic Test Structure
+
+```cpp
+// MyGameTests.cpp
+#include "Misc/AutomationTest.h"
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+    FDamageCalculationTest,
+    "MyGame.Combat.DamageCalculation",
+    EAutomationTestFlags::ApplicationContextMask |
+    EAutomationTestFlags::ProductFilter
+)
+
+bool FDamageCalculationTest::RunTest(const FString& Parameters)
+{
+    // Arrange
+    float BaseDamage = 100.f;
+    float CritMultiplier = 2.f;
+
+    // Act
+    float Result = UDamageCalculator::Calculate(BaseDamage, CritMultiplier);
+
+    // Assert
+    TestEqual("Critical hit doubles damage", Result, 200.f);
+
+    return true;
+}
+```
+
+### Complex Test with Setup/Teardown
+
+```cpp
+IMPLEMENT_COMPLEX_AUTOMATION_TEST(
+    FInventorySystemTest,
+    "MyGame.Systems.Inventory",
+    EAutomationTestFlags::ApplicationContextMask |
+    EAutomationTestFlags::ProductFilter
+)
+
+void FInventorySystemTest::GetTests(
+    TArray<FString>& OutBeautifiedNames,
+    TArray<FString>& OutTestCommands) const
+{
+    OutBeautifiedNames.Add("AddItem");
+    OutTestCommands.Add("AddItem");
+
+    OutBeautifiedNames.Add("RemoveItem");
+    OutTestCommands.Add("RemoveItem");
+
+    OutBeautifiedNames.Add("StackItems");
+    OutTestCommands.Add("StackItems");
+}
+
+bool FInventorySystemTest::RunTest(const FString& Parameters)
+{
+    // Setup
+    UInventoryComponent* Inventory = NewObject<UInventoryComponent>();
+
+    if (Parameters == "AddItem")
+    {
+        UItemData* Sword = NewObject<UItemData>();
+        Sword->ItemID = "sword_01";
+
+        bool bAdded = Inventory->AddItem(Sword);
+
+        TestTrue("Item added successfully", bAdded);
+        TestEqual("Inventory count", Inventory->GetItemCount(), 1);
+    }
+    else if (Parameters == "RemoveItem")
+    {
+        // ... test logic
+    }
+    else if (Parameters == "StackItems")
+    {
+        // ... test logic
+    }
+
+    return true;
+}
+```
+
+### Latent Actions (Async Tests)
+
+```cpp
+DEFINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(
+    FWaitForActorSpawn,
+    FString, ActorName
+);
+
+bool FWaitForActorSpawn::Update()
+{
+    UWorld* World = GEngine->GetWorldContexts()[0].World();
+    AActor* Actor = nullptr;
+
+    for (TActorIterator<AActor> It(World); It; ++It)
+    {
+        if (It->GetName() == ActorName)
+        {
+            Actor = *It;
+            break;
+        }
+    }
+
+    return Actor != nullptr; // Return true when complete
+}
+
+bool FSpawnTest::RunTest(const FString& Parameters)
+{
+    // Spawn enemy
+    ADD_LATENT_AUTOMATION_COMMAND(FSpawnEnemy("Goblin"));
+
+    // Wait for spawn
+    ADD_LATENT_AUTOMATION_COMMAND(FWaitForActorSpawn("Goblin"));
+
+    // Verify
+    ADD_LATENT_AUTOMATION_COMMAND(FVerifyEnemyState("Goblin", "Idle"));
+
+    return true;
+}
+```
+
+## Functional Tests
+
+Functional tests run inside the game world and can test gameplay scenarios.
+
+### Setup
+
+1. Create a test map (`TestMap_Combat.umap`)
+2. Add `AFunctionalTest` actors to the map
+3. Configure test parameters in Details panel
+
+### Blueprint Functional Test
+
+```cpp
+// In Blueprint:
+// 1. Create child of AFunctionalTest
+// 2. Override "Start Test" event
+// 3. Call "Finish Test" when complete
+```
+
+### C++ Functional Test
+
+```cpp
+UCLASS()
+class APlayerCombatTest : public AFunctionalTest
+{
+    GENERATED_BODY()
+
+public:
+    virtual void StartTest() override;
+
+protected:
+    UPROPERTY(EditAnywhere)
+    TSubclassOf<AEnemy> EnemyClass;
+
+    UPROPERTY(EditAnywhere)
+    float ExpectedDamage = 50.f;
+
+private:
+    void OnEnemyDamaged(float Damage);
+};
+
+void APlayerCombatTest::StartTest()
+{
+    Super::StartTest();
+
+    // Spawn test enemy
+    AEnemy* Enemy = GetWorld()->SpawnActor<AEnemy>(EnemyClass);
+    Enemy->OnDamaged.AddDynamic(this, &APlayerCombatTest::OnEnemyDamaged);
+
+    // Get player and attack
+    APlayerCharacter* Player = Cast<APlayerCharacter>(
+        UGameplayStatics::GetPlayerCharacter(this, 0));
+    Player->Attack(Enemy);
+}
+
+void APlayerCombatTest::OnEnemyDamaged(float Damage)
+{
+    if (FMath::IsNearlyEqual(Damage, ExpectedDamage, 0.1f))
+    {
+        FinishTest(EFunctionalTestResult::Succeeded, "Damage correct");
+    }
+    else
+    {
+        FinishTest(EFunctionalTestResult::Failed,
+            FString::Printf(TEXT("Expected %f, got %f"),
+                ExpectedDamage, Damage));
+    }
+}
+```
+
+## Gauntlet Framework
+
+Gauntlet extends automation for large-scale testing, performance benchmarking, and multi-client scenarios.
+
+### Gauntlet Test Configuration
+
+```cpp
+// MyGameTest.cs (Gauntlet config)
+namespace MyGame.Automation
+{
+    public class PerformanceTestConfig : UnrealTestConfig
+    {
+        [AutoParam]
+        public string MapName = "TestMap_Performance";
+
+        [AutoParam]
+        public int Duration = 300; // 5 minutes
+
+        public override void ApplyToConfig(UnrealAppConfig Config)
+        {
+            base.ApplyToConfig(Config);
+            Config.AddCmdLineArg("-game");
+            Config.AddCmdLineArg($"-ExecCmds=open {MapName}");
+        }
+    }
+}
+```
+
+### Running Gauntlet
+
+```bash
+# Run performance test
+RunUAT.bat RunUnreal -project=MyGame -platform=Win64 \
+  -configuration=Development -build=local \
+  -test=MyGame.PerformanceTest -Duration=300
+```
+
+## Blueprint Testing
+
+### Test Helpers in Blueprint
+
+Create a Blueprint Function Library with test utilities:
+
+```cpp
+UCLASS()
+class UTestHelpers : public UBlueprintFunctionLibrary
+{
+    GENERATED_BODY()
+
+public:
+    UFUNCTION(BlueprintCallable, Category = "Testing")
+    static void AssertTrue(bool Condition, const FString& Message);
+
+    UFUNCTION(BlueprintCallable, Category = "Testing")
+    static void AssertEqual(int32 A, int32 B, const FString& Message);
+
+    UFUNCTION(BlueprintCallable, Category = "Testing")
+    static AActor* SpawnTestActor(
+        UObject* WorldContext,
+        TSubclassOf<AActor> ActorClass,
+        FVector Location);
+};
+```
+
+## Performance Testing
+
+### Frame Time Measurement
+
+```cpp
+bool FFrameTimeTest::RunTest(const FString& Parameters)
+{
+    TArray<float> FrameTimes;
+    float TotalTime = 0.f;
+
+    // Collect frame times
+    ADD_LATENT_AUTOMATION_COMMAND(FCollectFrameTimes(
+        FrameTimes, 1000 // frames
+    ));
+
+    // Analyze
+    ADD_LATENT_AUTOMATION_COMMAND(FAnalyzeFrameTimes(
+        FrameTimes,
+        16.67f, // Target: 60fps
+        0.99f   // 99th percentile threshold
+    ));
+
+    return true;
+}
+```
+
+### Memory Tracking
+
+```cpp
+bool FMemoryLeakTest::RunTest(const FString& Parameters)
+{
+    SIZE_T BaselineMemory = FPlatformMemory::GetStats().UsedPhysical;
+
+    // Perform operations
+    for (int i = 0; i < 100; i++)
+    {
+        UObject* Obj = NewObject<UMyObject>();
+        // ... use object
+        Obj->MarkAsGarbage();  // UE5 API (was MarkPendingKill in UE4)
+    }
+
+    CollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS);
+
+    SIZE_T FinalMemory = FPlatformMemory::GetStats().UsedPhysical;
+    SIZE_T Leaked = FinalMemory - BaselineMemory;
+
+    TestTrue("No significant leak", Leaked < 1024 * 1024); // 1MB tolerance
+
+    return true;
+}
+```
+
+## CI Integration
+
+### Command Line
+
+```bash
+# Run all tests (UE5)
+UnrealEditor.exe MyGame -ExecCmds="Automation RunTests Now" -unattended -nopause
+
+# Run specific test
+UnrealEditor.exe MyGame -ExecCmds="Automation RunTests MyGame.Combat" -unattended
+
+# Run with report
+UnrealEditor.exe MyGame \
+  -ExecCmds="Automation RunTests Now; Automation ReportResults" \
+  -ReportOutputPath=TestResults.xml
+
+# Note: For UE4, use UE4Editor.exe instead of UnrealEditor.exe
+```
+
+### GitHub Actions
+
+```yaml
+test:
+  runs-on: [self-hosted, windows, unreal]
+  steps:
+    - name: Run Tests
+      run: |
+        # UE5: UnrealEditor-Cmd.exe, UE4: UE4Editor-Cmd.exe
+        & "$env:UE_ROOT/Engine/Binaries/Win64/UnrealEditor-Cmd.exe" `
+          "${{ github.workspace }}/MyGame.uproject" `
+          -ExecCmds="Automation RunTests Now" `
+          -unattended -nopause -nullrhi
+```
+
+## Best Practices
+
+### DO
+
+- Use `SmokeFilter` for fast CI tests
+- Create dedicated test maps for functional tests
+- Clean up spawned actors after tests
+- Use latent commands for async operations
+- Profile tests to keep CI fast
+
+### DON'T
+
+- Don't test engine functionality
+- Don't rely on specific tick order
+- Don't leave test actors in production maps
+- Don't ignore test warnings
+- Don't skip garbage collection in tests
+
+## Troubleshooting
+
+| Issue          | Cause           | Fix                          |
+| -------------- | --------------- | ---------------------------- |
+| Test not found | Wrong flags     | Check `EAutomationTestFlags` |
+| Crash in test  | Missing world   | Use proper test context      |
+| Flaky results  | Timing issues   | Use latent commands          |
+| Slow tests     | Too many actors | Optimize test setup          |

src/modules/bmgd/gametest/qa-index.csv

@@ -0,0 +1,17 @@
+id,name,description,tags,fragment_file
+playtesting,Playtesting Fundamentals,"Core principles and methods for playtesting game builds","testing-methods,playtesting,design-validation",knowledge/playtesting.md
+qa-automation,QA Automation,"Automated testing strategies for games including unit and integration tests","automation,unit-tests,integration",knowledge/qa-automation.md
+performance-testing,Performance Testing,"Frame rate profiling and optimization testing strategies","performance,profiling,fps",knowledge/performance-testing.md
+balance-testing,Balance Testing,"Methods for testing game balance and tuning","design-validation,balance,economy",knowledge/balance-testing.md
+compatibility-testing,Compatibility Testing,"Platform and device compatibility testing approaches","compatibility,platforms,hardware",knowledge/compatibility-testing.md
+regression-testing,Regression Testing,"Strategies for catching regressions in game builds","regression,ci,automation",knowledge/regression-testing.md
+unity-testing,Unity Test Framework,"Unity-specific testing with Test Framework, Play Mode, and Edit Mode tests","unity,unit-tests,integration",knowledge/unity-testing.md
+unreal-testing,Unreal Automation,"Unreal Engine automation system, functional tests, and Gauntlet","unreal,automation,gauntlet",knowledge/unreal-testing.md
+godot-testing,Godot GUT Testing,"Godot Unit Test framework patterns and best practices","godot,gut,unit-tests",knowledge/godot-testing.md
+save-testing,Save System Testing,"Strategies for testing save/load systems and data integrity","save-system,data,persistence",knowledge/save-testing.md
+multiplayer-testing,Multiplayer Testing,"Network testing, sync validation, and lag simulation","multiplayer,networking,sync",knowledge/multiplayer-testing.md
+input-testing,Input Testing,"Controller, keyboard, and touch input validation","input,controllers,accessibility",knowledge/input-testing.md
+localization-testing,Localization Testing,"Text, audio, and cultural validation for international releases","localization,i18n,text",knowledge/localization-testing.md
+certification-testing,Platform Certification,"Console TRC/XR requirements and certification testing","certification,console,trc,xr",knowledge/certification-testing.md
+smoke-testing,Smoke Testing,"Critical path validation for build verification","smoke-tests,bvt,ci",knowledge/smoke-testing.md
+test-priorities,Test Priorities Matrix,"P0-P3 criteria, coverage targets, execution ordering for games","prioritization,risk,coverage",knowledge/test-priorities.md

src/modules/bmgd/module.yaml

@@ -10,28 +10,44 @@ default_selected: false
 ## document_output_language
 ## output_folder
 
-game_project_name:
+project_name:
   prompt: "What is the name of your game project?"
   default: "{directory_name}"
   result: "{value}"
 
-sprint_artifacts:
-  prompt: "Where should Sprint Artifacts be stored (stories, epics, temp context, etc...)?"
-  default: "{output_folder}/sprint-artifacts"
-  result: "{project-root}/{value}"
-
 game_dev_experience:
-  prompt: "What is your game development experience level?"
+  prompt:
+    - "What is your game development experience level?"
+    - "This affects how agents explain concepts in chat."
   default: "intermediate"
   result: "{value}"
   single-select:
     - value: "beginner"
-      label: "Beginner - New to game development, provide detailed guidance"
+      label: "Beginner - New to game development, explain concepts clearly"
     - value: "intermediate"
-      label: "Intermediate - Familiar with game dev concepts, balanced approach"
+      label: "Intermediate - Familiar with game dev concepts, balance explanation with efficiency"
     - value: "expert"
       label: "Expert - Experienced game developer, be direct and technical"
 
+planning_artifacts:
+  prompt: "Where should game planning artifacts be stored?\n(Game Briefs, GDDs, Narrative Designs, Architecture docs)"
+  default: "{output_folder}/game-planning-artifacts"
+  result: "{project-root}/{value}"
+
+implementation_artifacts:
+  prompt: "Where should implementation artifacts be stored?\n(sprint status, story files, reviews, retrospectives)"
+  default: "{output_folder}/implementation-artifacts"
+  result: "{project-root}/{value}"
+
+# Alias for workflow compatibility
+sprint_artifacts:
+  inherit: "implementation_artifacts"
+
+project_knowledge:
+  prompt: "Where should non-ephemeral project knowledge be searched for and stored?\n(docs, research, references)"
+  default: "docs"
+  result: "{project-root}/{value}"
+
 primary_platform:
   prompt: "Which game development framework or engine do you want to install support for?"
   default: ["unity", "unreal", "godot", "other"]

src/modules/bmgd/teams/default-party.csv

@@ -3,6 +3,8 @@ name,displayName,title,icon,role,identity,communicationStyle,principles,module,p
 "game-designer","Samus Shepard","Game Designer","🎲","Lead Game Designer + Creative Vision Architect","Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking.","Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs","Design what players want to FEEL, not what they say they want. Prototype fast. One hour of playtesting beats ten hours of discussion.","bmgd","bmad/bmgd/agents/game-designer.md"
 "game-dev","Link Freeman","Game Developer","🕹️","Senior Game Developer + Technical Implementation Specialist","Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code.","Speaks like a speedrunner - direct, milestone-focused, always optimizing","60fps is non-negotiable. Write code designers can iterate without fear. Ship early, ship often, iterate on player feedback.","bmgd","bmad/bmgd/agents/game-dev.md"
 "game-scrum-master","Max","Game Dev Scrum Master","🎯","Game Development Scrum Master + Sprint Orchestrator","Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories.","Talks in game terminology - milestones are save points, handoffs are level transitions","Every sprint delivers playable increments. Clean separation between design and implementation. Keep the team moving through each phase.","bmgd","bmad/bmgd/agents/game-scrum-master.md"
+"game-qa","GLaDOS","Game QA Architect","🧪","Game QA Architect + Test Automation Specialist","Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games.","Speaks like GLaDOS from Portal - methodical, data-driven. Trust, but verify with tests.","Test what matters: gameplay feel, performance, progression. Automated tests catch regressions, humans catch fun problems. Profile before optimize, test before ship.","bmgd","bmad/bmgd/agents/game-qa.md"
+"game-solo-dev","Indie","Game Solo Dev","🎮","Elite Indie Game Developer + Quick Flow Specialist","Battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot. Lives the Quick Flow workflow.","Direct, confident, gameplay-focused. Uses dev slang. Does it feel good? Ship it.","Prototype fast, fail fast, iterate faster. A playable build beats a perfect design doc. 60fps is non-negotiable. The core loop must be fun first.","bmgd","bmad/bmgd/agents/game-solo-dev.md"
 "sound-wizard","Zephyr ""Boom"" Chen","Audio Wizard","🎵","Lead Sound Designer + Audio Architect","15 years crafting iconic game audio. Expert in adaptive music systems, procedural audio, and spatial sound. Obsessed with making every action feel impactful.","Talks in onomatopoeia - WHOOSH for swooshes, KABOOM for explosions, describes everything through sound effects","Sound is 50% of the experience. Every footstep tells a story. Silence is the most powerful sound.","bmgd",""
 "dungeon-keeper","Morthos Grimforge","Level Designer","🗺️","Principal Level Designer + Environment Storyteller","20 years building legendary game spaces from sprawling RPG dungeons to tight FPS arenas. Master of flow, pacing, and environmental storytelling.","Speaks like a dramatic dungeon master - describes spaces theatrically, rolls for initiative on decisions","Every room must teach or test. The best levels don't need tutorials. Players should feel clever, not frustrated.","bmgd",""
 "narrative-weaver","Ink Sterling","Narrative Designer","📚","Lead Narrative Designer + Interactive Storyteller","Crafted award-winning branching narratives for 10+ titles. Expert in choice architecture, character arcs, and integrating story with mechanics.","Speaks in story beats - everything is Act 1, plot twists, climaxes, and emotional payoffs","Story serves gameplay, gameplay reveals story. Every choice must matter or don't offer it. Kill your darlings ruthlessly.","bmgd",""

src/modules/bmgd/teams/team-gamedev.yaml

@@ -2,17 +2,28 @@
 bundle:
   name: Team Game Development
   icon: 🎮
-  description: Specialized game development team including Game Designer (creative vision and GDD), Game Developer (implementation and code), Game Architect (technical systems and infrastructure), and Game Dev Scrum Master (sprint coordination). Perfect for game projects across all scales and platforms.
+  description: Specialized game development team including Game Designer (creative vision and GDD), Game Developer (implementation and code), Game Architect (technical systems and infrastructure), Game Scrum Master (sprint coordination), Game QA (testing and quality assurance), and Game Solo Dev (quick-flow development). Perfect for game projects across all scales and platforms.
 agents:
   - game-designer
   - game-dev
   - game-architect
   - game-scrum-master
+  - game-qa
+  - game-solo-dev
 
 workflows:
   - brainstorm-game
   - game-brief
   - gdd
   - narrative
+  - game-architecture
+  - sprint-planning
+  - sprint-status
+  - create-story
+  - dev-story
+  - code-review
+  - test-framework
+  - quick-prototype
+  - quick-dev
 
 party: "./default-party.csv"

src/modules/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-01-init.md

@@ -0,0 +1,164 @@
+---
+name: 'step-01-init'
+description: 'Initialize the game brainstorming workflow and validate readiness'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-init.md'
+nextStepFile: '{workflow_path}/steps/step-02-context.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/brainstorming-session-{date}.md'
+
+# Context Files
+gameContext: '{workflow_path}/game-context.md'
+gameBrainMethods: '{workflow_path}/game-brain-methods.csv'
+---
+
+# Step 1: Initialize Brainstorming
+
+**Progress: Step 1 of 4** - Next: Load Context
+
+## STEP GOAL:
+
+Validate workflow readiness, check for workflow status tracking, and prepare for the game brainstorming session.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a creative game design facilitator
+- Focus on drawing out user's ideas
+- Game brainstorming is optional but valuable
+
+### Step-Specific Rules:
+
+- Check for workflow status file
+- Initialize session document with proper frontmatter
+- Prepare user for brainstorming mindset
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Wait for user confirmation before proceeding
+- Update frontmatter `stepsCompleted: [1]` before loading next step
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Check Workflow Status
+
+**Search for workflow status file:**
+
+Check if `{output_folder}/bmm-workflow-status.yaml` exists.
+
+**If status file NOT found:**
+
+"No workflow status file found. Game brainstorming is optional and can run standalone.
+
+Would you like to:
+
+1. Continue in standalone mode (no progress tracking)
+2. Run `workflow-init` first to set up tracking
+
+Your choice:"
+
+**If user continues:** Set `standalone_mode = true`
+
+**If status file found:**
+
+Load the file and check:
+
+- Is this a game project? (`project_type == 'game'`)
+- Has brainstorm-game already been completed?
+- Is this the next expected workflow?
+
+Handle each scenario appropriately with user prompts.
+
+### 2. Set Brainstorming Mindset
+
+"**Welcome to Game Brainstorming!**
+
+{{user_name}}, let's explore game ideas together.
+
+**Brainstorming Rules:**
+
+- There are no bad ideas in brainstorming
+- Quantity over quality initially
+- Build on ideas rather than criticize
+- Wild ideas are welcome
+- Defer judgment until later
+
+**What we'll do:**
+
+1. Load game-specific brainstorming techniques
+2. Explore your game concepts using various methods
+3. Capture and organize all ideas
+4. Save results for future refinement
+
+Ready to start brainstorming? [Y/N]"
+
+### 3. Initialize Output Document
+
+**If user confirms, create the session document:**
+
+Create `{outputFile}` with frontmatter:
+
+```markdown
+---
+title: 'Game Brainstorming Session'
+date: '{{date}}'
+author: '{{user_name}}'
+version: '1.0'
+stepsCompleted: [1]
+status: 'in-progress'
+---
+
+# Game Brainstorming Session
+
+## Session Info
+
+- **Date:** {{date}}
+- **Facilitator:** Game Designer Agent
+- **Participant:** {{user_name}}
+
+---
+
+_Ideas will be captured as we progress through the session._
+```
+
+### 4. Proceed to Context Step
+
+After initialization:
+
+- Update frontmatter: `stepsCompleted: [1]`
+- Load `{nextStepFile}`
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Workflow status checked appropriately
+- User confirmed ready to brainstorm
+- Output document initialized
+- Brainstorming mindset established
+- Frontmatter updated with stepsCompleted: [1]
+
+### SYSTEM FAILURE:
+
+- Starting without user confirmation
+- Not checking workflow status
+- Missing document initialization
+- Not setting brainstorming tone
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-02-context.md

@@ -0,0 +1,210 @@
+---
+name: 'step-02-context'
+description: 'Load game-specific brainstorming context and techniques'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-02-context.md'
+nextStepFile: '{workflow_path}/steps/step-03-ideation.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/brainstorming-session-{date}.md'
+
+# Context Files
+gameContext: '{workflow_path}/game-context.md'
+gameBrainMethods: '{workflow_path}/game-brain-methods.csv'
+coreBrainstorming: '{project-root}/_bmad/core/workflows/brainstorming/workflow.yaml'
+---
+
+# Step 2: Load Context
+
+**Progress: Step 2 of 4** - Next: Ideation Session
+
+## STEP GOAL:
+
+Load game-specific brainstorming context and techniques to guide the ideation session. Merge game techniques with core brainstorming methods.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a creative game design facilitator
+- Game-specific techniques enhance standard brainstorming
+- Understand various ideation methods deeply
+
+### Step-Specific Rules:
+
+- Load all context files completely
+- Present technique options to user
+- Let user select preferred approach
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after context loaded
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore technique combinations
+- **P (Party Mode)**: Get perspectives on approaches
+- **C (Continue)**: Confirm context and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Game Context
+
+**Load the game context document:**
+
+Read `{gameContext}` to understand:
+
+- Focus areas for game ideation
+- Key considerations for game design
+- Recommended techniques
+- Output structure guidance
+
+### 2. Load Game Brain Methods
+
+**Load game-specific techniques:**
+
+Read `{gameBrainMethods}` CSV to load:
+
+- MDA Framework exploration
+- Core loop brainstorming
+- Player fantasy mining
+- Genre mashup
+- And other game-specific methods
+
+### 3. Present Available Techniques
+
+"**Game Brainstorming Techniques Loaded!**
+
+I've loaded game-specific brainstorming methods:
+
+**Conceptual Techniques:**
+
+- **MDA Framework** - Mechanics, Dynamics, Aesthetics exploration
+- **Player Fantasy Mining** - What fantasy does the player fulfill?
+- **Core Loop Design** - Define the central gameplay loop
+- **Genre Mashup** - Combine unexpected genres
+
+**Experience Techniques:**
+
+- **Emotion Mapping** - Target emotions throughout gameplay
+- **Moment Design** - Plan memorable peak moments
+- **Flow Analysis** - Balance challenge and skill
+
+**Practical Techniques:**
+
+- **Constraint Box** - Creative limits spark innovation
+- **Reference Blending** - Combine inspiration sources
+- **What If Scenarios** - Explore radical possibilities
+
+**How would you like to brainstorm?**
+
+1. **Guided** - I'll walk you through techniques one by one
+2. **Selective** - Choose specific techniques to use
+3. **Freeform** - Open exploration with techniques as needed
+4. **YOLO** - Let me drive the session with all techniques
+
+Your preference:"
+
+### 4. Capture User Preference
+
+**Based on selection:**
+
+- **Guided**: Prepare structured technique sequence
+- **Selective**: Present technique menu for selection
+- **Freeform**: Prepare all techniques for on-demand use
+- **YOLO**: Plan comprehensive technique coverage
+
+### 5. Generate Context Section
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Brainstorming Approach
+
+**Selected Mode:** {{selected_mode}}
+
+**Techniques Available:**
+{{technique_list}}
+
+**Focus Areas:**
+{{focus_areas_from_context}}
+```
+
+### 6. Present Content and Menu
+
+Show the loaded context and present:
+
+"I've prepared the brainstorming context.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Ready to start ideation?**
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore technique combinations
+[P] Party Mode - Get perspectives on approaches
+[C] Continue - Save this and move to Ideation Session (Step 3 of 4)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Explore technique combinations and synergies
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Get multiple perspectives on brainstorming approaches
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the context section to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [context saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Game context loaded completely
+- Game brain methods loaded from CSV
+- Techniques presented clearly
+- User selected brainstorming approach
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2]
+
+### SYSTEM FAILURE:
+
+- Not loading context files
+- Proceeding without user technique selection
+- Not presenting A/P/C menu after context
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-03-ideation.md

@@ -0,0 +1,289 @@
+---
+name: 'step-03-ideation'
+description: 'Execute the brainstorming session with game-specific techniques'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-03-ideation.md'
+nextStepFile: '{workflow_path}/steps/step-04-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/brainstorming-session-{date}.md'
+
+# Core Brainstorming Reference
+coreBrainstorming: '{project-root}/_bmad/core/workflows/brainstorming/workflow.yaml'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 3: Ideation Session
+
+**Progress: Step 3 of 4** - Next: Complete Session
+
+## STEP GOAL:
+
+Facilitate the actual brainstorming session using selected techniques. Capture all ideas, concepts, and insights generated during the session.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a creative game design facilitator
+- Draw out user's ideas - don't generate for them
+- Use techniques to unlock creativity
+- ALL ideas are valid during brainstorming
+
+### Step-Specific Rules:
+
+- Apply selected techniques from Step 2
+- Capture EVERY idea, no matter how wild
+- Build on ideas rather than criticize
+- User drives the ideation; you facilitate
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after ideation session
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Dig deeper into promising ideas
+- **P (Party Mode)**: Get multiple perspectives on concepts
+- **C (Continue)**: Save ideas and complete session
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Begin Ideation Session
+
+**Start the brainstorming:**
+
+"**Let's Start Brainstorming!**
+
+Based on your selected approach ({{selected_mode}}), let's explore game ideas.
+
+**First Question:**
+What kind of game experience are you drawn to?
+
+Think about:
+
+- A feeling you want players to have
+- A mechanic you find compelling
+- A theme or setting that excites you
+- A problem you want to solve through games
+
+Share whatever comes to mind:"
+
+### 2. Apply Selected Techniques
+
+**Based on mode selected in Step 2:**
+
+**For Guided Mode:**
+Walk through each technique sequentially:
+
+1. **Player Fantasy Mining**
+   "What fantasy does your player want to fulfill? Being a hero? Building an empire? Surviving? Exploring? Describe the core fantasy."
+
+2. **Core Loop Brainstorming**
+   "What's the central action players repeat? Think: [Action] → [Reward/Feedback] → [Motivation to continue]"
+
+3. **MDA Framework**
+   "Let's explore: What Aesthetics (emotions)? What Dynamics (behaviors)? What Mechanics enable them?"
+
+4. **Genre Mashup**
+   "What two unexpected genres could combine? Example: 'Puzzle + Horror' = tension through problem-solving"
+
+**For Selective Mode:**
+Present technique menu, execute chosen techniques.
+
+**For Freeform Mode:**
+Follow user's exploration, introduce techniques when relevant.
+
+**For YOLO Mode:**
+Drive comprehensive exploration using all techniques.
+
+### 3. Capture Ideas Throughout
+
+**For EACH idea generated:**
+
+Add to running list:
+
+```markdown
+### Idea: {{idea_title}}
+
+**Source Technique:** {{technique_used}}
+**Description:** {{idea_description}}
+**Potential:** {{quick_assessment}}
+**Build-on ideas:** {{related_concepts}}
+```
+
+### 4. Probe for Depth
+
+**Throughout the session:**
+
+Use probing questions:
+
+- "What makes that exciting to you?"
+- "How would that feel moment-to-moment?"
+- "What's the twist that makes it unique?"
+- "What game does this remind you of, and how is it different?"
+- "What would the 'aha' moment be?"
+
+### 5. Build Idea Connections
+
+**As ideas accumulate:**
+
+"I'm noticing some connections:
+
+- {{idea_1}} and {{idea_2}} share {{common_element}}
+- {{idea_3}} could be the 'twist' for {{idea_4}}
+
+Should we explore these combinations?"
+
+### 6. Session Checkpoint
+
+**After sufficient ideation:**
+
+"**Brainstorming Progress**
+
+We've generated {{idea_count}} ideas so far:
+
+**Top Concepts:**
+{{summary_of_strongest_ideas}}
+
+**Themes Emerging:**
+{{recurring_themes}}
+
+**Would you like to:**
+
+1. Continue exploring (more techniques)
+2. Deep dive into a specific concept
+3. Wrap up and save what we have
+
+Your choice:"
+
+### 7. Generate Ideation Section
+
+Based on all ideas captured, prepare the content:
+
+```markdown
+## Ideas Generated
+
+### Concept 1: {{concept_name}}
+
+{{full_concept_description}}
+
+**Core Elements:**
+
+- {{element_1}}
+- {{element_2}}
+
+**Questions to Explore:**
+
+- {{question_1}}
+- {{question_2}}
+
+---
+
+### Concept 2: {{concept_name}}
+
+{{repeat_structure}}
+
+---
+
+## Themes and Patterns
+
+{{observed_themes}}
+
+## Promising Combinations
+
+{{combination_ideas}}
+
+## Raw Ideas List
+
+{{all_ideas_bullet_points}}
+```
+
+### 8. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"**Ideation Session Summary**
+
+Here's everything we captured:
+
+[Show the complete markdown content from step 7]
+
+**Session Stats:**
+
+- Ideas generated: {{count}}
+- Concepts developed: {{count}}
+- Themes identified: {{count}}
+
+**Select an Option:**
+[A] Advanced Elicitation - Dig deeper into promising ideas
+[P] Party Mode - Get multiple perspectives on concepts
+[C] Continue - Save ideas and complete session (Step 4 of 4)"
+
+### 9. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Deep dive into selected concepts
+- Ask user: "Accept these additions? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Get diverse perspectives on concepts
+- Ask user: "Accept these perspectives? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the ideation section to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [ideation content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- User drove the ideation
+- Multiple techniques applied
+- All ideas captured without judgment
+- Connections and themes identified
+- Ideas organized and summarized
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3]
+
+### SYSTEM FAILURE:
+
+- Generating ideas FOR the user instead of WITH them
+- Dismissing or criticizing ideas during session
+- Not capturing all ideas
+- Rushing through techniques
+- Not presenting A/P/C menu after ideation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-04-complete.md

@@ -0,0 +1,275 @@
+---
+name: 'step-04-complete'
+description: 'Complete the brainstorming session with summary and next steps'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/brainstorming-session-{date}.md'
+
+# Handoff References
+gameBriefWorkflow: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.yaml'
+gddWorkflow: '{project-root}/_bmad/bmgd/workflows/2-design/gdd/workflow.yaml'
+---
+
+# Step 4: Complete Session
+
+**Progress: Step 4 of 4** - Brainstorming Complete!
+
+## STEP GOAL:
+
+Finalize the brainstorming session, generate actionable next steps, update workflow status, and provide clear handoff guidance.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a creative game design facilitator
+- Help user identify most promising concepts
+- Provide clear path forward
+
+### Step-Specific Rules:
+
+- Highlight top 1-3 concepts for further development
+- Generate actionable next steps
+- Update workflow status if tracking enabled
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Generate final summary
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4]`
+- Present completion summary and next steps
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Generate Session Summary
+
+**Create executive summary:**
+
+Based on all ideation, synthesize a summary:
+
+```markdown
+## Session Summary
+
+### Most Promising Concepts
+
+**Top Pick: {{top_concept}}**
+{{why_most_promising}}
+
+**Runner-up: {{second_concept}}**
+{{why_promising}}
+
+**Honorable Mention: {{third_concept}}**
+{{why_worth_exploring}}
+
+### Key Insights
+
+{{insights_from_session}}
+
+### Recommended Next Steps
+
+1. {{next_step_1}}
+2. {{next_step_2}}
+3. {{next_step_3}}
+```
+
+### 2. Present Final Summary
+
+"**Brainstorming Session Complete!**
+
+{{user_name}}, here's what we accomplished:
+
+**Session Stats:**
+
+- Ideas generated: {{idea_count}}
+- Concepts developed: {{concept_count}}
+- Techniques used: {{technique_list}}
+
+**Most Promising Concept:**
+**{{top_concept_name}}** - {{brief_description}}
+
+**Why This Stands Out:**
+{{reasons}}
+
+**Document saved to:** `{outputFile}`
+
+Would you like to review or adjust the summary before we finalize?"
+
+### 3. Handle Review Requests
+
+**If user wants to review:**
+
+"Which would you like to review?
+
+1. Most Promising Concepts
+2. All Ideas Generated
+3. Session Insights
+4. Full Document
+
+Or type 'all' to see the complete document."
+
+### 4. Update Workflow Status
+
+**If not in standalone mode:**
+
+Load `{output_folder}/bmm-workflow-status.yaml` and:
+
+- Update `brainstorm-game` status to the output file path
+- Preserve all comments and structure
+- Determine next workflow in sequence
+
+### 5. Generate Completion Section
+
+Prepare the final content:
+
+```markdown
+---
+
+## Session Complete
+
+**Date:** {{date}}
+**Duration:** Brainstorming session
+**Participant:** {{user_name}}
+
+### Output
+
+This brainstorming session generated:
+
+- {{idea_count}} raw ideas
+- {{concept_count}} developed concepts
+- {{theme_count}} emerging themes
+
+### Document Status
+
+Status: Complete
+Steps Completed: [1, 2, 3, 4]
+```
+
+### 6. Present Next Steps Menu
+
+"**Recommended Next Steps:**
+
+1. **Create Game Brief** - Transform your top concept into a formal game brief
+   - Workflow: `create-brief`
+   - Input: This brainstorming session
+   - Output: Structured game vision document
+
+2. **Research Market** - Validate your concept against the market
+   - Look at similar games
+   - Identify your unique angle
+   - Understand competition
+
+3. **Prototype Core Mechanic** - Test your core idea immediately
+   - Quick paper prototype
+   - Simple digital prototype
+   - Get hands-on feel for the concept
+
+4. **Another Brainstorm Session** - Explore more concepts
+   - Try different techniques
+   - Explore alternative directions
+
+**Which would you like to do next?**
+
+1. Start Game Brief workflow
+2. Review the brainstorming results
+3. Run another brainstorm session
+4. Exit workflow"
+
+### 7. Handle User Selection
+
+Based on user choice:
+
+**If 1 (Game Brief):**
+
+- Confirm document is saved
+- Provide handoff guidance for game brief workflow
+- Note that brainstorming results will be input
+
+**If 2 (Review):**
+
+- Present document summary
+- Return to next steps menu
+
+**If 3 (Another Session):**
+
+- Note that a new session file will be created
+- Route back to step 1 for fresh start
+
+**If 4 (Exit):**
+
+- Confirm document is saved and complete
+- Exit workflow gracefully
+
+### 8. Final Completion Message
+
+"**Brainstorming Session Complete!**
+
+**Deliverables:**
+
+- Brainstorming results saved to: `{outputFile}`
+- {{idea_count}} ideas captured
+- Top concepts identified and summarized
+
+{{#if standalone_mode != true}}
+**Status Updated:**
+
+- Progress tracking updated: brainstorm-game marked complete
+- Next recommended: Game Brief workflow
+  {{/if}}
+
+**Your Ideas Are Ready For:**
+
+- Game Brief creation
+- Concept validation
+- Prototyping
+- Team discussion
+
+Great brainstorming session, {{user_name}}! Your creativity is the foundation for an exciting game."
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Top concepts identified and highlighted
+- Session summary generated
+- Actionable next steps provided
+- Workflow status updated (if tracking)
+- Document saved and complete
+- Clear handoff guidance provided
+- Frontmatter shows all 4 steps completed
+
+### SYSTEM FAILURE:
+
+- No clear top concepts identified
+- Missing session summary
+- No actionable next steps
+- Status not updated when tracking enabled
+- User left without guidance
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+---
+
+## Brainstorm Game Workflow Complete
+
+The Brainstorm Game workflow facilitates creative game ideation through 4 collaborative steps:
+
+1. **Initialize** - Set brainstorming mindset and prepare session
+2. **Context** - Load game-specific techniques and select approach
+3. **Ideation** - Execute brainstorming with user driving ideas
+4. **Complete** - Summarize results and provide next steps
+
+This step-file architecture ensures consistent, creative brainstorming with user collaboration throughout.

src/modules/bmgd/workflows/1-preproduction/brainstorm-game/workflow.md

@@ -0,0 +1,49 @@
+# Brainstorm Game Workflow
+
+**Facilitate game brainstorming sessions with game-specific context and techniques**
+
+## Overview
+
+This workflow orchestrates creative brainstorming for game ideas by combining the core CIS brainstorming workflow with game-specific context, guidance, and specialized game design techniques.
+
+## Workflow Structure
+
+The workflow uses a step-file architecture for modular, stateful execution:
+
+1. **Step 1: Initialize** - Validate workflow readiness and discover context
+2. **Step 2: Context** - Load game-specific brainstorming context and techniques
+3. **Step 3: Ideation** - Execute brainstorming with game techniques
+4. **Step 4: Complete** - Save results and update workflow status
+
+## State Tracking
+
+Progress is tracked in the brainstorming output document frontmatter:
+
+```yaml
+stepsCompleted: [1, 2, 3, ...] # Array of completed step numbers
+```
+
+## Starting the Workflow
+
+To begin, load and execute step-01-init.md:
+
+```
+{workflow_path}/steps/step-01-init.md
+```
+
+## Critical Rules
+
+- This is a meta-workflow that orchestrates CIS brainstorming
+- Use game-specific techniques from game-brain-methods.csv
+- Apply game-context.md guidance throughout
+- **NEVER** mention time estimates
+- **ALWAYS** wait for user input between steps
+
+## Agent Role
+
+You are a creative facilitator specializing in game ideation:
+
+- Draw out user's game concepts and ideas
+- Apply game-specific brainstorming techniques
+- Help users explore mechanics, themes, and experiences
+- Capture and organize ideas for later refinement

src/modules/bmgd/workflows/1-preproduction/brainstorm-game/workflow.yaml

@@ -1,6 +1,6 @@
 # Brainstorm Game Workflow Configuration
 name: "brainstorm-game"
-description: "Facilitate game brainstorming sessions by orchestrating the CIS brainstorming workflow with game-specific context, guidance, and additional game design techniques."
+description: "Facilitate game brainstorming sessions with game-specific context, guidance, and game design techniques."
 author: "BMad"
 
 # Critical variables from config
@@ -12,30 +12,51 @@ document_output_language: "{config_source}:document_output_language"
 game_dev_experience: "{config_source}:game_dev_experience"
 date: system-generated
 
-# Module path and component files
+# Workflow components - Step-file architecture
 installed_path: "{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game"
+instructions: "{installed_path}/workflow.md"
 template: false
-instructions: "{installed_path}/instructions.md"
 
 # Context and techniques for game brainstorming
 game_context: "{installed_path}/game-context.md"
 game_brain_methods: "{installed_path}/game-brain-methods.csv"
 
-# CORE brainstorming workflow to invoke
+# CORE brainstorming workflow reference (for technique merging)
 core_brainstorming: "{project-root}/_bmad/core/workflows/brainstorming/workflow.yaml"
 
+# Output configuration
+default_output_file: "{output_folder}/brainstorming-session-{date}.md"
+
+# Workflow metadata
+version: "2.0.0"
+paradigm: "step-file-architecture"
+features:
+  - "Step-file architecture for modular execution"
+  - "Game-specific brainstorming techniques"
+  - "MDA Framework exploration"
+  - "Core loop brainstorming"
+  - "Player fantasy mining"
+  - "Genre mashup ideation"
+  - "State tracking via frontmatter"
+
 standalone: true
 
 web_bundle:
   name: "brainstorm-game"
-  description: "Facilitate game brainstorming sessions by orchestrating the CIS brainstorming workflow with game-specific context, guidance, and additional game design techniques."
+  description: "Facilitate game brainstorming sessions with game-specific context and techniques"
   author: "BMad"
-  instructions: "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/instructions.md"
+  instructions: "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/workflow.md"
   template: false
   web_bundle_files:
-    - "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/instructions.md"
+    # Main workflow file
+    - "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/workflow.md"
+    # Step files
+    - "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-01-init.md"
+    - "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-02-context.md"
+    - "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-03-ideation.md"
+    - "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-04-complete.md"
+    # Context files
     - "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/game-context.md"
     - "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/game-brain-methods.csv"
-    - "_bmad/core/workflows/brainstorming/workflow.yaml"
   existing_workflows:
     - core_brainstorming: "_bmad/core/workflows/brainstorming/workflow.yaml"

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-01-init.md

@@ -0,0 +1,223 @@
+---
+name: 'step-01-init'
+description: 'Initialize the Game Brief workflow by detecting continuation state and setting up the document'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-init.md'
+nextStepFile: '{workflow_path}/steps/step-02-vision.md'
+continueStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+
+# Template References
+briefTemplate: '{workflow_path}/templates/game-brief-template.md'
+---
+
+# Step 1: Workflow Initialization
+
+**Progress: Step 1 of 8** - Next: Game Vision
+
+## STEP GOAL:
+
+Initialize the Game Brief workflow by detecting continuation state, discovering any input documents (brainstorming, research), and setting up the document structure.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- If you already have been given a name, communication_style and persona, continue to use those while playing this new role
+- We engage in collaborative dialogue, not command-response
+- You bring structured game design thinking and facilitation skills
+
+### Step-Specific Rules:
+
+- Focus only on initialization and setup - no content generation yet
+- FORBIDDEN to look ahead to future steps or assume knowledge from them
+- Approach: Systematic setup with clear reporting to user
+- Detect existing workflow state and handle continuation properly
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis of current state before taking any action
+- Initialize document structure and update frontmatter appropriately
+- Set up frontmatter `stepsCompleted: [1]` before loading next step
+- FORBIDDEN to load next step until user selects 'C' (Continue)
+
+## CONTEXT BOUNDARIES:
+
+- Available context: Variables from workflow.md are available in memory
+- Focus: Workflow initialization and document setup only
+- Limits: Don't assume knowledge from other steps or create content yet
+- Dependencies: Configuration loaded from workflow.md initialization
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Check for Existing Workflow State
+
+First, check if the output document already exists:
+
+**Workflow State Detection:**
+
+- Look for file at `{outputFile}`
+- If exists, read the complete file including frontmatter
+- If not exists, this is a fresh workflow
+
+### 2. Handle Continuation (If Document Exists)
+
+If the document exists and has frontmatter with `stepsCompleted`:
+
+**Continuation Protocol:**
+
+- **STOP immediately** and load `{continueStepFile}`
+- Do not proceed with any initialization tasks
+- Let step-01b handle all continuation logic
+- This is an auto-proceed situation - no user choice needed
+
+### 3. Fresh Workflow Setup (If No Document)
+
+If no document exists or no `stepsCompleted` in frontmatter:
+
+#### A. Input Document Discovery
+
+Discover and load context documents using smart discovery.
+
+**IMPORTANT: Track document counts as you discover files.**
+
+Initialize counters:
+
+```
+brainstormingCount = 0
+researchCount = 0
+notesCount = 0
+```
+
+**Brainstorming Documents:**
+
+1. Check: `{output_folder}/*brainstorm*.md`
+2. Check: `{output_folder}/analysis/*brainstorm*.md`
+3. Load completely and extract key ideas
+4. **Update brainstormingCount with number of files found**
+
+**Research Documents:**
+
+1. Check: `{output_folder}/*research*.md`
+2. Check: `{output_folder}/analysis/*research*.md`
+3. Load useful research files completely
+4. **Update researchCount with number of files found**
+
+**Design Notes:**
+
+1. Check: `{output_folder}/*notes*.md` or `{output_folder}/*design*.md`
+2. Load any relevant design notes
+3. **Update notesCount with number of files found**
+
+**Loading Rules:**
+
+- Load ALL discovered files completely (no offset/limit)
+- Track all successfully loaded files in frontmatter `inputDocuments` array
+
+#### B. Create Initial Document
+
+**Document Setup:**
+
+- Copy the template from `{briefTemplate}` to `{outputFile}`
+- Initialize frontmatter with proper structure:
+
+```yaml
+---
+stepsCompleted: []
+inputDocuments: []
+documentCounts:
+  brainstorming: { { brainstormingCount } }
+  research: { { researchCount } }
+  notes: { { notesCount } }
+workflowType: 'game-brief'
+lastStep: 0
+project_name: '{{project_name}}'
+user_name: '{{user_name}}'
+date: '{{date}}'
+game_name: ''
+---
+```
+
+#### C. Present Initialization Results
+
+**Setup Report to User:**
+
+"Welcome {{user_name}}! I've set up your Game Brief workspace.
+
+**Document Setup:**
+
+- Created: `{outputFile}` from template
+- Initialized frontmatter with workflow state
+
+**Input Documents Discovered:**
+
+- Brainstorming: {{brainstormingCount}} files {if brainstormingCount > 0}loaded{else}(none found){/if}
+- Research: {{researchCount}} files {if researchCount > 0}loaded{else}(none found){/if}
+- Design notes: {{notesCount}} files {if notesCount > 0}loaded{else}(none found){/if}
+
+{if any_documents_found}
+I'll use these documents to give us a head start on your game brief.
+{else}
+We'll start fresh and build your game vision together through conversation.
+{/if}
+
+Do you have any other documents you'd like me to include, or shall we continue?"
+
+### 4. Present MENU OPTIONS
+
+Display menu after setup report:
+
+"[C] Continue - Save this and move to Game Vision (Step 2 of 8)"
+
+#### Menu Handling Logic:
+
+- IF C: Update frontmatter with `stepsCompleted: [1]`, then load, read entire file, then execute {nextStepFile}
+- IF user provides additional files: Load them, update inputDocuments and documentCounts, redisplay report
+- IF user asks questions: Answer and redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [frontmatter properly updated with stepsCompleted: [1] and documentCounts], will you then load and read fully `{nextStepFile}` to execute and begin game vision discovery.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Existing workflow detected and properly handed off to step-01b
+- Fresh workflow initialized with template and proper frontmatter
+- Input documents discovered and loaded
+- All discovered files tracked in frontmatter `inputDocuments`
+- **Document counts stored in frontmatter `documentCounts`**
+- Menu presented and user input handled correctly
+- Frontmatter updated with `stepsCompleted: [1]` before proceeding
+
+### SYSTEM FAILURE:
+
+- Proceeding with fresh initialization when existing workflow exists
+- Not updating frontmatter with discovered input documents
+- **Not storing document counts in frontmatter**
+- Creating document without proper template structure
+- Proceeding without user selecting 'C' (Continue)
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-01b-continue.md

@@ -0,0 +1,151 @@
+---
+name: 'step-01b-continue'
+description: 'Resume an interrupted Game Brief workflow from the last completed step'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+---
+
+# Step 1B: Workflow Continuation
+
+## STEP GOAL:
+
+Resume the Game Brief workflow from where it was left off, ensuring smooth continuation with full context restoration.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- Resume workflow from exact point where it was interrupted
+
+### Step-Specific Rules:
+
+- FOCUS on understanding where we left off and continuing appropriately
+- FORBIDDEN to modify content completed in previous steps
+- Only reload documents that were already tracked in `inputDocuments`
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis of current state before taking action
+- Keep existing frontmatter `stepsCompleted` values
+- Only load documents that were already tracked in `inputDocuments`
+- FORBIDDEN to discover new input documents during continuation
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Analyze Current State
+
+**State Assessment:**
+Review the frontmatter to understand:
+
+- `stepsCompleted`: Which steps are already done
+- `lastStep`: The most recently completed step number
+- `inputDocuments`: What context was already loaded
+- `documentCounts`: brainstorming, research, notes counts
+- `game_name`: The game name (if set)
+- All other frontmatter variables
+
+### 2. Restore Context Documents
+
+**Context Reloading:**
+
+- For each document in `inputDocuments`, load the complete file
+- This ensures you have full context for continuation
+- Don't discover new documents - only reload what was previously processed
+
+### 3. Present Current Progress
+
+**Progress Report to User:**
+"Welcome back {{user_name}}! I'm resuming our Game Brief collaboration for {{game_name or project_name}}.
+
+**Current Progress:**
+
+- Steps completed: {stepsCompleted}
+- Last worked on: Step {lastStep}
+- Context documents available: {len(inputDocuments)} files
+
+**Document Status:**
+
+- Current Game Brief is ready with all completed sections
+- Ready to continue from where we left off
+
+Does this look right, or do you want to make any adjustments before we proceed?"
+
+### 4. Determine Continuation Path
+
+**Next Step Logic:**
+Based on `lastStep` value, determine which step to load next:
+
+- If `lastStep = 1` -> Load `./step-02-vision.md`
+- If `lastStep = 2` -> Load `./step-03-market.md`
+- If `lastStep = 3` -> Load `./step-04-fundamentals.md`
+- If `lastStep = 4` -> Load `./step-05-scope.md`
+- If `lastStep = 5` -> Load `./step-06-references.md`
+- If `lastStep = 6` -> Load `./step-07-content.md`
+- If `lastStep = 7` -> Load `./step-08-complete.md`
+- If `lastStep = 8` -> Workflow already complete
+
+### 5. Handle Workflow Completion
+
+**If workflow already complete (`lastStep = 8`):**
+"Great news! It looks like we've already completed the Game Brief workflow for {{game_name}}.
+
+The final document is ready at `{outputFile}` with all sections completed.
+
+Would you like me to:
+
+- Review the completed brief with you
+- Suggest next workflow steps (like GDD creation)
+- Start a new brief revision
+
+What would be most helpful?"
+
+### 6. Present MENU OPTIONS
+
+**If workflow not complete:**
+Display: "Ready to continue with Step {nextStepNumber}?
+
+**Select an Option:** [C] Continue to next step"
+
+#### Menu Handling Logic:
+
+- IF C: Load, read entire file, then execute the appropriate next step file based on `lastStep`
+- IF Any other comments or queries: respond and redisplay menu
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [current state confirmed], will you then load and read fully the appropriate next step file to resume the workflow.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- All previous input documents successfully reloaded
+- Current workflow state accurately analyzed and presented
+- User confirms understanding of progress before continuation
+- Correct next step identified and prepared for loading
+
+### SYSTEM FAILURE:
+
+- Discovering new input documents instead of reloading existing ones
+- Modifying content from already completed steps
+- Loading wrong next step based on `lastStep` value
+- Proceeding without user confirmation of current state
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-02-vision.md

@@ -0,0 +1,218 @@
+---
+name: 'step-02-vision'
+description: 'Define the core game vision including name, concept, pitch, and vision statement'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-02-vision.md'
+nextStepFile: '{workflow_path}/steps/step-03-market.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 2: Game Vision
+
+**Progress: Step 2 of 8** - Next: Target Market
+
+## STEP GOAL:
+
+Capture the core game vision including the working title, one-sentence concept, elevator pitch, and aspirational vision statement that will guide all design decisions.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Vision is the foundation - get it right before moving forward
+- Challenge vague language and elevate compelling ideas
+
+### Step-Specific Rules:
+
+- Focus on crystallizing the game's core identity
+- FORBIDDEN to generate vision without real user input
+- Push for specificity and clarity
+- Reference successful games as examples of good pitches
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Dig deeper into the vision
+- **P (Party Mode)**: Get multiple perspectives on the vision
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Game Name Discovery
+
+**Start with the basics:**
+
+"Let's start with your game's identity.
+
+**What's the working title for your game?**
+
+(Don't worry if it's not final - working titles help us talk about the game and can always change later.)"
+
+Store in frontmatter: `game_name: '{user_provided_name}'`
+
+### 2. Context Check
+
+**If input documents were loaded:**
+
+"I've reviewed your {brainstorming/research} documents and noticed some interesting ideas:
+
+{summarize_key_themes_from_documents}
+
+Let's use these as a starting point for crystallizing your vision."
+
+### 3. Core Concept Discovery
+
+**Guide user through concept definition:**
+
+"Now let's capture the essence of {{game_name}} in a single sentence.
+
+**Examples of great one-sentence concepts:**
+
+- 'A roguelike deck-builder where you climb a mysterious spire' (Slay the Spire)
+- 'A precision platformer about climbing a mountain and overcoming anxiety' (Celeste)
+- 'A cozy farming sim where you rebuild your grandfather's farm and become part of a small town' (Stardew Valley)
+
+**What is {{game_name}}?** Give me one sentence that captures the core experience."
+
+### 4. Elevator Pitch Discovery
+
+**Build on the concept:**
+
+"Now let's expand that into an elevator pitch - 2-3 sentences that would compel a player or publisher to want to know more.
+
+**A great elevator pitch answers:**
+
+- What is it? (genre, style)
+- What do you do? (core action)
+- What makes it special? (hook)
+
+**Refine this until it hooks attention.** What's your elevator pitch for {{game_name}}?"
+
+### 5. Vision Statement Discovery
+
+**Explore the aspirational vision:**
+
+"Finally, let's capture your aspirational vision - the experience you want to create and what makes it meaningful.
+
+**Questions to consider:**
+
+- What feeling do you want players to have when they put down the controller?
+- What would make this game matter to someone?
+- What's your personal motivation for making this?
+
+**This is your North Star** - ambitious yet achievable. What's your vision for {{game_name}}?"
+
+### 6. Generate Vision Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Game Vision
+
+### Core Concept
+
+{{core_concept}}
+
+### Elevator Pitch
+
+{{elevator_pitch}}
+
+### Vision Statement
+
+{{vision_statement}}
+```
+
+### 7. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Game Vision section based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 6]
+
+**Validation Check:**
+
+- Does the core concept capture the essence?
+- Does the pitch hook attention?
+- Does the vision inspire?
+
+**Select an Option:**
+[A] Advanced Elicitation - Refine and strengthen the vision
+[P] Party Mode - Get other perspectives on the vision
+[C] Continue - Save this and move to Target Market (Step 3 of 8)"
+
+### 8. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2]`, `game_name: '{game_name}'`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [vision content saved with frontmatter updated including game_name], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Game name captured and stored in frontmatter
+- Core concept is clear and concise (one sentence)
+- Elevator pitch is compelling (2-3 sentences)
+- Vision statement is aspirational yet achievable
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2]
+
+### SYSTEM FAILURE:
+
+- Generating vision without user input
+- Core concept is vague or generic
+- Elevator pitch doesn't hook attention
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-03-market.md

@@ -0,0 +1,218 @@
+---
+name: 'step-03-market'
+description: 'Define target audience and market context'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-03-market.md'
+nextStepFile: '{workflow_path}/steps/step-04-fundamentals.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 3: Target Market
+
+**Progress: Step 3 of 8** - Next: Game Fundamentals
+
+## STEP GOAL:
+
+Define the primary and secondary target audiences with specific demographics, and establish the market context including competitive landscape and timing.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Push for specificity beyond generic descriptions
+- Challenge vague answers like "people who like fun games"
+
+### Step-Specific Rules:
+
+- Focus on who will actually play this game
+- FORBIDDEN to generate audience without real user input
+- Help identify a realistic and reachable audience segment
+- Consider secondary audiences if applicable
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Dig deeper into audience insights
+- **P (Party Mode)**: Get multiple perspectives on market positioning
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Primary Audience Discovery
+
+**Guide user through audience definition:**
+
+"Let's define who {{game_name}} is really for.
+
+**Primary Audience Questions:**
+
+- **Age range:** Who are you designing for?
+- **Gaming experience:** Casual, core, or hardcore gamers?
+- **Genre familiarity:** Do they know this genre well, or are they new to it?
+- **Play patterns:** When and how do they play? (commute, evening sessions, weekends)
+- **Motivations:** What draws them to games like this?
+
+**Push for specificity:**
+'People who like roguelikes' is too broad. 'Experienced roguelike fans who want deeper deckbuilding strategy' is better.
+
+Who is your primary audience for {{game_name}}?"
+
+### 2. Secondary Audience Discovery
+
+**Explore additional audiences:**
+
+"Are there secondary audiences who might enjoy {{game_name}}?
+
+**Examples:**
+
+- Primary: Hardcore roguelike fans → Secondary: Strategy game players looking for something new
+- Primary: Cozy game fans → Secondary: Burnt-out competitive gamers seeking relaxation
+
+**If you have a secondary audience:**
+
+- How do their needs differ from primary?
+- What features might appeal specifically to them?
+
+Do you have a secondary audience in mind?"
+
+### 3. Market Context Discovery
+
+**Explore the competitive landscape:**
+
+"Let's understand the market context for {{game_name}}.
+
+**Market Questions:**
+
+- **Similar successful games:** What games have proven there's an audience?
+- **Market gaps:** What's missing that {{game_name}} could fill?
+- **Timing:** Why is now the right time for this game?
+- **Competition:** Who are you competing with for player attention?
+- **Discoverability:** How will players find your game?
+
+What does the market look like for {{game_name}}?"
+
+### 4. Generate Market Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Target Market
+
+### Primary Audience
+
+{{primary_audience_description}}
+
+**Demographics:**
+{{demographics}}
+
+**Gaming Preferences:**
+{{gaming_preferences}}
+
+**Motivations:**
+{{what_draws_them}}
+
+### Secondary Audience
+
+{{secondary_audience_description}}
+
+### Market Context
+
+{{market_context_analysis}}
+
+**Similar Successful Games:**
+{{comparable_titles}}
+
+**Market Opportunity:**
+{{why_now}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Target Market section based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Is the primary audience specific enough to guide design decisions?
+- Does the market context support the viability of this game?
+
+**Select an Option:**
+[A] Advanced Elicitation - Dig deeper into market insights
+[P] Party Mode - Get perspectives on market positioning
+[C] Continue - Save this and move to Game Fundamentals (Step 4 of 8)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [market content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Primary audience is specific and well-defined
+- Secondary audience considered (even if none exists)
+- Market context provides business rationale
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3]
+
+### SYSTEM FAILURE:
+
+- Generating audience without user input
+- Audience is too vague to guide decisions
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-04-fundamentals.md

@@ -0,0 +1,231 @@
+---
+name: 'step-04-fundamentals'
+description: 'Define core gameplay pillars, mechanics, and player experience goals'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-fundamentals.md'
+nextStepFile: '{workflow_path}/steps/step-05-scope.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 4: Game Fundamentals
+
+**Progress: Step 4 of 8** - Next: Scope & Constraints
+
+## STEP GOAL:
+
+Define the core gameplay pillars (fundamental design tenets), primary mechanics (what players do), and player experience goals (what feelings are designed for).
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Pillars are the "constitution" - everything must serve them
+- Connect mechanics directly to emotional experiences
+
+### Step-Specific Rules:
+
+- Focus on the core of what makes this game unique
+- FORBIDDEN to generate fundamentals without real user input
+- Ensure pillars are specific and measurable
+- Focus on player actions rather than implementation details
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Stress test the fundamentals
+- **P (Party Mode)**: Get perspectives on core design
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Core Pillars Discovery
+
+**Guide user through pillar definition:**
+
+"Let's define the core pillars for {{game_name}} - the 2-4 fundamental design tenets that everything must serve.
+
+**Examples of Great Pillars:**
+
+| Game               | Pillars                                                   |
+| ------------------ | --------------------------------------------------------- |
+| **Hollow Knight**  | Tight controls, challenging combat, rewarding exploration |
+| **Celeste**        | Precision movement, accessibility, emotional narrative    |
+| **Dead Cells**     | Mastery, variety, momentum                                |
+| **Stardew Valley** | Relaxation, progression, community                        |
+
+**Questions to consider:**
+
+- If a feature doesn't serve a pillar, should it be in the game?
+- When pillars conflict, which wins?
+
+What are the 2-4 core pillars for {{game_name}}?"
+
+### 2. Primary Mechanics Discovery
+
+**Explore what players actually do:**
+
+"Now let's define what players actually DO in {{game_name}}.
+
+**Think in verbs - what actions define the experience?**
+
+Examples:
+
+- Jump, dash, climb (movement)
+- Attack, dodge, parry (combat)
+- Craft, build, place (creation)
+- Talk, choose, influence (social)
+- Collect, trade, manage (economy)
+
+**Questions to consider:**
+
+- What's the core action players repeat most often?
+- What actions create the most satisfying moments?
+- How do different mechanics interact?
+
+What are the primary mechanics in {{game_name}}?"
+
+### 3. Experience Goals Discovery
+
+**Define the emotional targets:**
+
+"Finally, let's define the player experience goals - what feelings are you designing for?
+
+**Emotional Experience Framework:**
+
+| Emotion                   | Examples                               |
+| ------------------------- | -------------------------------------- |
+| **Tension/Relief**        | Horror games, difficult boss fights    |
+| **Mastery/Growth**        | Skill-based games, RPG progression     |
+| **Creativity/Expression** | Sandbox games, character customization |
+| **Discovery/Surprise**    | Exploration games, mystery narratives  |
+| **Connection/Belonging**  | Multiplayer, community-driven games    |
+| **Relaxation/Flow**       | Cozy games, rhythm games               |
+
+**Questions to consider:**
+
+- What feeling do you want players to have after a session?
+- What emotional journey happens during play?
+- What makes this experience meaningful?
+
+What are the player experience goals for {{game_name}}?"
+
+### 4. Generate Fundamentals Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Game Fundamentals
+
+### Core Gameplay Pillars
+
+{{pillars_with_descriptions}}
+
+**Pillar Priority:** When pillars conflict, prioritize:
+{{pillar_priority_order}}
+
+### Primary Mechanics
+
+{{mechanics_list_with_descriptions}}
+
+**Core Loop:** {{how_mechanics_combine_into_loop}}
+
+### Player Experience Goals
+
+{{experience_goals}}
+
+**Emotional Journey:** {{what_players_feel_during_play}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Game Fundamentals section based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Do all pillars support your vision?
+- Do mechanics serve the pillars?
+- Do experience goals match your audience?
+
+**Select an Option:**
+[A] Advanced Elicitation - Stress test these fundamentals
+[P] Party Mode - Get other perspectives on core design
+[C] Continue - Save this and move to Scope & Constraints (Step 5 of 8)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [fundamentals content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 2-4 clear, actionable pillars defined
+- Primary mechanics clearly described
+- Experience goals tied to audience and vision
+- Pillar priority established
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4]
+
+### SYSTEM FAILURE:
+
+- Generating fundamentals without user input
+- Generic pillars that don't guide decisions
+- Mechanics disconnected from experience goals
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-05-scope.md

@@ -0,0 +1,242 @@
+---
+name: 'step-05-scope'
+description: 'Define project scope including platforms, constraints, and resources'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-scope.md'
+nextStepFile: '{workflow_path}/steps/step-06-references.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 5: Scope & Constraints
+
+**Progress: Step 5 of 8** - Next: Reference Framework
+
+## STEP GOAL:
+
+Define realistic project constraints including target platforms, budget considerations, team resources, and technical constraints. Push for realism about scope.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Push for realism about constraints
+- Identify potential blockers early
+
+### Step-Specific Rules:
+
+- Focus on establishing realistic boundaries
+- FORBIDDEN to generate scope without real user input
+- Help identify skill gaps and resource assumptions
+- Document constraints that will affect design decisions
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Challenge assumptions about scope
+- **P (Party Mode)**: Get perspectives on feasibility
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Platform Discovery
+
+**Guide user through platform selection:**
+
+"Let's define where {{game_name}} will be played.
+
+**Platform Considerations:**
+
+| Platform       | Key Considerations                                      |
+| -------------- | ------------------------------------------------------- |
+| **PC (Steam)** | Keyboard/mouse, largest indie audience, most flexible   |
+| **Console**    | Controller-first, certification, couch play             |
+| **Mobile**     | Touch controls, short sessions, different monetization  |
+| **Web**        | Instant access, file size limits, browser compatibility |
+| **VR**         | Specialized hardware, motion controls, comfort          |
+
+**Questions to consider:**
+
+- Where does your target audience primarily play?
+- Which platform(s) are you targeting for launch?
+- Are there secondary platforms for later?
+
+What platform(s) are you targeting for {{game_name}}?"
+
+### 2. Budget Considerations
+
+**Explore financial constraints:**
+
+"Let's be realistic about budget constraints.
+
+**Budget Categories:**
+
+- **Development costs:** Tools, software, hardware
+- **Asset creation:** Art, audio, music (in-house vs outsource)
+- **Marketing:** Visibility, trailers, press
+- **Platform fees:** Store cuts, devkit costs
+- **External services:** Servers, analytics, localization
+
+**Questions to consider:**
+
+- What's your budget reality? (self-funded, funded, shoestring)
+- What can you create yourself vs need to outsource?
+- Are there areas where budget will limit scope?
+
+What are the budget considerations for {{game_name}}?"
+
+### 3. Team Resources Discovery
+
+**Assess team capabilities:**
+
+"Let's understand what team resources you have.
+
+**Resource Questions:**
+
+- **Team size:** Solo, small team, larger team?
+- **Roles covered:** Design, programming, art, audio, marketing?
+- **Availability:** Full-time, part-time, nights/weekends?
+- **Skill gaps:** What expertise is missing?
+- **Outsourcing:** What might need external help?
+
+What team resources do you have for {{game_name}}?"
+
+### 4. Technical Constraints Discovery
+
+**Identify technical boundaries:**
+
+"Finally, let's identify technical constraints.
+
+**Technical Considerations:**
+
+- **Engine/framework:** Already decided or open?
+- **Performance targets:** Frame rate, file size, load times?
+- **Technical experience:** Team's technical capabilities?
+- **Accessibility:** What accessibility features are required?
+- **Online features:** Multiplayer, leaderboards, cloud saves?
+
+What technical constraints apply to {{game_name}}?"
+
+### 5. Generate Scope Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Scope and Constraints
+
+### Target Platforms
+
+**Primary:** {{primary_platform}}
+**Secondary:** {{secondary_platforms}}
+
+### Budget Considerations
+
+{{budget_overview}}
+
+### Team Resources
+
+{{team_composition}}
+
+**Skill Gaps:** {{identified_gaps}}
+
+### Technical Constraints
+
+{{technical_constraints}}
+
+### Scope Realities
+
+{{scope_acknowledgements}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Scope & Constraints section based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Validation Check:**
+
+- Are these constraints realistic?
+- Have we identified potential blockers?
+- Is the scope achievable with these resources?
+
+**Select an Option:**
+[A] Advanced Elicitation - Challenge scope assumptions
+[P] Party Mode - Get perspectives on feasibility
+[C] Continue - Save this and move to Reference Framework (Step 6 of 8)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [scope content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Target platforms clearly defined
+- Budget constraints documented realistically
+- Team resources and gaps identified
+- Technical constraints established
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5]
+
+### SYSTEM FAILURE:
+
+- Generating scope without user input
+- Unrealistic constraints that set project up for failure
+- Missing critical blockers
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-06-references.md

@@ -0,0 +1,224 @@
+---
+name: 'step-06-references'
+description: 'Define inspiration games, competitive analysis, and key differentiators'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-references.md'
+nextStepFile: '{workflow_path}/steps/step-07-content.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 6: Reference Framework
+
+**Progress: Step 6 of 8** - Next: Content Framework
+
+## STEP GOAL:
+
+Identify inspiration games (what you're drawing from and NOT taking), analyze competition, and define concrete differentiators that make this game worth making.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Challenge "just better" thinking
+- Push for genuine, specific differentiation
+
+### Step-Specific Rules:
+
+- Focus on what makes this game unique
+- FORBIDDEN to generate references without real user input
+- Validate that differentiators are concrete and achievable
+- Understand both what you're taking AND what you're avoiding
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Challenge differentiation claims
+- **P (Party Mode)**: Get perspectives on uniqueness
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Inspiration Games Discovery
+
+**Guide user through references:**
+
+"Let's identify the games that inspire {{game_name}}.
+
+**For each inspiration game, I want to know:**
+
+1. **What game?**
+2. **What are you taking?** (mechanics, feel, art style, structure)
+3. **What are you NOT taking?** (equally important!)
+
+**Example:**
+
+- 'From Hades: the combat feel and build variety'
+- 'NOT from Hades: the roguelike structure or the dialogue system'
+
+What 3-5 games inspire {{game_name}}, and what specifically are you drawing from each?"
+
+### 2. Competitive Analysis Discovery
+
+**Explore the competition:**
+
+"Now let's analyze your competition.
+
+**Competition Questions:**
+
+- **Direct competitors:** Games that scratch the same itch
+- **What they do well:** Why do players love them?
+- **What they do poorly:** Where do they fall short?
+- **Market positioning:** How crowded is this space?
+
+**For {{game_name}}, who are you competing with?**
+
+Remember: if there are no competitors, that might mean there's no market. Some competition is healthy."
+
+### 3. Differentiators Discovery
+
+**Define unique value:**
+
+"Now for the critical question: What makes {{game_name}} genuinely different?
+
+**Differentiation Test:**
+
+A strong differentiator passes ALL of these:
+
+1. Is it concrete and achievable?
+2. Does it matter to your target audience?
+3. Can competitors easily copy it?
+4. Would you still make the game without it?
+
+**Challenge 'just better' thinking:**
+'Better graphics' or 'more content' aren't differentiators - they're expectations.
+
+What 2-4 things make {{game_name}} genuinely different and worth players' attention?"
+
+### 4. Generate References Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Reference Framework
+
+### Inspiration Games
+
+{{for_each_inspiration}}
+**{{game_name}}**
+
+- Taking: {{what_taking}}
+- Not Taking: {{what_avoiding}}
+  {{/for_each}}
+
+### Competitive Analysis
+
+**Direct Competitors:**
+{{competitors_list}}
+
+**Competitor Strengths:**
+{{what_they_do_well}}
+
+**Competitor Weaknesses:**
+{{where_they_fall_short}}
+
+### Key Differentiators
+
+{{differentiators_with_descriptions}}
+
+**Unique Value Proposition:**
+{{one_sentence_why_choose_this}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Reference Framework section based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Are differentiators genuine, not just features?
+- Does the competitive analysis reveal opportunity?
+- Are inspirations specific about what you're taking vs avoiding?
+
+**Select an Option:**
+[A] Advanced Elicitation - Challenge differentiation claims
+[P] Party Mode - Get perspectives on uniqueness
+[C] Continue - Save this and move to Content Framework (Step 7 of 8)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [references content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 3-5 inspiration games with specific takeaways
+- Competition analyzed with strengths and weaknesses
+- Differentiators are concrete and achievable
+- Unique value proposition is clear
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6]
+
+### SYSTEM FAILURE:
+
+- Generating references without user input
+- Generic differentiators like "better gameplay"
+- Missing the "not taking" aspect of inspirations
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-07-content.md

@@ -0,0 +1,282 @@
+---
+name: 'step-07-content'
+description: 'Define content framework, art/audio direction, and risk assessment'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-07-content.md'
+nextStepFile: '{workflow_path}/steps/step-08-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 7: Content & Production
+
+**Progress: Step 7 of 8** - Next: Final Review
+
+## STEP GOAL:
+
+Define the content framework (world, narrative approach, volume), art and audio direction, and assess key risks with mitigation strategies.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Ensure art/audio vision aligns with budget and team
+- Facilitate honest risk assessment
+
+### Step-Specific Rules:
+
+- Focus on production realities
+- FORBIDDEN to generate content framework without user input
+- Flag content-heavy areas that need planning
+- Prioritize risks by impact and likelihood
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into risks
+- **P (Party Mode)**: Get perspectives on feasibility
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. World & Setting Discovery
+
+**Explore the game's world:**
+
+"Let's define the world of {{game_name}}.
+
+**World Questions:**
+
+- **Setting:** Where and when does this take place?
+- **World-building depth:** How much lore matters?
+- **Narrative importance:** Story-driven or story-light?
+- **Atmosphere:** What mood should the world evoke?
+
+Describe the world and setting for {{game_name}}."
+
+### 2. Narrative Approach Discovery
+
+**Define storytelling strategy:**
+
+"How will {{game_name}} handle narrative?
+
+**Narrative Approaches:**
+
+| Approach          | Examples                                  |
+| ----------------- | ----------------------------------------- |
+| **Story-Driven**  | Linear narrative with cutscenes, dialogue |
+| **Environmental** | Story told through world, items, visuals  |
+| **Emergent**      | Player creates their own stories          |
+| **Minimal**       | Pure gameplay, little to no story         |
+
+**Questions:**
+
+- How is story delivered? (cutscenes, dialogue, text, environmental)
+- Is there a dedicated narrative workflow needed later?
+
+What's the narrative approach for {{game_name}}?"
+
+### 3. Art & Audio Direction Discovery
+
+**Establish aesthetic vision:**
+
+"Let's define the look and sound of {{game_name}}.
+
+**Visual Style:**
+
+- Art style (pixel, low-poly, stylized 3D, realistic)
+- Color palette and mood
+- Reference games or images
+- Animation complexity
+
+**Audio Style:**
+
+- Music genre and mood
+- Sound effect approach
+- Voice acting scope (none, grunts, partial, full)
+
+**Production Reality:**
+
+- What can be created in-house?
+- What needs outsourcing?
+- Are asset store/AI tools acceptable?
+
+Describe the art and audio direction for {{game_name}}."
+
+### 4. Risk Assessment Discovery
+
+**Facilitate honest risk evaluation:**
+
+"Now let's honestly assess the risks for {{game_name}}.
+
+**Risk Categories:**
+
+| Category      | Questions                               |
+| ------------- | --------------------------------------- |
+| **Technical** | Unproven systems? Performance concerns? |
+| **Market**    | Saturated genre? Discoverability?       |
+| **Scope**     | Too ambitious? Feature creep?           |
+| **Team**      | Skill gaps? Availability?               |
+| **Financial** | Runway? Unexpected costs?               |
+
+**For each major risk:**
+
+- What could go wrong?
+- How likely is it?
+- What's the impact if it happens?
+- How can we mitigate it?
+
+What are the key risks for {{game_name}}?"
+
+### 5. Generate Content & Production Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Content Framework
+
+### World and Setting
+
+{{world_setting_description}}
+
+### Narrative Approach
+
+{{narrative_approach}}
+
+**Story Delivery:** {{how_story_delivered}}
+
+### Content Volume
+
+{{content_volume_estimates}}
+
+---
+
+## Art and Audio Direction
+
+### Visual Style
+
+{{visual_style_description}}
+
+**References:** {{reference_games_or_images}}
+
+### Audio Style
+
+{{audio_direction}}
+
+### Production Approach
+
+{{production_strategy}}
+
+---
+
+## Risk Assessment
+
+### Key Risks
+
+{{prioritized_risk_list}}
+
+### Technical Challenges
+
+{{technical_risks}}
+
+### Market Risks
+
+{{market_risks}}
+
+### Mitigation Strategies
+
+{{mitigation_strategies}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Content & Production section based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Validation Check:**
+
+- Does art/audio align with budget and team?
+- Have we identified the biggest risks?
+- Are mitigations actionable?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into risks
+[P] Party Mode - Get perspectives on feasibility
+[C] Continue - Save this and move to Final Review (Step 8 of 8)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- World and setting clearly defined
+- Narrative approach documented
+- Art/audio direction established
+- Risks prioritized with mitigations
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7]
+
+### SYSTEM FAILURE:
+
+- Generating content without user input
+- Art/audio vision misaligned with resources
+- Missing major risk categories
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-08-complete.md

@@ -0,0 +1,296 @@
+---
+name: 'step-08-complete'
+description: 'Define success criteria and complete the game brief with handoff guidance'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-08-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-brief.md'
+
+# Workflow References
+gddWorkflow: '{project-root}/_bmad/bmgd/workflows/2-design/gdd/workflow.yaml'
+---
+
+# Step 8: Success & Handoff
+
+**Progress: Step 8 of 8** - Game Brief Complete!
+
+## STEP GOAL:
+
+Define MVP scope, success metrics, immediate next steps, and provide clear handoff guidance for proceeding to GDD creation.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- This is the final step - ensure completeness
+- Provide actionable next steps
+
+### Step-Specific Rules:
+
+- Focus on measurable success criteria
+- Push for specificity - challenge vague aspirations
+- Clearly distinguish MVP from full release
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Generate final sections
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]`
+- Present completion summary and next steps
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. MVP Definition Discovery
+
+**Define minimum viable product:**
+
+"Let's define the MVP (Minimum Playable Version) for {{game_name}}.
+
+**MVP is the absolute minimum where:**
+
+- Core gameplay loop is fun and complete
+- Only essential content is included
+- It could stand alone as a playable experience
+
+**Questions:**
+
+- What features are absolutely required?
+- What content is the minimum to prove the concept?
+- What can be cut and added later?
+
+What's the MVP for {{game_name}}?"
+
+### 2. Success Metrics Discovery
+
+**Define measurable success:**
+
+"Let's define how you'll measure success for {{game_name}}.
+
+**Metric Categories:**
+
+| Category               | Examples                                |
+| ---------------------- | --------------------------------------- |
+| **Player Acquisition** | Wishlists, downloads, sales             |
+| **Engagement**         | Session length, retention, completion   |
+| **Quality**            | Review scores, bug reports              |
+| **Community**          | Discord members, streamers, fan content |
+| **Financial**          | Revenue, ROI, sustainability            |
+
+**For each metric, answer:** How will you measure that?
+
+What success metrics matter for {{game_name}}?"
+
+### 3. Immediate Actions Discovery
+
+**Identify next steps:**
+
+"What should happen immediately after this brief is complete?
+
+**Common Next Actions:**
+
+- Prototype core mechanic
+- Create art style test
+- Validate technical feasibility
+- Build vertical slice
+- Playtest with target audience
+- Proceed to GDD workflow
+
+**Open Questions:**
+
+- What design questions are still unresolved?
+- What assumptions need validation?
+- What blockers must be resolved?
+
+What are the immediate next steps for {{game_name}}?"
+
+### 4. Generate Executive Summary
+
+**Create summary section:**
+
+Based on all previous sections, synthesize an executive summary:
+
+```markdown
+## Executive Summary
+
+{{game_name}} is {{core_concept}}.
+
+**Target Audience:** {{primary_audience_summary}}
+
+**Core Pillars:** {{pillars_list}}
+
+**Key Differentiators:** {{top_differentiators}}
+
+**Platform:** {{primary_platform}}
+
+**Success Vision:** {{what_success_looks_like}}
+```
+
+### 5. Generate Success & Next Steps Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Success Criteria
+
+### MVP Definition
+
+{{mvp_scope}}
+
+### Success Metrics
+
+{{metrics_with_targets}}
+
+### Launch Goals
+
+{{launch_targets}}
+
+---
+
+## Next Steps
+
+### Immediate Actions
+
+{{prioritized_action_list}}
+
+### Research Needs
+
+{{research_requirements}}
+
+### Open Questions
+
+{{unresolved_questions}}
+```
+
+### 6. Present Completion Summary
+
+"**Game Brief Complete!**
+
+{{user_name}}, the Game Brief for **{{game_name}}** is now complete!
+
+**Brief Summary:**
+
+- **Core Concept:** {{core_concept}}
+- **Target Audience:** {{primary_audience}}
+- **Pillars:** {{pillars}}
+- **Platform:** {{platform}}
+
+**Sections Completed:**
+
+1. Game Vision
+2. Target Market
+3. Game Fundamentals
+4. Scope & Constraints
+5. Reference Framework
+6. Content & Production
+7. Success Criteria
+8. Next Steps
+
+**Document saved to:** `{outputFile}`
+
+Do you want to review or adjust anything before we finalize?"
+
+### 7. Present Next Steps Menu
+
+**After user confirms completion:**
+
+"**Recommended Next Steps for {{game_name}}:**
+
+1. **Create GDD** - Transform this brief into a detailed Game Design Document
+   - Command: `create-gdd` (Game Designer agent)
+   - Input: This game brief
+   - Output: Comprehensive GDD
+
+2. **Prototype Core Mechanic** - Validate gameplay before full production
+
+3. **Art Style Test** - Validate visual direction
+
+4. **Market Validation** - Test interest with target audience
+
+**Which would you like to do next?**
+
+1. Start GDD workflow
+2. Review the completed brief
+3. Exit workflow"
+
+### 8. Handle User Selection
+
+Based on user choice:
+
+**If 1 (Start GDD):**
+
+- Update frontmatter with final `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]`
+- Provide handoff guidance for GDD workflow
+
+**If 2 (Review):**
+
+- Present full document summary
+- Return to next steps menu
+
+**If 3 (Exit):**
+
+- Update frontmatter with final stepsCompleted
+- Confirm brief is saved
+- Exit workflow gracefully
+
+## CRITICAL STEP COMPLETION NOTE
+
+This is the final step. Ensure:
+
+- Executive summary is generated
+- All content is saved to game-brief.md
+- Frontmatter shows all 8 steps completed
+- User has clear actionable next steps
+- Handoff to GDD workflow is smooth
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- MVP clearly scoped
+- Success metrics are measurable
+- Immediate actions are actionable
+- Executive summary synthesizes the brief
+- Document is complete and saved
+- Clear next steps provided
+- Frontmatter updated with all steps completed
+
+### SYSTEM FAILURE:
+
+- Missing MVP definition
+- Vague success metrics that can't be measured
+- No clear next steps
+- Frontmatter not updated to show completion
+- User left without actionable guidance
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+---
+
+## Game Brief Workflow Complete
+
+The Game Brief workflow transforms a game idea into a validated vision through 8 collaborative steps:
+
+1. **Initialize** - Set up workflow and discover input documents
+2. **Vision** - Capture core concept, pitch, and vision statement
+3. **Market** - Define target audience and market context
+4. **Fundamentals** - Establish pillars, mechanics, and experience goals
+5. **Scope** - Set realistic constraints and resources
+6. **References** - Identify inspirations and differentiators
+7. **Content** - Define world, art/audio, and assess risks
+8. **Complete** - Set success criteria and provide handoff
+
+This step-file architecture ensures consistent, thorough game brief creation with user collaboration at every step.

src/modules/bmgd/workflows/1-preproduction/game-brief/workflow.md

@@ -0,0 +1,62 @@
+---
+name: create-game-brief
+description: Creates a comprehensive Game Brief through collaborative step-by-step discovery to capture game vision before detailed design.
+main_config: '{project-root}/_bmad/bmgd/config.yaml'
+web_bundle: true
+---
+
+# Game Brief Workflow
+
+**Goal:** Create comprehensive Game Briefs through collaborative step-by-step discovery to capture and validate the core game vision before detailed design work.
+
+**Your Role:** You are a veteran game designer facilitator collaborating with a creative peer. This is a partnership, not a client-vendor relationship. You bring structured game design thinking and market awareness, while the user brings their game vision and creative ideas. Work together as equals. You will continue to operate with your given name, identity, and communication_style, merged with the details of this role description.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self contained instruction file that is a part of an overall workflow that must be followed exactly
+- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
+- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
+- **Append-Only Building**: Build documents by appending content as directed to the output file
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, load, read entire file, then execute the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- NEVER load multiple step files simultaneously
+- ALWAYS read entire step file before execution
+- NEVER skip steps or optimize the sequence
+- ALWAYS update frontmatter of output files when writing the final output for a specific step
+- ALWAYS follow the exact instructions in the step file
+- ALWAYS halt at menus and wait for user input
+- NEVER create mental todo lists from future steps
+- NEVER mention time estimates
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from {main_config} and resolve:
+
+- `project_name`, `output_folder`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+
+### 2. First Step EXECUTION
+
+Load, read the full file and then execute `steps/step-01-init.md` to begin the workflow.

src/modules/bmgd/workflows/1-preproduction/game-brief/workflow.yaml

@@ -12,14 +12,34 @@ document_output_language: "{config_source}:document_output_language"
 game_dev_experience: "{config_source}:game_dev_experience"
 date: system-generated
 
-# Module path and component files
+# Workflow components - Step-file architecture
 installed_path: "{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief"
-template: "{installed_path}/template.md"
-instructions: "{installed_path}/instructions.md"
+instructions: "{installed_path}/workflow.md"
+template: "{installed_path}/templates/game-brief-template.md"
 validation: "{installed_path}/checklist.md"
 
+# Smart input file references - handles brainstorming/research docs
+input_file_patterns:
+  brainstorm:
+    description: "Brainstorming or ideation documents (optional)"
+    whole: "{output_folder}/*brainstorm*.md"
+    sharded: "{output_folder}/*brainstorm*/index.md"
+    load_strategy: "FULL_LOAD"
+
+  research:
+    description: "Market or domain research (optional)"
+    whole: "{output_folder}/*research*.md"
+    sharded: "{output_folder}/*research*/index.md"
+    load_strategy: "FULL_LOAD"
+
+  inspiration:
+    description: "Inspiration or reference documents (optional)"
+    whole: "{output_folder}/*inspiration*.md"
+    sharded: "{output_folder}/*inspiration*/index.md"
+    load_strategy: "FULL_LOAD"
+
 # Output configuration
-default_output_file: "{output_folder}/game-brief-{{game_name}}-{{date}}.md"
+default_output_file: "{output_folder}/game-brief.md"
 
 standalone: true
 
@@ -27,10 +47,21 @@ web_bundle:
   name: "game-brief"
   description: "Interactive game brief creation workflow that guides users through defining their game vision with multiple input sources and conversational collaboration"
   author: "BMad"
-  instructions: "_bmad/bmgd/workflows/1-preproduction/game-brief/instructions.md"
-  validation: "_bmad/bmgd/workflows/1-preproduction/game-brief/checklist.md"
-  template: "_bmad/bmgd/workflows/1-preproduction/game-brief/template.md"
+  instructions: "_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.md"
   web_bundle_files:
-    - "_bmad/bmgd/workflows/1-preproduction/game-brief/instructions.md"
+    # Main workflow file
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.md"
+    # Step files
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-01-init.md"
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-01b-continue.md"
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-02-vision.md"
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-03-market.md"
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-04-fundamentals.md"
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-05-scope.md"
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-06-references.md"
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-07-content.md"
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-08-complete.md"
+    # Template
+    - "_bmad/bmgd/workflows/1-preproduction/game-brief/templates/game-brief-template.md"
+    # Validation checklist
     - "_bmad/bmgd/workflows/1-preproduction/game-brief/checklist.md"
-    - "_bmad/bmgd/workflows/1-preproduction/game-brief/template.md"

src/modules/bmgd/workflows/2-design/gdd/instructions-gdd.md

@@ -1,502 +0,0 @@
-# GDD Workflow - Game Projects (All Levels)
-
-<workflow>
-
-<critical>The workflow execution engine is governed by: {project_root}/\_bmad/core/tasks/workflow.xml</critical>
-<critical>You MUST have already loaded and processed: {installed_path}/workflow.yaml</critical>
-<critical>Communicate all responses in {communication_language} and language MUST be tailored to {user_skill_level}</critical>
-<critical>Generate all documents in {document_output_language}</critical>
-<critical>This is the GDD instruction set for GAME projects - replaces PRD with Game Design Document</critical>
-<critical>Project analysis already completed - proceeding with game-specific design</critical>
-<critical>Uses gdd_template for GDD output, game_types.csv for type-specific sections</critical>
-<critical>Routes to 3-solutioning for architecture (platform-specific decisions handled there)</critical>
-<critical>If users mention technical details, append to technical_preferences with timestamp</critical>
-
-<critical>DOCUMENT OUTPUT: Concise, clear, actionable game design specs. Use tables/lists over prose. User skill level ({user_skill_level}) affects conversation style ONLY, not document content.</critical>
-<critical>⚠️ CHECKPOINT PROTOCOL: After EVERY <template-output> tag, you MUST follow workflow.xml substep 2c: SAVE content to file immediately → SHOW checkpoint separator (━━━━━━━━━━━━━━━━━━━━━━━) → DISPLAY generated content → PRESENT options [a]Advanced Elicitation/[c]Continue/[p]Party-Mode/[y]YOLO → WAIT for user response. Never batch saves or skip checkpoints.</critical>
-
-## Input Document Discovery
-
-This workflow requires: game brief, and may reference market research or brownfield project documentation.
-
-**Discovery Process** (execute for each referenced document):
-
-1. **Search for whole document first** - Use fuzzy file matching to find the complete document
-2. **Check for sharded version** - If whole document not found, look for `{doc-name}/index.md`
-3. **If sharded version found**:
-   - Read `index.md` to understand the document structure
-   - Read ALL section files listed in the index
-   - Treat the combined content as if it were a single document
-4. **Brownfield projects**: The `document-project` workflow always creates `{output_folder}/index.md`
-
-**Priority**: If both whole and sharded versions exist, use the whole document.
-
-**Fuzzy matching**: Be flexible with document names - users may use variations in naming conventions.
-
-<step n="0" goal="Validate workflow and extract project configuration">
-
-<invoke-workflow path="{project-root}/_bmad/bmm/workflows/workflow-status">
-  <param>mode: data</param>
-  <param>data_request: project_config</param>
-</invoke-workflow>
-
-<check if="status_exists == false">
-  <output>**Note: No Workflow Status File Found**
-
-The GDD workflow can run standalone or as part of the BMM workflow path.
-
-**Recommended:** Run `workflow-init` first for:
-
-- Project context tracking
-- Workflow sequencing guidance
-- Progress monitoring across workflows
-
-**Or continue standalone** without progress tracking.
-</output>
-<ask>Continue in standalone mode or exit to run workflow-init? (continue/exit)</ask>
-<check if="continue">
-<action>Set standalone_mode = true</action>
-</check>
-<check if="exit">
-<action>Exit workflow</action>
-</check>
-</check>
-
-<check if="status_exists == true">
-  <action>Store {{status_file_path}} for later updates</action>
-
-  <check if="project_type != 'game'">
-    <output>**Incorrect Workflow for Software Projects**
-
-Your project is type: {{project_type}}
-
-**Correct workflows for software projects:**
-
-- Level 0-1: `tech-spec` (Architect agent)
-- Level 2-4: `prd` (PM agent)
-
-{{#if project_level <= 1}}
-Use: `tech-spec`
-{{else}}
-Use: `prd`
-{{/if}}
-</output>
-<action>Exit and redirect to appropriate workflow</action>
-</check>
-</check>
-</step>
-
-<step n="0.5" goal="Validate workflow sequencing" tag="workflow-status">
-
-<check if="standalone_mode != true">
-  <action>Check status of "gdd" workflow in loaded status file</action>
-
-  <check if="gdd status is file path (already completed)">
-    <output>⚠️ GDD already completed: {{gdd status}}</output>
-    <ask>Re-running will overwrite the existing GDD. Continue? (y/n)</ask>
-    <check if="n">
-      <output>Exiting. Use workflow-status to see your next step.</output>
-      <action>Exit workflow</action>
-    </check>
-  </check>
-
-  <check if="gdd is not the next expected workflow (latter items are completed already in the list)">
-    <output>⚠️ Next expected workflow: {{next_workflow}}. GDD is out of sequence.</output>
-    <ask>Continue with GDD anyway? (y/n)</ask>
-    <check if="n">
-      <output>Exiting. Run {{next_workflow}} instead.</output>
-      <action>Exit workflow</action>
-    </check>
-  </check>
-</check>
-</step>
-
-<step n="1" goal="Load context and determine game type">
-
-<action>Use {{project_type}} and {{project_level}} from status data</action>
-
-<check if="continuation_mode == true">
-  <action>Load existing GDD.md and check completion status</action>
-  <ask>Found existing work. Would you like to:
-  1. Review what's done and continue
-  2. Modify existing sections
-  3. Start fresh
-  </ask>
-  <action>If continuing, skip to first incomplete section</action>
-</check>
-
-<action if="new or starting fresh">Check or existing game-brief in output_folder</action>
-
-<check if="game-brief exists">
-  <ask>Found existing game brief! Would you like to:
-
-1. Use it as input (recommended - I'll extract key info)
-2. Ignore it and start fresh
-   </ask>
-   </check>
-
-<check if="using game-brief">
-  <action>Load and analyze game-brief document</action>
-  <action>Extract: game_name, core_concept, target_audience, platforms, game_pillars, primary_mechanics</action>
-  <action>Pre-fill relevant GDD sections with game-brief content</action>
-  <action>Note which sections were pre-filled from brief</action>
-
-</check>
-
-<check if="no game-brief was loaded">
-  <ask>Describe your game. What is it about? What does the player do? What is the Genre or type?</ask>
-
-<action>Analyze description to determine game type</action>
-<action>Map to closest game_types.csv id or use "custom"</action>
-</check>
-
-<check if="else (game-brief was loaded)">
-  <action>Use game concept from brief to determine game type</action>
-
-  <ask optional="true">
-    I've identified this as a **{{game_type}}** game. Is that correct?
-    If not, briefly describe what type it should be:
-  </ask>
-
-<action>Map selection to game_types.csv id</action>
-<action>Load corresponding fragment file from game-types/ folder</action>
-<action>Store game_type for later injection</action>
-
-<action>Load gdd_template from workflow.yaml</action>
-
-Get core game concept and vision.
-
-<template-output>description</template-output>
-</check>
-
-</step>
-
-<step n="2" goal="Define platforms and target audience">
-
-<action>Guide user to specify target platform(s) for their game, exploring considerations like desktop, mobile, web, console, or multi-platform deployment</action>
-
-<template-output>platforms</template-output>
-
-<action>Guide user to define their target audience with specific demographics: age range, gaming experience level (casual/core/hardcore), genre familiarity, and preferred play session lengths</action>
-
-<template-output>target_audience</template-output>
-
-</step>
-
-<step n="3" goal="Define goals, context, and unique selling points">
-
-<action>Guide user to define project goals appropriate for their level (Level 0-1: 1-2 goals, Level 2: 2-3 goals, Level 3-4: 3-5 strategic goals) - what success looks like for this game</action>
-
-<template-output>goals</template-output>
-
-<action>Guide user to provide context on why this game matters now - the motivation and rationale behind the project</action>
-
-<template-output>context</template-output>
-
-<action>Guide user to identify the unique selling points (USPs) - what makes this game different from existing games in the market</action>
-
-<template-output>unique_selling_points</template-output>
-
-</step>
-
-<step n="4" goal="Core gameplay definition">
-
-<critical>These are game-defining decisions</critical>
-
-<action>Guide user to identify 2-4 core game pillars - the fundamental gameplay elements that define their game's experience (e.g., tight controls + challenging combat + rewarding exploration, or strategic depth + replayability + quick sessions)</action>
-
-<template-output>game_pillars</template-output>
-
-<action>Guide user to describe the core gameplay loop - what actions the player repeats throughout the game, creating a clear cyclical pattern of player behavior and rewards</action>
-
-<template-output>gameplay_loop</template-output>
-
-<action>Guide user to define win and loss conditions - how the player succeeds and fails in the game</action>
-
-<template-output>win_loss_conditions</template-output>
-
-</step>
-
-<step n="5" goal="Game mechanics and controls">
-
-<action>Guide user to define the primary game mechanics that players will interact with throughout the game</action>
-
-<template-output>primary_mechanics</template-output>
-
-<action>Guide user to describe their control scheme and input method (keyboard/mouse, gamepad, touchscreen, etc.), including key bindings or button layouts if known</action>
-
-<template-output>controls</template-output>
-
-</step>
-
-<step n="6" goal="Inject game-type-specific sections">
-
-<action>Load game-type fragment from: {installed_path}/gdd/game-types/{{game_type}}.md</action>
-
-<critical>Process each section in the fragment template</critical>
-
-For each {{placeholder}} in the fragment, elicit and capture that information.
-
-<template-output file="GDD.md">GAME_TYPE_SPECIFIC_SECTIONS</template-output>
-
-</step>
-
-<step n="7" goal="Progression and balance">
-
-<action>Guide user to describe how player progression works in their game - whether through skill improvement, power gains, ability unlocking, narrative advancement, or a combination of approaches</action>
-
-<template-output>player_progression</template-output>
-
-<action>Guide user to define the difficulty curve: how challenge increases over time, pacing rhythm (steady/spikes/player-controlled), and any accessibility options planned</action>
-
-<template-output>difficulty_curve</template-output>
-
-<action>Ask if the game includes an in-game economy or resource system, and if so, guide user to describe it (skip if not applicable)</action>
-
-<template-output>economy_resources</template-output>
-
-</step>
-
-<step n="8" goal="Level design framework">
-
-<action>Guide user to describe the types of levels/stages in their game (e.g., tutorial, themed biomes, boss arenas, procedural vs. handcrafted, etc.)</action>
-
-<template-output>level_types</template-output>
-
-<action>Guide user to explain how levels progress or unlock - whether through linear sequence, hub-based structure, open world exploration, or player-driven choices</action>
-
-<template-output>level_progression</template-output>
-
-</step>
-
-<step n="9" goal="Art and audio direction">
-
-<action>Guide user to describe their art style vision: visual aesthetic (pixel art, low-poly, realistic, stylized), color palette preferences, and any inspirations or references</action>
-
-<template-output>art_style</template-output>
-
-<action>Guide user to describe their audio and music direction: music style/genre, sound effect tone, and how important audio is to the gameplay experience</action>
-
-<template-output>audio_music</template-output>
-
-</step>
-
-<step n="10" goal="Technical specifications">
-
-<action>Guide user to define performance requirements: target frame rate, resolution, acceptable load times, and mobile battery considerations if applicable</action>
-
-<template-output>performance_requirements</template-output>
-
-<action>Guide user to identify platform-specific considerations (mobile touch controls/screen sizes, PC keyboard/mouse/settings, console controller/certification, web browser compatibility/file size)</action>
-
-<template-output>platform_details</template-output>
-
-<action>Guide user to document key asset requirements: art assets (sprites/models/animations), audio assets (music/SFX/voice), estimated counts/sizes, and asset pipeline needs</action>
-
-<template-output>asset_requirements</template-output>
-
-</step>
-
-<step n="11" goal="Epic structure">
-
-<action>Work with user to translate game features into development epics, following level-appropriate guidelines (Level 1: 1 epic/1-10 stories, Level 2: 1-2 epics/5-15 stories, Level 3: 2-5 epics/12-40 stories, Level 4: 5+ epics/40+ stories)</action>
-
-<template-output>epics</template-output>
-
-</step>
-
-<step n="12" goal="Generate detailed epic breakdown in epics.md">
-
-<action>Load epics_template from workflow.yaml</action>
-
-<critical>Create separate epics.md with full story hierarchy</critical>
-
-<action>Generate epic overview section with all epics listed</action>
-
-<template-output file="epics.md">epic_overview</template-output>
-
-<action>For each epic, generate detailed breakdown with expanded goals, capabilities, and success criteria</action>
-
-<action>For each epic, generate all stories in user story format with prerequisites, acceptance criteria (3-8 per story), and high-level technical notes</action>
-
-<for-each epic="epic_list">
-
-<template-output file="epics.md">epic*{{epic_number}}*details</template-output>
-
-</for-each>
-
-</step>
-<step n="13" goal="Success metrics">
-
-<action>Guide user to identify technical metrics they'll track (e.g., frame rate consistency, load times, crash rate, memory usage)</action>
-
-<template-output>technical_metrics</template-output>
-
-<action>Guide user to identify gameplay metrics they'll track (e.g., player completion rate, session length, difficulty pain points, feature engagement)</action>
-
-<template-output>gameplay_metrics</template-output>
-
-</step>
-
-<step n="14" goal="Document out of scope and assumptions">
-
-<action>Guide user to document what is explicitly out of scope for this game - features, platforms, or content that won't be included in this version</action>
-
-<template-output>out_of_scope</template-output>
-
-<action>Guide user to document key assumptions and dependencies - technical assumptions, team capabilities, third-party dependencies, or external factors the project relies on</action>
-
-<template-output>assumptions_and_dependencies</template-output>
-
-</step>
-
-<step n="15" goal="Update status and populate story sequence" tag="workflow-status">
-
-<check if="standalone_mode != true">
-  <action>Load the FULL file: {output_folder}/bmm-workflow-status.yaml</action>
-  <action>Find workflow_status key "gdd"</action>
-  <critical>ONLY write the file path as the status value - no other text, notes, or metadata</critical>
-  <action>Update workflow_status["gdd"] = "{output_folder}/bmm-gdd-{{game_name}}-{{date}}.md"</action>
-  <action>Save file, preserving ALL comments and structure including STATUS DEFINITIONS</action>
-
-<action>Parse {epics_output_file} to extract all stories</action>
-<action>Populate story_sequence section in status file with story IDs</action>
-<action>Set each story status to "not-started"</action>
-<output>Loaded {{total_stories}} stories from epics into story sequence.</output>
-
-<action>Find first non-completed workflow in workflow_status (next workflow to do)</action>
-<action>Determine next agent from path file based on next workflow</action>
-<output>Next workflow: {{next_workflow}} ({{next_agent}} agent)</output>
-</check>
-
-</step>
-
-<step n="16" goal="Generate solutioning handoff and next steps">
-
-<action>Check if game-type fragment contained narrative tags indicating narrative importance</action>
-
-<check if="fragment had <narrative-workflow-critical> or <narrative-workflow-recommended>">
-  <action>Set needs_narrative = true</action>
-  <action>Extract narrative importance level from tag</action>
-
-## Next Steps for {{game_name}}
-
-</check>
-
-<check if="needs_narrative == true">
-  <action>Inform user that their game type benefits from narrative design, presenting the option to create a Narrative Design Document covering story structure, character arcs, world lore, dialogue framework, and environmental storytelling</action>
-
-<ask>This game type ({{game_type}}) benefits from narrative design.
-
-Would you like to create a Narrative Design Document now?
-
-1. Yes, create Narrative Design Document (recommended)
-2. No, proceed directly to solutioning
-3. Skip for now, I'll do it later
-
-Your choice:</ask>
-
-</check>
-
-<check if="user selects option 1 or fuzzy indicates wanting to create the narrative design document">
-  <invoke-workflow>{project-root}/_bmad/bmm/workflows/2-plan-workflows/narrative/workflow.yaml</invoke-workflow>
-  <action>Pass GDD context to narrative workflow</action>
-  <action>Exit current workflow (narrative will hand off to solutioning when done)</action>
-
-Since this is a Level {{project_level}} game project, you need solutioning for platform/engine architecture.
-
-**Start new chat with solutioning workflow and provide:**
-
-1. This GDD: `{{gdd_output_file}}`
-2. Project analysis: `{{analysis_file}}`
-
-**The solutioning workflow will:**
-
-- Determine game engine/platform (Unity, Godot, Phaser, custom, etc.)
-- Generate architecture.md with engine-specific decisions
-- Create per-epic tech specs
-- Handle platform-specific architecture (from registry.csv game-\* entries)
-
-## Complete Next Steps Checklist
-
-<action>Generate comprehensive checklist based on project analysis</action>
-
-### Phase 1: Architecture and Engine Selection
-
-- [ ] **Run solutioning workflow** (REQUIRED)
-  - Command: `workflow create-architecture`
-  - Input: GDD.md, bmm-workflow-status.md
-  - Output: architecture.md with engine/platform specifics
-  - Note: Registry.csv will provide engine-specific guidance
-
-### Phase 2: Prototype and Playtesting
-
-- [ ] **Create core mechanic prototype**
-  - Validate game feel
-  - Test control responsiveness
-  - Iterate on game pillars
-
-- [ ] **Playtest early and often**
-  - Internal testing
-  - External playtesting
-  - Feedback integration
-
-### Phase 3: Asset Production
-
-- [ ] **Create asset pipeline**
-  - Art style guides
-  - Technical constraints
-  - Asset naming conventions
-
-- [ ] **Audio integration**
-  - Music composition/licensing
-  - SFX creation
-  - Audio middleware setup
-
-### Phase 4: Development
-
-- [ ] **Generate detailed user stories**
-  - Command: `workflow generate-stories`
-  - Input: GDD.md + architecture.md
-
-- [ ] **Sprint planning**
-  - Vertical slices
-  - Milestone planning
-  - Demo/playable builds
-
-<ask>**✅ GDD Complete, {user_name}!**
-
-Next immediate action:
-
-</check>
-
-<check if="needs_narrative == true">
-
-1. Create Narrative Design Document (recommended for {{game_type}})
-2. Start solutioning workflow (engine/architecture)
-3. Create prototype build
-4. Begin asset production planning
-5. Review GDD with team/stakeholders
-6. Exit workflow
-
-</check>
-
-<check if="else">
-
-1. Start solutioning workflow (engine/architecture)
-2. Create prototype build
-3. Begin asset production planning
-4. Review GDD with team/stakeholders
-5. Exit workflow
-
-Which would you like to proceed with?</ask>
-</check>
-
-<check if="user selects narrative option">
-  <invoke-workflow>{project-root}/_bmad/bmm/workflows/2-plan-workflows/narrative/workflow.yaml</invoke-workflow>
-  <action>Pass GDD context to narrative workflow</action>
-</check>
-
-</step>
-
-</workflow>

src/modules/bmgd/workflows/2-design/gdd/steps/step-01-init.md

@@ -0,0 +1,248 @@
+---
+name: 'step-01-init'
+description: 'Initialize the GDD workflow by detecting continuation state and setting up the document'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-init.md'
+nextStepFile: '{workflow_path}/steps/step-02-context.md'
+continueStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Template References
+gddTemplate: '{workflow_path}/templates/gdd-template.md'
+
+# Data Files
+gameTypesCSV: '{workflow_path}/game-types.csv'
+---
+
+# Step 1: Workflow Initialization
+
+**Progress: Step 1 of 14** - Next: Game Context & Type
+
+## STEP GOAL:
+
+Initialize the GDD workflow by detecting continuation state, discovering input documents (game brief, research), and setting up the document structure for collaborative game design discovery.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- If you already have been given a name, communication_style and persona, continue to use those while playing this new role
+- We engage in collaborative dialogue, not command-response
+- You bring structured game design thinking and facilitation skills, while the user brings their game vision
+
+### Step-Specific Rules:
+
+- Focus only on initialization and setup - no content generation yet
+- FORBIDDEN to look ahead to future steps or assume knowledge from them
+- Approach: Systematic setup with clear reporting to user
+- Detect existing workflow state and handle continuation properly
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis of current state before taking any action
+- Initialize document structure and update frontmatter appropriately
+- Set up frontmatter `stepsCompleted: [1]` before loading next step
+- FORBIDDEN to load next step until user selects 'C' (Continue)
+
+## CONTEXT BOUNDARIES:
+
+- Available context: Variables from workflow.md are available in memory
+- Focus: Workflow initialization and document setup only
+- Limits: Don't assume knowledge from other steps or create content yet
+- Dependencies: Configuration loaded from workflow.md initialization
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Check for Existing Workflow State
+
+First, check if the output document already exists:
+
+**Workflow State Detection:**
+
+- Look for file at `{outputFile}`
+- If exists, read the complete file including frontmatter
+- If not exists, this is a fresh workflow
+
+### 2. Handle Continuation (If Document Exists)
+
+If the document exists and has frontmatter with `stepsCompleted`:
+
+**Continuation Protocol:**
+
+- **STOP immediately** and load `{continueStepFile}`
+- Do not proceed with any initialization tasks
+- Let step-01b handle all continuation logic
+- This is an auto-proceed situation - no user choice needed
+
+### 3. Fresh Workflow Setup (If No Document)
+
+If no document exists or no `stepsCompleted` in frontmatter:
+
+#### A. Input Document Discovery
+
+Discover and load context documents using smart discovery.
+
+**IMPORTANT: Track document counts as you discover files.**
+
+Initialize counters:
+
+```
+briefCount = 0
+researchCount = 0
+brainstormingCount = 0
+projectDocsCount = 0
+```
+
+**Game Brief (Priority: Analysis -> Main -> Sharded -> Whole):**
+
+1. Check analysis folder: `{output_folder}/analysis/*game-brief*.md`
+2. If no analysis files: Try main folder: `{output_folder}/*game-brief*.md`
+3. If no main files: Check for sharded brief folder: `{output_folder}/*game-brief*/**/*.md`
+4. If sharded folder exists: Load EVERY file in that folder completely
+5. Add discovered files to `inputDocuments` frontmatter
+6. **Update briefCount with number of files found**
+
+**Research Documents (Priority: Analysis -> Main -> Sharded -> Whole):**
+
+1. Check analysis folder: `{output_folder}/analysis/research/*research*.md`
+2. If no analysis files: Try main folder: `{output_folder}/*research*.md`
+3. If no main files: Check for sharded research folder: `{output_folder}/*research*/**/*.md`
+4. Load useful research files completely
+5. Add discovered files to `inputDocuments` frontmatter
+6. **Update researchCount with number of files found**
+
+**Brainstorming Documents (Priority: Analysis -> Main):**
+
+1. Check analysis folder: `{output_folder}/analysis/brainstorming/*brainstorm*.md`
+2. If no analysis files: Try main folder: `{output_folder}/*brainstorm*.md`
+3. Add discovered files to `inputDocuments` frontmatter
+4. **Update brainstormingCount with number of files found**
+
+**Project Documentation (Existing Projects - Brownfield):**
+
+1. Look for index file: `{output_folder}/index.md`
+2. CRITICAL: Load index.md to understand what project files are available
+3. Read available files from index to understand existing project context
+4. This provides essential context for extending existing game with new features
+5. Add discovered files to `inputDocuments` frontmatter
+6. **Update projectDocsCount with number of files found (including index.md)**
+
+**Loading Rules:**
+
+- Load ALL discovered files completely (no offset/limit)
+- For sharded folders, load ALL files to get complete picture
+- For existing projects, use index.md as guide to what's relevant
+- Track all successfully loaded files in frontmatter `inputDocuments` array
+
+#### B. Create Initial Document
+
+**Document Setup:**
+
+- Copy the template from `{gddTemplate}` to `{outputFile}`
+- Initialize frontmatter with proper structure including document counts:
+
+```yaml
+---
+stepsCompleted: []
+inputDocuments: []
+documentCounts:
+  briefs: { { briefCount } }
+  research: { { researchCount } }
+  brainstorming: { { brainstormingCount } }
+  projectDocs: { { projectDocsCount } }
+workflowType: 'gdd'
+lastStep: 0
+project_name: '{{project_name}}'
+user_name: '{{user_name}}'
+date: '{{date}}'
+game_type: ''
+game_name: ''
+---
+```
+
+#### C. Present Initialization Results
+
+**Setup Report to User:**
+
+"Welcome {{user_name}}! I've set up your GDD workspace for {{project_name}}.
+
+**Document Setup:**
+
+- Created: `{outputFile}` from template
+- Initialized frontmatter with workflow state
+
+**Input Documents Discovered:**
+
+- Game briefs: {{briefCount}} files {if briefCount > 0}loaded{else}(none found){/if}
+- Research: {{researchCount}} files {if researchCount > 0}loaded{else}(none found){/if}
+- Brainstorming: {{brainstormingCount}} files {if brainstormingCount > 0}loaded{else}(none found){/if}
+- Project docs: {{projectDocsCount}} files {if projectDocsCount > 0}loaded (brownfield project){else}(none found - greenfield project){/if}
+
+**Files loaded:** {list of specific file names or "No additional documents found"}
+
+{if projectDocsCount > 0}
+**Note:** This is a **brownfield project**. Your existing project documentation has been loaded. In the next step, I'll ask specifically about what new features or changes you want to add to your existing game.
+{/if}
+
+Do you have any other documents you'd like me to include, or shall we continue to the next step?"
+
+### 4. Present MENU OPTIONS
+
+Display menu after setup report:
+
+"[C] Continue - Save this and move to Game Context & Type (Step 2 of 14)"
+
+#### Menu Handling Logic:
+
+- IF C: Update frontmatter with `stepsCompleted: [1]`, then load, read entire file, then execute {nextStepFile}
+- IF user provides additional files: Load them, update inputDocuments and documentCounts, redisplay report
+- IF user asks questions: Answer and redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [frontmatter properly updated with stepsCompleted: [1] and documentCounts], will you then load and read fully `{nextStepFile}` to execute and begin game context discovery.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Existing workflow detected and properly handed off to step-01b
+- Fresh workflow initialized with template and proper frontmatter
+- Input documents discovered and loaded using sharded-first logic
+- All discovered files tracked in frontmatter `inputDocuments`
+- **Document counts stored in frontmatter `documentCounts`**
+- User clearly informed of brownfield vs greenfield status
+- Menu presented and user input handled correctly
+- Frontmatter updated with `stepsCompleted: [1]` before proceeding
+
+### SYSTEM FAILURE:
+
+- Proceeding with fresh initialization when existing workflow exists
+- Not updating frontmatter with discovered input documents
+- **Not storing document counts in frontmatter**
+- Creating document without proper template structure
+- Not checking sharded folders first before whole files
+- Not reporting discovered documents to user clearly
+- Proceeding without user selecting 'C' (Continue)
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-01b-continue.md

@@ -0,0 +1,173 @@
+---
+name: 'step-01b-continue'
+description: 'Resume an interrupted GDD workflow from the last completed step'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+---
+
+# Step 1B: Workflow Continuation
+
+## STEP GOAL:
+
+Resume the GDD workflow from where it was left off, ensuring smooth continuation with full context restoration.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- Resume workflow from exact point where it was interrupted
+
+### Step-Specific Rules:
+
+- FOCUS on understanding where we left off and continuing appropriately
+- FORBIDDEN to modify content completed in previous steps
+- Only reload documents that were already tracked in `inputDocuments`
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis of current state before taking action
+- Keep existing frontmatter `stepsCompleted` values
+- Only load documents that were already tracked in `inputDocuments`
+- FORBIDDEN to discover new input documents during continuation
+
+## CONTEXT BOUNDARIES:
+
+- Available context: Current document and frontmatter are already loaded
+- Focus: Workflow state analysis and continuation logic only
+- Limits: Don't assume knowledge beyond what's in the document
+- Dependencies: Existing workflow state from previous session
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Analyze Current State
+
+**State Assessment:**
+Review the frontmatter to understand:
+
+- `stepsCompleted`: Which steps are already done
+- `lastStep`: The most recently completed step number
+- `inputDocuments`: What context was already loaded
+- `documentCounts`: briefs, research, brainstorming, projectDocs counts
+- `game_type`: The identified game type (if set)
+- `game_name`: The game name (if set)
+- All other frontmatter variables
+
+### 2. Restore Context Documents
+
+**Context Reloading:**
+
+- For each document in `inputDocuments`, load the complete file
+- This ensures you have full context for continuation
+- Don't discover new documents - only reload what was previously processed
+- If `game_type` is set, also reload the corresponding game type guide from `{workflow_path}/game-types/{game_type}.md`
+
+### 3. Present Current Progress
+
+**Progress Report to User:**
+"Welcome back {{user_name}}! I'm resuming our GDD collaboration for {{game_name or project_name}}.
+
+**Current Progress:**
+
+- Steps completed: {stepsCompleted}
+- Last worked on: Step {lastStep}
+- Game type: {game_type or 'Not yet determined'}
+- Context documents available: {len(inputDocuments)} files
+
+**Document Status:**
+
+- Current GDD document is ready with all completed sections
+- Ready to continue from where we left off
+
+Does this look right, or do you want to make any adjustments before we proceed?"
+
+### 4. Determine Continuation Path
+
+**Next Step Logic:**
+Based on `lastStep` value, determine which step to load next:
+
+- If `lastStep = 1` -> Load `./step-02-context.md`
+- If `lastStep = 2` -> Load `./step-03-platforms.md`
+- If `lastStep = 3` -> Load `./step-04-vision.md`
+- If `lastStep = 4` -> Load `./step-05-core-gameplay.md`
+- If `lastStep = 5` -> Load `./step-06-mechanics.md`
+- If `lastStep = 6` -> Load `./step-07-game-type.md`
+- If `lastStep = 7` -> Load `./step-08-progression.md`
+- If `lastStep = 8` -> Load `./step-09-levels.md`
+- If `lastStep = 9` -> Load `./step-10-art-audio.md`
+- If `lastStep = 10` -> Load `./step-11-technical.md`
+- If `lastStep = 11` -> Load `./step-12-epics.md`
+- If `lastStep = 12` -> Load `./step-13-metrics.md`
+- If `lastStep = 13` -> Load `./step-14-complete.md`
+- If `lastStep = 14` -> Workflow already complete
+
+### 5. Handle Workflow Completion
+
+**If workflow already complete (`lastStep = 14`):**
+"Great news! It looks like we've already completed the GDD workflow for {{game_name}}.
+
+The final document is ready at `{outputFile}` with all sections completed through step 14.
+
+Would you like me to:
+
+- Review the completed GDD with you
+- Suggest next workflow steps (like architecture or epic creation)
+- Start a new GDD revision
+
+What would be most helpful?"
+
+### 6. Present MENU OPTIONS
+
+**If workflow not complete:**
+Display: "Ready to continue with Step {nextStepNumber}?
+
+**Select an Option:** [C] Continue to next step"
+
+#### Menu Handling Logic:
+
+- IF C: Load, read entire file, then execute the appropriate next step file based on `lastStep`
+- IF Any other comments or queries: respond and redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [current state confirmed], will you then load and read fully the appropriate next step file to resume the workflow.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- All previous input documents successfully reloaded
+- Game type guide reloaded if game_type was set
+- Current workflow state accurately analyzed and presented
+- User confirms understanding of progress before continuation
+- Correct next step identified and prepared for loading
+
+### SYSTEM FAILURE:
+
+- Discovering new input documents instead of reloading existing ones
+- Modifying content from already completed steps
+- Loading wrong next step based on `lastStep` value
+- Proceeding without user confirmation of current state
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-02-context.md

@@ -0,0 +1,332 @@
+---
+name: 'step-02-context'
+description: 'Load game context from brief and determine the game type'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-02-context.md'
+nextStepFile: '{workflow_path}/steps/step-03-platforms.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Data Files
+gameTypesCSV: '{workflow_path}/game-types.csv'
+gameTypesFolder: '{workflow_path}/game-types'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 2: Game Context & Type
+
+**Progress: Step 2 of 14** - Next: Platforms & Audience
+
+## STEP GOAL:
+
+Load and analyze the game brief (if available), determine the game type from game-types.csv, load the corresponding game type guide, and capture the core game concept that will drive the entire GDD.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- You bring structured game design thinking and facilitation skills, while the user brings their game vision
+
+### Step-Specific Rules:
+
+- Focus on understanding the game concept and determining the correct game type
+- CRITICAL: Load game-types.csv to understand available game types
+- FORBIDDEN to generate detailed content without real user input
+- Approach: Leverage existing documents while validating with user
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating core concept content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+This step will generate content and present choices:
+
+- **A (Advanced Elicitation)**: Use discovery protocols to develop deeper insights about the game concept
+- **P (Party Mode)**: Bring multiple perspectives to discuss and improve the game concept
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## PROTOCOL INTEGRATION:
+
+- When 'A' selected: Execute {advancedElicitationTask}
+- When 'P' selected: Execute {partyModeWorkflow}
+- PROTOCOLS always return to this step's A/P/C menu
+- User accepts/rejects protocol changes before proceeding
+
+## CONTEXT BOUNDARIES:
+
+- Current document and frontmatter from step 1 are available
+- Input documents already loaded are in memory (game briefs, research, brainstorming)
+- **Document counts available in frontmatter `documentCounts`**
+- Game types CSV data will be loaded in this step
+- This will be the first content section appended to the document
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Read Document State from Frontmatter
+
+**CRITICAL FIRST ACTION:** Read the frontmatter from `{outputFile}` to get document counts.
+
+```
+Read documentCounts from gdd.md frontmatter:
+- briefCount = documentCounts.briefs
+- researchCount = documentCounts.research
+- brainstormingCount = documentCounts.brainstorming
+- projectDocsCount = documentCounts.projectDocs
+```
+
+**ANNOUNCE your understanding:**
+
+"From step 1, I have loaded:
+
+- Game briefs: {{briefCount}} files
+- Research: {{researchCount}} files
+- Brainstorming: {{brainstormingCount}} files
+- Project docs: {{projectDocsCount}} files
+
+{if projectDocsCount > 0}This is a **brownfield project** - I'll focus on understanding what you want to add or change.{else}This is a **greenfield project** - I'll help you define the full game vision.{/if}"
+
+### 2. Load Game Types Data
+
+Load and prepare CSV data for intelligent game type classification:
+
+- Load `{gameTypesCSV}` completely
+- Parse columns: id, name, description, key_mechanics, detection_signals
+- Store in memory for classification matching
+
+### 3. Begin Discovery Conversation
+
+**SELECT EXACTLY ONE DISCOVERY PATH based on document state:**
+
+---
+
+#### PATH A: Has Game Brief (briefCount > 0)
+
+**Use this path when:** `briefCount > 0`
+
+"As your game design peer, I've reviewed your game brief and have a great starting point. Let me share what I understand and you can refine or correct as needed.
+
+**Based on your game brief:**
+
+**Game Name:**
+{{extracted_name_from_brief}}
+
+**Core Concept:**
+{{extracted_concept_from_brief}}
+
+**Genre/Type:**
+{{extracted_genre_from_brief}}
+
+**Target Experience:**
+{{extracted_experience_from_brief}}
+
+{if projectDocsCount > 0}I also see you have existing project documentation. This GDD will define how new features integrate with your existing game.{/if}
+
+**How does this align with your vision?** Should we refine any of these points or are there important aspects I'm missing?"
+
+**AFTER this message, SKIP to Section 4.**
+
+---
+
+#### PATH B: No Brief but Has Brainstorming (briefCount == 0 AND brainstormingCount > 0)
+
+**Use this path when:** `briefCount == 0 AND brainstormingCount > 0`
+
+"As your game design peer, I've reviewed your brainstorming documents.
+
+**Ideas I've extracted:**
+{{summarize key concepts from brainstorming}}
+
+Let's crystallize these ideas into a clear game concept:
+
+- What's the core gameplay experience you want to create?
+- What genre or type of game is this?
+- What's the one thing that makes this game special?
+
+I'll use this to identify the right game type framework for our GDD."
+
+**AFTER this message, SKIP to Section 4.**
+
+---
+
+#### PATH C: No Documents - Greenfield (briefCount == 0 AND brainstormingCount == 0)
+
+**Use this path when:** `briefCount == 0 AND brainstormingCount == 0`
+
+"Let's start by understanding your game vision!
+
+**Tell me about what you want to create:**
+
+- What kind of game is it? (genre, style, references)
+- What does the player do? (core actions, moment-to-moment gameplay)
+- What makes it special or different?
+- What experience or feeling do you want players to have?
+
+I'll be listening for signals to help us identify the right game type framework."
+
+**AFTER this message, SKIP to Section 4.**
+
+---
+
+### 4. Determine Game Type
+
+As the user describes their game, match against `detection_signals` from `game-types.csv`:
+
+#### Game Type Detection Logic
+
+Compare user description against game-types.csv entries:
+
+- Look for keyword matches from semicolon-separated detection_signals
+- Examples: "platform;jump;run;2D;side-scroll" -> action-platformer
+- Examples: "RPG;level;quest;stats;inventory" -> rpg
+- Examples: "story;choices;narrative;dialogue" -> visual-novel
+
+Store the best matching `game_type` id.
+
+### 5. Present Classification for Validation
+
+**Present to user:**
+
+"Based on our conversation, I'm classifying this as:
+
+**Game Type:** {matched_game_type_name} ({matched_game_type_id})
+
+**Why this type:**
+{explain the detection signals that matched}
+
+**This game type includes these focus areas:**
+{key_mechanics from game-types.csv}
+
+Does this sound right? If not, tell me what type better fits your vision and I'll adjust."
+
+### 6. Load Game Type Guide
+
+**After user confirms game type:**
+
+- Load the corresponding game type guide: `{gameTypesFolder}/{game_type}.md`
+- Store the guide content for use in step-07 (game-type specific sections)
+- Update frontmatter: `game_type: '{game_type}'`
+
+### 7. Capture Game Name
+
+"What would you like to call this game? (Working title is fine)"
+
+- Store in frontmatter: `game_name: '{user_provided_name}'`
+
+### 8. Generate Core Concept Content
+
+Based on the conversation, prepare the content to append to the document:
+
+#### Content Structure:
+
+```markdown
+## Executive Summary
+
+### Game Name
+
+{{game_name}}
+
+### Core Concept
+
+{{description - 2-3 paragraphs describing the game concept}}
+
+### Game Type
+
+**Type:** {{game_type_name}}
+**Framework:** This GDD uses the {{game_type}} template with type-specific sections for {{key_mechanics}}
+```
+
+### 9. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Executive Summary based on our conversation. This will be the opening section of your GDD.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 8]
+
+**Select an Option:**
+[A] Advanced Elicitation - Let's dive deeper and refine this content
+[P] Party Mode - Bring in different perspectives to improve this
+[C] Continue - Save this and move to Platforms & Audience (Step 3 of 14)"
+
+### 10. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Process the enhanced content that comes back
+- Ask user: "Accept these changes to the Core Concept? (y/n)"
+- If yes: Update the content with improvements, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Process the collaborative improvements that come back
+- Ask user: "Accept these changes to the Core Concept? (y/n)"
+- If yes: Update the content with improvements, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2]`, `game_type: '{game_type}'`, `game_name: '{game_name}'`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [core concept content finalized and saved to document with frontmatter updated including game_type and game_name], will you then load and read fully `{nextStepFile}` to execute and begin platforms definition.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Document counts read from frontmatter and announced
+- Game types CSV loaded and used effectively
+- **Correct discovery path selected based on document counts**
+- Input documents analyzed and leveraged for head start
+- Game type identified and validated with user
+- Game type guide loaded and stored for later use
+- Game name captured and stored in frontmatter
+- Core concept content generated collaboratively
+- A/P/C menu presented and handled correctly
+- Content properly appended to document when C selected
+- Frontmatter updated with stepsCompleted: [1, 2], game_type, game_name
+
+### SYSTEM FAILURE:
+
+- **Not reading documentCounts from frontmatter first**
+- **Executing multiple discovery paths instead of exactly one**
+- Not loading game-types.csv for classification
+- Not validating game type with user before proceeding
+- Generating detailed content without real user input
+- Not loading the game type guide file
+- Not capturing game name
+- Not presenting A/P/C menu after content generation
+- Appending content without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-03-platforms.md

@@ -0,0 +1,245 @@
+---
+name: 'step-03-platforms'
+description: 'Define target platforms and target audience for the game'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-03-platforms.md'
+nextStepFile: '{workflow_path}/steps/step-04-vision.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 3: Platforms & Audience
+
+**Progress: Step 3 of 14** - Next: Goals & Vision
+
+## STEP GOAL:
+
+Define the target platform(s) for the game and establish a clear picture of the target audience, including demographics, gaming experience level, and preferred play patterns.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- Platform and audience decisions drive many downstream choices - take this seriously
+
+### Step-Specific Rules:
+
+- Focus on platform capabilities and audience characteristics
+- FORBIDDEN to generate detailed content without real user input
+- Consider platform-specific constraints (controls, performance, monetization)
+- Approach: Guide user through considerations they may not have thought about
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content for each section
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore platform constraints and audience nuances deeper
+- **P (Party Mode)**: Get multiple perspectives on platform/audience decisions
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- Game type and core concept from step 2 are available
+- Platform choice affects many downstream decisions
+- Audience definition affects tone, complexity, and accessibility
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Platform Discovery
+
+**Guide user through platform selection:**
+
+"Now let's talk about where players will experience {{game_name}}.
+
+**Platform Options to Consider:**
+
+| Platform                     | Considerations                                                           |
+| ---------------------------- | ------------------------------------------------------------------------ |
+| **PC (Steam/Epic)**          | Full keyboard/mouse, highest specs, Steam achievements, workshop support |
+| **Web Browser**              | Instant access, limited performance, broad reach, touch/mouse hybrid     |
+| **Mobile (iOS/Android)**     | Touch controls, short sessions, IAP monetization, battery/thermal limits |
+| **Console (Switch/PS/Xbox)** | Controller-first, certification requirements, couch multiplayer          |
+| **VR (Quest/PCVR)**          | Motion controls, comfort considerations, presence                        |
+
+**For {{game_type}} games, common platform choices include:** {platform_suggestions_from_game_type}
+
+**Questions to consider:**
+
+1. Where do your target players primarily game?
+2. Does your core gameplay work well with {platform} input methods?
+3. Are you targeting a primary platform with potential ports later?
+
+What platform(s) are you targeting?"
+
+### 2. Capture Platform Details
+
+**After user responds:**
+
+Document:
+
+- Primary platform (if multiple)
+- Platform-specific control schemes
+- Performance considerations (60fps target, resolution, etc.)
+- Platform-specific features to leverage (achievements, cloud saves, etc.)
+
+### 3. Audience Discovery
+
+**Guide user through audience definition:**
+
+"Now let's define who {{game_name}} is for.
+
+**Demographics to Consider:**
+
+- **Age Range:** What ages are you designing for? (affects content, complexity, monetization)
+- **Gaming Experience:** Casual, core, or hardcore gamers?
+- **Genre Familiarity:** Do they know {{game_type}} conventions, or are they new to the genre?
+- **Session Length:** Quick mobile sessions (5-15 min) or deep PC sessions (1+ hour)?
+
+**For {{game_type}} games, typical audiences include:**
+{audience_suggestions_from_game_type}
+
+Tell me about your ideal player. Who is this game for?"
+
+### 4. Capture Audience Details
+
+**After user responds:**
+
+Document:
+
+- Primary demographic
+- Gaming experience level
+- Genre familiarity expectations
+- Preferred session lengths
+- Secondary audiences (if any)
+
+### 5. Generate Platforms & Audience Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Target Platform(s)
+
+### Primary Platform
+
+{{primary_platform}}
+
+### Platform Considerations
+
+{{platform_specific_details}}
+
+### Control Scheme
+
+{{control_scheme_for_platform}}
+
+---
+
+## Target Audience
+
+### Demographics
+
+{{target_demographics}}
+
+### Gaming Experience
+
+{{experience_level}} - {{experience_description}}
+
+### Genre Familiarity
+
+{{genre_familiarity_description}}
+
+### Session Length
+
+{{typical_session_length}} - {{session_description}}
+
+### Player Motivations
+
+{{what_draws_this_audience_to_this_game}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Platforms & Audience sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore platform/audience deeper
+[P] Party Mode - Get other perspectives on these decisions
+[C] Continue - Save this and move to Goals & Vision (Step 4 of 14)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [platforms and audience content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Platform(s) clearly identified with rationale
+- Platform-specific considerations documented
+- Target audience demographics defined
+- Gaming experience level captured
+- Session length expectations established
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3]
+
+### SYSTEM FAILURE:
+
+- Assuming platform without user confirmation
+- Generating audience profile without user input
+- Not considering platform-specific constraints
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-04-vision.md

@@ -0,0 +1,229 @@
+---
+name: 'step-04-vision'
+description: 'Define project goals, context, and unique selling points'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-vision.md'
+nextStepFile: '{workflow_path}/steps/step-05-core-gameplay.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 4: Goals & Vision
+
+**Progress: Step 4 of 14** - Next: Core Gameplay
+
+## STEP GOAL:
+
+Define the project goals, background context for why this game matters now, and the unique selling points that differentiate this game from others in the market.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- Vision and USPs are critical for maintaining focus throughout development
+
+### Step-Specific Rules:
+
+- Focus on the "why" behind this game project
+- FORBIDDEN to generate goals/USPs without real user input
+- Help user articulate what makes their game worth making
+- Approach: Challenge assumptions about differentiation
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Dig deeper into goals and differentiation
+- **P (Party Mode)**: Challenge and strengthen the vision with multiple perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- Game type, platform, and audience from previous steps are available
+- Goals should be achievable and measurable where possible
+- USPs must be genuinely differentiating, not just features
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Goals Discovery
+
+**Guide user through goal definition:**
+
+"Let's define what success looks like for {{game_name}}.
+
+**Types of Goals to Consider:**
+
+| Goal Type         | Examples                                             |
+| ----------------- | ---------------------------------------------------- |
+| **Creative**      | "Create a game that makes players feel powerful"     |
+| **Technical**     | "Ship a stable 60fps experience on target platforms" |
+| **Business**      | "Achieve 10,000 wishlists before launch"             |
+| **Personal**      | "Learn Godot through this project"                   |
+| **Player Impact** | "Create a speedrunning community"                    |
+
+**Questions to consider:**
+
+1. What does success look like for this project?
+2. What would make you proud to have shipped this?
+3. Are there specific metrics you want to hit?
+
+What are your 2-4 main goals for {{game_name}}?"
+
+### 2. Context Discovery
+
+**Guide user through background context:**
+
+"Now let's capture why this game matters right now.
+
+**Context Questions:**
+
+- **Motivation:** What inspired you to make this game?
+- **Timing:** Why is now the right time for this game?
+- **Gap:** What's missing in the market that this fills?
+- **Personal:** What unique perspective or experience do you bring?
+
+Tell me the story behind {{game_name}}. Why are you making this?"
+
+### 3. USP Discovery
+
+**Guide user through unique selling points:**
+
+"Now for the critical question: What makes {{game_name}} different?
+
+**USP Framework:**
+
+A strong USP answers: "Why would someone play THIS game instead of the alternatives?"
+
+**Categories of Differentiation:**
+
+- **Mechanical Innovation:** New gameplay systems or combinations
+- **Narrative/World:** Unique setting, story, or characters
+- **Art/Audio:** Distinctive aesthetic or soundscape
+- **Audience Focus:** Serving an underserved player segment
+- **Technical:** Performance, accessibility, or platform features
+
+**For {{game_type}} games, common USPs include:**
+{typical_usps_for_game_type}
+
+But what's YOUR unique angle?
+
+**Challenge Questions:**
+
+1. If I removed your USP, would the game still be interesting?
+2. Can another developer easily copy this USP?
+3. Does this USP matter to your target audience?
+
+What 2-4 things make {{game_name}} genuinely different?"
+
+### 4. Generate Vision Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Goals and Context
+
+### Project Goals
+
+{{goals_list_with_descriptions}}
+
+### Background and Rationale
+
+{{context_narrative}}
+
+---
+
+## Unique Selling Points (USPs)
+
+{{usps_with_descriptions}}
+
+### Competitive Positioning
+
+{{how_this_game_stands_out_in_the_market}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Goals & Vision sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Select an Option:**
+[A] Advanced Elicitation - Challenge and strengthen these points
+[P] Party Mode - Get other perspectives on differentiation
+[C] Continue - Save this and move to Core Gameplay (Step 5 of 14)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [vision content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 2-4 clear, achievable goals defined
+- Background context captures the "why"
+- USPs are genuinely differentiating, not just features
+- Competitive positioning is clear
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4]
+
+### SYSTEM FAILURE:
+
+- Generating generic goals without user input
+- USPs that are just feature lists, not differentiation
+- Not challenging weak USPs
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-05-core-gameplay.md

@@ -0,0 +1,258 @@
+---
+name: 'step-05-core-gameplay'
+description: 'Define game pillars, core gameplay loop, and win/loss conditions'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-core-gameplay.md'
+nextStepFile: '{workflow_path}/steps/step-06-mechanics.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 5: Core Gameplay
+
+**Progress: Step 5 of 14** - Next: Game Mechanics
+
+## STEP GOAL:
+
+Define the fundamental gameplay elements: game pillars (core design tenets), the core gameplay loop (what players repeatedly do), and win/loss conditions (how players succeed or fail).
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- These are GAME-DEFINING decisions - treat them with appropriate weight
+- Every future decision should serve these pillars and loop
+
+### Step-Specific Rules:
+
+- Focus on the heart of the gameplay experience
+- FORBIDDEN to generate pillars/loops without real user input
+- Challenge: Do these pillars and loop serve the stated USPs?
+- Approach: Help user think through the player experience
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into the player experience
+- **P (Party Mode)**: Test these fundamentals with multiple perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context (type, platform, audience, goals, USPs) available
+- Pillars are the "constitution" that guides all design decisions
+- Core loop is what players do 80% of the time
+- Win/loss conditions provide motivation and stakes
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Game Pillars Discovery
+
+**Guide user through pillar definition:**
+
+"Now we define the core pillars - the fundamental design principles that every feature must serve.
+
+**What are Game Pillars?**
+
+Pillars are 2-4 non-negotiable design tenets. Every mechanic, system, and feature should support at least one pillar. If something doesn't serve a pillar, question whether it belongs.
+
+**Examples of Pillars:**
+
+| Game           | Pillars                                            |
+| -------------- | -------------------------------------------------- |
+| **Dark Souls** | Challenge, Discovery, Consequence                  |
+| **Celeste**    | Tight Controls, Accessibility, Emotional Narrative |
+| **Minecraft**  | Creativity, Exploration, Player Agency             |
+| **Dead Cells** | Mastery, Variety, Momentum                         |
+
+**For your {{game_type}} with USPs of {{usps}}:**
+
+What 2-4 pillars will define every design decision in {{game_name}}?"
+
+### 2. Core Loop Discovery
+
+**Guide user through loop definition:**
+
+"Now let's define the core gameplay loop - the cycle of actions players repeat throughout the game.
+
+**Core Loop Structure:**
+
+A good loop has: **Action -> Feedback -> Reward -> Motivation to repeat**
+
+**Examples:**
+
+| Game          | Core Loop                                                              |
+| ------------- | ---------------------------------------------------------------------- |
+| **Roguelike** | Enter dungeon -> Fight/loot -> Die/extract -> Upgrade -> Enter dungeon |
+| **Puzzle**    | See puzzle -> Analyze -> Attempt -> Succeed/fail -> Next puzzle        |
+| **FPS**       | Engage enemy -> Shoot -> Kill/die -> Respawn/proceed -> Engage         |
+
+**For {{game_type}} games, typical loops include:**
+{typical_loops_for_game_type}
+
+**Questions to consider:**
+
+1. What does the player do most of the time?
+2. What makes each loop iteration feel different from the last?
+3. How long is one loop cycle? (seconds, minutes, hours?)
+
+Describe the core loop for {{game_name}}."
+
+### 3. Win/Loss Conditions Discovery
+
+**Guide user through win/loss definition:**
+
+"Finally, let's define how players succeed and fail.
+
+**Win/Loss Framework:**
+
+| Condition Type | Examples                                                        |
+| -------------- | --------------------------------------------------------------- |
+| **Victory**    | Beat final boss, reach score, complete story, survive time      |
+| **Failure**    | Run out of lives, time expires, resources depleted, story fails |
+| **Soft Fail**  | Lose progress, restart level, dropped loot                      |
+| **No Failure** | Sandbox games, creative tools, walking sims                     |
+
+**Questions to consider:**
+
+1. Is there a definitive "win state" or is success ongoing?
+2. What happens when players fail? How punishing is it?
+3. Are there multiple win/lose conditions (lives AND time)?
+4. Does failure teach the player something?
+
+How do players win and lose in {{game_name}}?"
+
+### 4. Generate Core Gameplay Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Core Gameplay
+
+### Game Pillars
+
+{{pillar_list_with_descriptions}}
+
+**Pillar Prioritization:** When pillars conflict, prioritize in this order:
+{{pillar_priority_order}}
+
+### Core Gameplay Loop
+
+{{loop_description}}
+
+**Loop Diagram:**
+{{text_based_loop_visualization}}
+
+**Loop Timing:** {{typical_loop_duration}}
+
+**Loop Variation:** {{what_makes_each_iteration_different}}
+
+### Win/Loss Conditions
+
+#### Victory Conditions
+
+{{win_conditions}}
+
+#### Failure Conditions
+
+{{loss_conditions}}
+
+#### Failure Recovery
+
+{{what_happens_on_failure}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Core Gameplay sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Do all pillars support your USPs?
+- Does the core loop deliver on your pillars?
+- Do win/loss conditions create appropriate stakes?
+
+**Select an Option:**
+[A] Advanced Elicitation - Stress test these fundamentals
+[P] Party Mode - Get other perspectives on the core design
+[C] Continue - Save this and move to Game Mechanics (Step 6 of 14)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [core gameplay content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 2-4 clear, actionable pillars defined
+- Pillar prioritization established for conflicts
+- Core loop clearly described with timing and variation
+- Win/loss conditions appropriate for game type
+- Failure recovery explained
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5]
+
+### SYSTEM FAILURE:
+
+- Generic pillars that don't guide decisions
+- Core loop that doesn't match the game type
+- Generating content without real user input
+- Win/loss conditions misaligned with stated goals
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-06-mechanics.md

@@ -0,0 +1,249 @@
+---
+name: 'step-06-mechanics'
+description: 'Define primary game mechanics and control schemes'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-mechanics.md'
+nextStepFile: '{workflow_path}/steps/step-07-game-type.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 6: Game Mechanics
+
+**Progress: Step 6 of 14** - Next: Game Type Specifics
+
+## STEP GOAL:
+
+Define the primary game mechanics that players interact with and the control scheme/input methods for the target platform(s).
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Mechanics must serve the pillars and core loop defined in step 5
+- Controls must work for the target platform defined in step 3
+
+### Step-Specific Rules:
+
+- Focus on moment-to-moment player interactions
+- FORBIDDEN to generate mechanics without real user input
+- Challenge: Does each mechanic serve a pillar?
+- Approach: Start with verbs - what does the player DO?
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into mechanic interactions and edge cases
+- **P (Party Mode)**: Test mechanic clarity with multiple perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially pillars and platform)
+- Mechanics are the building blocks of gameplay
+- Controls must feel good on target platform(s)
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Primary Mechanics Discovery
+
+**Guide user through mechanics definition:**
+
+"Let's define the primary mechanics - the core actions players perform to engage with your game.
+
+**Mechanics Framework:**
+
+Think in terms of VERBS - what does the player DO?
+
+| Mechanic Category | Example Verbs                            |
+| ----------------- | ---------------------------------------- |
+| **Movement**      | Run, jump, dash, climb, swim, fly        |
+| **Combat**        | Attack, block, dodge, parry, aim, shoot  |
+| **Interaction**   | Talk, pickup, use, craft, build, destroy |
+| **Resource**      | Collect, spend, trade, manage, invest    |
+| **Information**   | Discover, read, scan, analyze, remember  |
+| **Social**        | Cooperate, compete, trade, communicate   |
+
+**For {{game_type}} games, key mechanics typically include:**
+{typical_mechanics_for_game_type}
+
+**Your core loop is:** {{core_loop}}
+**Your pillars are:** {{pillars}}
+
+**Questions to consider:**
+
+1. What are the 3-5 most important things players do?
+2. Which mechanics support which pillars?
+3. How do mechanics combine or interact?
+
+What are the primary mechanics in {{game_name}}?"
+
+### 2. Mechanics Deep Dive
+
+**For each mechanic identified, ask:**
+
+"Let's detail **{{mechanic_name}}**:
+
+- **When does the player use this?** (constantly, situationally, rarely)
+- **What skill does it test?** (timing, positioning, strategy, knowledge)
+- **How does it feel?** (snappy, weighty, floaty, precise)
+- **How does it progress?** (unlocks, upgrades, mastery)
+- **How does it interact with other mechanics?**"
+
+### 3. Controls Discovery
+
+**Guide user through control scheme definition:**
+
+"Now let's map these mechanics to controls for {{primary_platform}}.
+
+**Control Considerations:**
+
+| Platform    | Key Considerations                                                 |
+| ----------- | ------------------------------------------------------------------ |
+| **PC**      | Keyboard/mouse precision, rebindable keys, many available inputs   |
+| **Console** | Limited buttons, shoulder triggers, stick deadzone, rumble         |
+| **Mobile**  | Touch targets, gesture clarity, screen real estate, one-hand play? |
+| **VR**      | Motion control, tracked hands, comfort, physical space             |
+
+**Control Design Principles:**
+
+1. **Frequency = Accessibility:** Common actions get easy-to-reach inputs
+2. **Similar actions, similar buttons:** Jump/interact shouldn't be opposite hands
+3. **No hand gymnastics:** Avoid requiring uncomfortable button combos
+4. **Platform conventions:** Use expected mappings where appropriate
+
+**For {{game_type}} on {{platform}}, typical control schemes include:**
+{typical_controls_for_game_type_and_platform}
+
+How do you want controls to work in {{game_name}}?"
+
+### 4. Generate Mechanics Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Game Mechanics
+
+### Primary Mechanics
+
+{{mechanics_list_with_details}}
+
+### Mechanic Interactions
+
+{{how_mechanics_combine}}
+
+### Mechanic Progression
+
+{{how_mechanics_evolve_or_unlock}}
+
+---
+
+## Controls and Input
+
+### Control Scheme ({{primary_platform}})
+
+{{control_mapping_table_or_description}}
+
+### Input Feel
+
+{{how_controls_should_feel}}
+
+### Accessibility Controls
+
+{{planned_accessibility_options}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Mechanics & Controls sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Does each mechanic serve at least one pillar?
+- Do controls feel natural for the platform?
+- Are common actions easily accessible?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into mechanic feel and edge cases
+[P] Party Mode - Test these mechanics with other perspectives
+[C] Continue - Save this and move to Game Type Specifics (Step 7 of 14)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [mechanics content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 3-5 primary mechanics clearly defined
+- Each mechanic linked to pillars
+- Mechanic interactions described
+- Control scheme appropriate for platform
+- Input feel considerations captured
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6]
+
+### SYSTEM FAILURE:
+
+- Mechanics that don't serve pillars
+- Controls inappropriate for target platform
+- Generating content without real user input
+- Missing mechanic interactions
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-07-game-type.md

@@ -0,0 +1,266 @@
+---
+name: 'step-07-game-type'
+description: 'Process game-type specific sections from the loaded game type guide'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-07-game-type.md'
+nextStepFile: '{workflow_path}/steps/step-08-progression.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Game Type Resources
+gameTypesFolder: '{workflow_path}/game-types'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 7: Game Type Specifics
+
+**Progress: Step 7 of 14** - Next: Progression & Balance
+
+## STEP GOAL:
+
+Process the game-type specific sections from the loaded game type guide ({game_type}.md). Each game type has unique sections that must be addressed (e.g., RPGs need character systems, platformers need movement feel, etc.).
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Game type guides contain expert knowledge for specific genres
+- This step varies significantly based on game type
+
+### Step-Specific Rules:
+
+- CRITICAL: Load and process the game type guide file
+- Each section in the guide should be elicited from user
+- FORBIDDEN to generate type-specific content without user input
+- Some game types have optional sections - respect them
+
+## EXECUTION PROTOCOLS:
+
+- Load the game type guide from `{gameTypesFolder}/{game_type}.md`
+- Process each section in the guide sequentially
+- Present A/P/C menu after completing all type-specific sections
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into genre-specific elements
+- **P (Party Mode)**: Get genre expert perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- Game type was determined in step 2 and stored in frontmatter
+- Game type guide should already be loaded in memory from step 2
+- All previous context (pillars, mechanics, etc.) available
+- Type-specific content goes in the {{GAME_TYPE_SPECIFIC_SECTIONS}} placeholder
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Game Type Guide
+
+**CRITICAL FIRST ACTION:**
+
+- Read `game_type` from frontmatter
+- If not already loaded, load `{gameTypesFolder}/{game_type}.md`
+- Parse the guide to identify all sections that need elicitation
+
+**Announce to user:**
+
+"Now we'll work through the **{{game_type}}** specific sections. This game type has unique design elements that we need to define.
+
+**{{game_type}} requires these specific sections:**
+{list_sections_from_game_type_guide}
+
+Let's work through each one."
+
+### 2. Process Each Section from Guide
+
+**For each section defined in the game type guide:**
+
+The game type guide will have sections marked with placeholders like `{{section_name}}`. For each:
+
+1. **Read the guidance** in the guide for this section
+2. **Present the guidance and questions** to the user
+3. **Elicit user input** for this specific section
+4. **Store the content** for final assembly
+
+**Example flow for an RPG game type:**
+
+"**Character System**
+
+Your game type guide suggests addressing:
+
+- Character creation options
+- Attribute/stat system
+- Class or build system
+- Character progression path
+
+{guidance_from_guide}
+
+How do you want the character system to work in {{game_name}}?"
+
+### 3. Handle Optional Sections
+
+Some game type guides have optional sections marked with `[optional]` or similar:
+
+- Present optional sections to user
+- Ask: "This section is optional for {{game_type}}. Would you like to define {{section_name}}?"
+- If yes: elicit content
+- If no: skip and note as "Not applicable for this game"
+
+### 4. Handle Narrative Flags
+
+Some game type guides include narrative flags:
+
+- `<narrative-workflow-critical>` - Story is essential for this game type
+- `<narrative-workflow-recommended>` - Story would enhance this game type
+
+If flag found:
+
+- Store `needs_narrative = true` for use in step 14
+- Note to user: "This game type typically benefits from dedicated narrative design. We'll address this in the final step."
+
+### 5. Generate Game Type Content
+
+Based on all elicited sections, prepare the content:
+
+```markdown
+## {{game_type_name}} Specific Design
+
+{{assembled_sections_from_guide_elicitation}}
+```
+
+The content structure will vary based on game type:
+
+**Example for RPG:**
+
+```markdown
+## RPG Specific Design
+
+### Character System
+
+{{character_system_content}}
+
+### Combat System
+
+{{combat_system_content}}
+
+### Inventory & Equipment
+
+{{inventory_content}}
+
+### Quest System
+
+{{quest_system_content}}
+```
+
+**Example for Platformer:**
+
+```markdown
+## Platformer Specific Design
+
+### Movement Feel
+
+{{movement_feel_content}}
+
+### Jump Mechanics
+
+{{jump_mechanics_content}}
+
+### Hazards & Enemies
+
+{{hazards_content}}
+
+### Collectibles
+
+{{collectibles_content}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the {{game_type}} Specific Design sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Validation Check:**
+
+- Does each section align with your core pillars?
+- Have we covered all required elements for {{game_type}}?
+- Any genre conventions you want to subvert?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into genre specifics
+[P] Party Mode - Get genre expert perspectives
+[C] Continue - Save this and move to Progression & Balance (Step 8 of 14)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}` in place of {{GAME_TYPE_SPECIFIC_SECTIONS}}
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]`
+- If `needs_narrative` flag was set, store in frontmatter
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [game type content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Game type guide loaded and parsed
+- All required sections elicited from user
+- Optional sections offered and handled appropriately
+- Narrative flags detected and stored
+- Content matches game type guide structure
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7]
+
+### SYSTEM FAILURE:
+
+- Not loading the game type guide file
+- Generating type-specific content without user input
+- Missing required sections from the guide
+- Ignoring narrative flags
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-08-progression.md

@@ -0,0 +1,272 @@
+---
+name: 'step-08-progression'
+description: 'Define player progression systems and game balance'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-08-progression.md'
+nextStepFile: '{workflow_path}/steps/step-09-levels.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 8: Progression & Balance
+
+**Progress: Step 8 of 14** - Next: Level Design
+
+## STEP GOAL:
+
+Define how players progress through the game (skill, power, narrative, etc.), the difficulty curve, and any economy or resource systems.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Progression is what keeps players engaged over time
+- Balance determines if the game feels fair and fun
+
+### Step-Specific Rules:
+
+- Focus on player growth and challenge scaling
+- FORBIDDEN to generate progression systems without user input
+- Some games have no explicit progression - that's valid
+- Economy/resources are optional - ask before including
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into progression curves and balance
+- **P (Party Mode)**: Test progression ideas with multiple perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially core loop and mechanics)
+- Progression should reinforce the core loop
+- Balance affects all previously defined mechanics
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Player Progression Discovery
+
+**Guide user through progression definition:**
+
+"Let's define how players grow and progress through {{game_name}}.
+
+**Types of Progression:**
+
+| Type           | Description                                | Examples                  |
+| -------------- | ------------------------------------------ | ------------------------- |
+| **Skill**      | Player gets better at the game             | Dark Souls, Celeste       |
+| **Power**      | Character gets stronger (stats, abilities) | RPGs, Metroidvanias       |
+| **Narrative**  | Story unfolds and advances                 | Visual novels, adventures |
+| **Content**    | New levels, areas, or modes unlock         | Most games                |
+| **Collection** | Gathering items, achievements              | Completionist games       |
+| **Social**     | Rank, reputation, community status         | Competitive games         |
+
+**For {{game_type}} games, typical progression includes:**
+{typical_progression_for_game_type}
+
+**Questions to consider:**
+
+1. What type(s) of progression does {{game_name}} have?
+2. How long until players feel meaningful progress?
+3. Is there a "meta" progression (between runs/sessions)?
+
+How do players progress in {{game_name}}?"
+
+### 2. Difficulty Curve Discovery
+
+**Guide user through difficulty design:**
+
+"Now let's design the difficulty curve.
+
+**Difficulty Curve Patterns:**
+
+| Pattern               | Description                             | Best For                       |
+| --------------------- | --------------------------------------- | ------------------------------ |
+| **Linear**            | Steady increase in challenge            | Story games, first playthrough |
+| **Sawtooth**          | Build-release pattern (easy after hard) | Level-based games              |
+| **Exponential**       | Gentle start, steep late-game           | RPGs, incremental games        |
+| **Flat**              | Consistent challenge throughout         | Roguelikes, skill games        |
+| **Player-controlled** | User selects difficulty                 | Accessibility-focused          |
+
+**Questions to consider:**
+
+1. How does challenge increase over time?
+2. Are there difficulty spikes (bosses, skill checks)?
+3. Can players adjust difficulty? How?
+4. How do you handle players who are stuck?
+
+Describe the difficulty curve for {{game_name}}."
+
+### 3. Economy/Resources Discovery (Optional)
+
+**Ask first:**
+
+"Does {{game_name}} have an in-game economy or resource system?
+
+Examples:
+
+- Currency (gold, coins, gems)
+- Crafting materials
+- Energy/stamina systems
+- Ammunition or consumables
+
+If yes, we'll define it. If no, we'll skip this section."
+
+**If yes:**
+
+"Let's define the economy/resources:
+
+**Economy Questions:**
+
+1. What resources exist?
+2. How are resources earned?
+3. How are resources spent?
+4. Is there inflation/scarcity design?
+5. Are there sinks to remove resources?
+6. Premium currency? (if F2P)
+
+Describe the economy in {{game_name}}."
+
+### 4. Generate Progression Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Progression and Balance
+
+### Player Progression
+
+{{progression_system_description}}
+
+#### Progression Types
+
+{{progression_types_used}}
+
+#### Progression Pacing
+
+{{how_fast_players_progress}}
+
+### Difficulty Curve
+
+{{difficulty_curve_description}}
+
+#### Challenge Scaling
+
+{{how_difficulty_increases}}
+
+#### Difficulty Options
+
+{{accessibility_and_difficulty_settings}}
+
+### Economy and Resources
+
+{{if_has_economy}}
+{{economy_system_description}}
+
+#### Resources
+
+{{resource_types_and_purposes}}
+
+#### Economy Flow
+
+{{earn_and_spend_loop}}
+{{/if_has_economy}}
+
+{{if_no_economy}}
+_This game does not feature an in-game economy or resource system._
+{{/if_no_economy}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Progression & Balance sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Does progression reinforce your core loop?
+- Is the difficulty curve appropriate for your audience?
+- Does the economy (if any) feel fair?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into balance and pacing
+[P] Party Mode - Test these systems with other perspectives
+[C] Continue - Save this and move to Level Design (Step 9 of 14)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [progression content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Progression system clearly defined
+- Difficulty curve appropriate for game type and audience
+- Economy handled correctly (defined or explicitly skipped)
+- Balance considerations documented
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
+
+### SYSTEM FAILURE:
+
+- Generating progression without user input
+- Assuming economy exists without asking
+- Difficulty curve mismatched with audience
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-09-levels.md

@@ -0,0 +1,264 @@
+---
+name: 'step-09-levels'
+description: 'Define level design framework and level progression'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-09-levels.md'
+nextStepFile: '{workflow_path}/steps/step-10-art-audio.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 9: Level Design
+
+**Progress: Step 9 of 14** - Next: Art & Audio
+
+## STEP GOAL:
+
+Define the level design framework including level types, structure, and how levels progress or unlock throughout the game.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Level design is where mechanics meet content
+- Not all games have "levels" - some have open worlds, others are endless
+
+### Step-Specific Rules:
+
+- Focus on spatial design and content structure
+- FORBIDDEN to generate level designs without user input
+- Adapt terminology to game type (levels, stages, areas, dungeons, etc.)
+- Some games have no level structure - that's valid
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into level design principles
+- **P (Party Mode)**: Get perspectives on level structure
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially mechanics and progression)
+- Level design should teach and challenge using defined mechanics
+- Structure should support defined progression system
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Determine Level Structure Type
+
+**First, establish the structural approach:**
+
+"Let's define how {{game_name}} structures its playable content.
+
+**Structure Types:**
+
+| Type                 | Description                       | Examples                    |
+| -------------------- | --------------------------------- | --------------------------- |
+| **Linear Levels**    | Distinct stages played in order   | Mario, Celeste              |
+| **Hub-Based**        | Central area connecting levels    | Mario 64, Hollow Knight     |
+| **Open World**       | Large continuous space            | Breath of the Wild, GTA     |
+| **Procedural**       | Generated levels each playthrough | Spelunky, Dead Cells        |
+| **Arena/Match**      | Self-contained competitive spaces | Fighting games, MOBAs       |
+| **Puzzle Sets**      | Collections of puzzles            | Portal, The Witness         |
+| **Narrative Scenes** | Story-driven segments             | Visual novels, adventures   |
+| **Endless**          | Infinite generated content        | Endless runners, idle games |
+
+**For {{game_type}} games, typical structures include:**
+{typical_structures_for_game_type}
+
+What structure best fits {{game_name}}?"
+
+### 2. Level Types Discovery
+
+**Based on structure choice, elicit level types:**
+
+"Now let's define the types of {levels/areas/stages} in {{game_name}}.
+
+**Questions to consider:**
+
+1. What different environments or settings exist?
+2. Are there tutorial levels? How are they integrated?
+3. Are there boss levels or climax moments?
+4. What's the shortest level? Longest?
+5. Any special or secret levels?
+
+Describe the types of {levels/areas/stages} in {{game_name}}."
+
+### 3. Level Progression Discovery
+
+**Guide user through progression structure:**
+
+"Now let's define how players progress through {levels/areas/content}.
+
+**Progression Models:**
+
+| Model                 | Description                      | Best For               |
+| --------------------- | -------------------------------- | ---------------------- |
+| **Linear Sequence**   | 1 -> 2 -> 3 -> ...               | Story games, tutorials |
+| **Branching Paths**   | Choices lead to different levels | Replayability          |
+| **Open Selection**    | Player chooses order             | Mega Man style         |
+| **Gated Progress**    | Abilities unlock new areas       | Metroidvania           |
+| **Score/Star Unlock** | Performance unlocks levels       | Angry Birds style      |
+| **Story Unlock**      | Narrative triggers unlock        | Adventure games        |
+
+**Questions to consider:**
+
+1. How do players unlock new {levels/areas}?
+2. Can players replay previous {levels/areas}?
+3. Is there a "world map" or selection screen?
+4. How is the final {level/area} unlocked?
+
+How do players progress through {{game_name}}'s content?"
+
+### 4. Level Design Principles (Optional)
+
+"Would you like to establish specific level design principles or guidelines for {{game_name}}?
+
+Examples:
+
+- 'Teach through play, never through text'
+- 'Every room has one new idea'
+- '30 second rule - something interesting every 30 seconds'
+- 'Left is safety, right is danger'
+
+These can guide consistent level design throughout development."
+
+### 5. Generate Level Design Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Level Design Framework
+
+### Structure Type
+
+{{structure_type_description}}
+
+### Level Types
+
+{{level_types_list}}
+
+#### Tutorial Integration
+
+{{how_tutorials_work}}
+
+#### Special Levels
+
+{{boss_levels_secret_levels_etc}}
+
+### Level Progression
+
+{{progression_model_description}}
+
+#### Unlock System
+
+{{how_levels_unlock}}
+
+#### Replayability
+
+{{replay_and_revisit_mechanics}}
+
+### Level Design Principles
+
+{{if_has_principles}}
+{{level_design_guidelines}}
+{{/if_has_principles}}
+
+{{if_no_principles}}
+_Level design principles will be established during production._
+{{/if_no_principles}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Level Design Framework based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Validation Check:**
+
+- Does the structure support your core loop?
+- Does progression feel rewarding?
+- Are level types varied enough to maintain interest?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into level design specifics
+[P] Party Mode - Get other perspectives on level structure
+[C] Continue - Save this and move to Art & Audio (Step 10 of 14)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [level design content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Level structure type clearly identified
+- Level types defined with variety
+- Progression model documented
+- Tutorial integration addressed
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+### SYSTEM FAILURE:
+
+- Generating level designs without user input
+- Using wrong terminology for game type
+- Structure doesn't support core loop
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-10-art-audio.md

@@ -0,0 +1,255 @@
+---
+name: 'step-10-art-audio'
+description: 'Define art style and audio direction'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-10-art-audio.md'
+nextStepFile: '{workflow_path}/steps/step-11-technical.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 10: Art & Audio
+
+**Progress: Step 10 of 14** - Next: Technical Specs
+
+## STEP GOAL:
+
+Define the visual art style and audio/music direction for the game, establishing the aesthetic identity that will guide all asset creation.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Art and audio define the player's emotional experience
+- These decisions heavily impact scope and team requirements
+
+### Step-Specific Rules:
+
+- Focus on direction and mood, not specific asset lists
+- FORBIDDEN to generate art/audio direction without user input
+- Reference games or other media when helpful
+- Consider platform constraints on art complexity
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into aesthetic choices
+- **P (Party Mode)**: Get artistic perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially platform and audience)
+- Art style should match game pillars and tone
+- Audio must work on target platform(s)
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Art Style Discovery
+
+**Guide user through visual direction:**
+
+"Let's define the visual identity of {{game_name}}.
+
+**Art Style Categories:**
+
+| Style           | Description                  | Examples                  |
+| --------------- | ---------------------------- | ------------------------- |
+| **Pixel Art**   | Retro-styled discrete pixels | Celeste, Shovel Knight    |
+| **Low-Poly**    | Simple 3D geometry           | Superhot, Monument Valley |
+| **Hand-Drawn**  | Illustration-like visuals    | Cuphead, Hollow Knight    |
+| **Realistic**   | Photorealistic graphics      | AAA titles                |
+| **Stylized 3D** | Non-realistic 3D             | Fortnite, Zelda: BotW     |
+| **Vector/Flat** | Clean shapes, minimal        | Thomas Was Alone          |
+| **Mixed Media** | Combining multiple styles    | Paper Mario               |
+
+**Visual Elements to Consider:**
+
+- **Color Palette:** Vibrant, muted, monochromatic, complementary?
+- **Lighting:** Dramatic, soft, realistic, stylized?
+- **Camera:** 2D side, top-down, isometric, 3D third/first person?
+- **Character Design:** Cute, realistic, abstract, iconic?
+
+**For {{game_type}} on {{platform}}, common art styles include:**
+{typical_art_styles_for_game_type}
+
+What visual style do you envision for {{game_name}}?"
+
+### 2. Art Reference Gathering
+
+"Are there any games, films, or art that inspire the look of {{game_name}}?
+
+Examples help communicate the vision:
+
+- 'The lighting of Limbo with the colors of Journey'
+- 'Pixel art like Hyper Light Drifter but with a warmer palette'
+- 'Studio Ghibli-inspired environments'
+
+What references capture the visual feel you want?"
+
+### 3. Audio Direction Discovery
+
+**Guide user through audio/music direction:**
+
+"Now let's define the audio identity of {{game_name}}.
+
+**Music Style Considerations:**
+
+| Style              | Mood                | Examples              |
+| ------------------ | ------------------- | --------------------- |
+| **Chiptune/8-bit** | Retro, energetic    | Shovel Knight         |
+| **Orchestral**     | Epic, emotional     | Zelda, Final Fantasy  |
+| **Electronic**     | Modern, driving     | Hotline Miami, FURI   |
+| **Ambient**        | Atmospheric, subtle | Journey, INSIDE       |
+| **Rock/Metal**     | Intense, aggressive | DOOM, Devil May Cry   |
+| **Jazz/Lo-fi**     | Chill, stylish      | Persona, VA-11 Hall-A |
+| **Dynamic**        | Adapts to gameplay  | DOOM, Ape Out         |
+
+**Sound Design Considerations:**
+
+- **Feedback Sounds:** How responsive and punchy?
+- **Environmental Audio:** How immersive?
+- **Voice/Dialogue:** None, grunts, partial, full VO?
+- **Accessibility:** Audio cues for visual elements?
+
+**For {{game_type}} games, typical audio approaches include:**
+{typical_audio_for_game_type}
+
+What audio direction fits {{game_name}}?"
+
+### 4. Generate Art & Audio Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Art and Audio Direction
+
+### Art Style
+
+{{art_style_description}}
+
+#### Visual References
+
+{{reference_games_and_media}}
+
+#### Color Palette
+
+{{color_direction}}
+
+#### Camera and Perspective
+
+{{camera_style}}
+
+### Audio and Music
+
+{{audio_direction_description}}
+
+#### Music Style
+
+{{music_genre_and_mood}}
+
+#### Sound Design
+
+{{sound_design_approach}}
+
+#### Voice/Dialogue
+
+{{voice_approach}}
+
+### Aesthetic Goals
+
+{{how_art_and_audio_support_game_pillars}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Art & Audio Direction based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Does the art style support your game pillars?
+- Is the audio direction achievable for your scope?
+- Do art and audio work together cohesively?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into aesthetic details
+[P] Party Mode - Get artistic perspectives
+[C] Continue - Save this and move to Technical Specs (Step 11 of 14)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [art/audio content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Art style clearly defined with references
+- Audio direction documented
+- Aesthetic supports game pillars and tone
+- Platform constraints considered
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+### SYSTEM FAILURE:
+
+- Generating art/audio direction without user input
+- Art style inappropriate for target platform
+- Missing references that help communicate vision
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-11-technical.md

@@ -0,0 +1,275 @@
+---
+name: 'step-11-technical'
+description: 'Define technical specifications and requirements'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-11-technical.md'
+nextStepFile: '{workflow_path}/steps/step-12-epics.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 11: Technical Specifications
+
+**Progress: Step 11 of 14** - Next: Epic Structure
+
+## STEP GOAL:
+
+Define technical requirements including performance targets, platform-specific details, and asset requirements. This provides a bridge to the architecture workflow.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Technical specs inform the architecture workflow
+- Not all technical decisions are made here - architecture comes later
+
+### Step-Specific Rules:
+
+- Focus on requirements, not implementation details
+- FORBIDDEN to generate tech specs without user input
+- Keep scope appropriate - detailed architecture comes in a separate workflow
+- Reference target platform(s) from step 3
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into technical requirements
+- **P (Party Mode)**: Get technical perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially platform from step 3)
+- This is GDD-level specs, not architecture-level details
+- Engine/framework selection happens in architecture workflow
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Performance Requirements Discovery
+
+**Guide user through performance targets:**
+
+"Let's define the technical requirements for {{game_name}}.
+
+**Performance Targets:**
+
+| Platform    | Typical Targets                             |
+| ----------- | ------------------------------------------- |
+| **PC**      | 60fps @ 1080p minimum, 4K optional          |
+| **Console** | 30fps or 60fps depending on visual fidelity |
+| **Mobile**  | 30fps, thermal management, battery life     |
+| **Web**     | 30-60fps, file size under 50MB              |
+| **VR**      | 72-90fps minimum, latency critical          |
+
+**For {{game_type}} on {{platform}}:**
+
+**Questions to consider:**
+
+1. What frame rate are you targeting?
+2. What resolutions should be supported?
+3. What's the acceptable load time?
+4. Any specific performance priorities? (visuals vs frame rate)
+
+What are your performance targets for {{game_name}}?"
+
+### 2. Platform-Specific Requirements
+
+**Guide user through platform details:**
+
+"Now let's capture platform-specific considerations for {{platform}}.
+
+**Platform-Specific Questions:**
+
+**PC:**
+
+- Minimum and recommended specs?
+- Steam/Epic/itch.io features to support?
+- Mod support planned?
+- Cloud saves?
+
+**Console:**
+
+- Certification requirements awareness?
+- Controller-only or hybrid input?
+- Achievement/trophy integration?
+
+**Mobile:**
+
+- iOS minimum version? Android API level?
+- Portrait, landscape, or both?
+- Offline play required?
+- In-app purchases planned?
+
+**Web:**
+
+- Target browsers?
+- WebGL version?
+- Maximum build size?
+
+What platform-specific requirements matter for {{game_name}}?"
+
+### 3. Asset Requirements Discovery
+
+**Guide user through asset considerations:**
+
+"Finally, let's document asset requirements and constraints.
+
+**Asset Categories:**
+
+| Category             | Considerations                        |
+| -------------------- | ------------------------------------- |
+| **Sprites/Textures** | Resolution, count estimates, atlasing |
+| **3D Models**        | Poly budgets, LOD levels, rigging     |
+| **Animations**       | Frame counts, skeletal vs sprite      |
+| **Audio**            | Music tracks, SFX count, voice lines  |
+| **UI**               | Resolution scaling, localization      |
+
+**Questions to consider:**
+
+1. What are the major asset categories you'll need?
+2. Any rough estimates on asset counts?
+3. What quality level are you targeting?
+4. Any external assets planned (asset store, licensed content)?
+
+What are the key asset requirements for {{game_name}}?"
+
+### 4. Generate Technical Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Technical Specifications
+
+### Performance Requirements
+
+{{performance_targets_description}}
+
+#### Frame Rate Target
+
+{{target_fps}}
+
+#### Resolution Support
+
+{{resolution_targets}}
+
+#### Load Times
+
+{{load_time_requirements}}
+
+### Platform-Specific Details
+
+{{platform_specific_requirements}}
+
+#### {{platform}} Requirements
+
+{{platform_details}}
+
+### Asset Requirements
+
+{{asset_requirements_overview}}
+
+#### Art Assets
+
+{{art_asset_requirements}}
+
+#### Audio Assets
+
+{{audio_asset_requirements}}
+
+#### External Assets
+
+{{third_party_asset_plans}}
+
+### Technical Constraints
+
+{{any_known_limitations_or_requirements}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Technical Specifications based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Note:** This is GDD-level technical planning. Detailed architecture decisions (engine selection, specific technologies, system design) will be addressed in the Architecture workflow after the GDD is complete.
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into technical requirements
+[P] Party Mode - Get technical perspectives
+[C] Continue - Save this and move to Epic Structure (Step 12 of 14)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [technical content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Performance targets clearly defined
+- Platform-specific requirements documented
+- Asset requirements outlined
+- Scope appropriate for GDD (not architecture-level detail)
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+### SYSTEM FAILURE:
+
+- Generating tech specs without user input
+- Going too deep into architecture details
+- Missing key platform requirements
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-12-epics.md

@@ -0,0 +1,284 @@
+---
+name: 'step-12-epics'
+description: 'Define development epics and high-level story breakdown'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-12-epics.md'
+nextStepFile: '{workflow_path}/steps/step-13-metrics.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+epicsOutputFile: '{output_folder}/epics.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 12: Epic Structure
+
+**Progress: Step 12 of 14** - Next: Success Metrics
+
+## STEP GOAL:
+
+Translate the game features defined throughout the GDD into development epics, each with a clear scope and list of high-level stories. This provides the foundation for sprint planning.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Epics bridge design (GDD) to implementation (sprints)
+- Epic scope should be completable in 1-4 sprints
+
+### Step-Specific Rules:
+
+- Focus on feature groupings, not detailed task breakdowns
+- FORBIDDEN to generate epics without user input
+- Each epic should deliver playable value
+- Stories are high-level here - detailed stories come in sprint planning
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Refine epic scopes and boundaries
+- **P (Party Mode)**: Get perspectives on epic organization
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All GDD content from previous steps available
+- Epics should map to game pillars and features
+- This creates both GDD epic summary and detailed epics.md file
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Review Game Features for Epic Candidates
+
+**Analyze the GDD content:**
+
+"Let's organize {{game_name}}'s features into development epics.
+
+Based on everything we've defined, here are the major feature areas I've identified:
+
+**From Core Gameplay:** {{core_loop_features}}
+**From Mechanics:** {{mechanics_features}}
+**From Game Type Specifics:** {{game_type_features}}
+**From Progression:** {{progression_features}}
+**From Level Design:** {{level_features}}
+**From Art/Audio:** {{art_audio_features}}
+**From Technical:** {{technical_features}}
+
+**Epic Organization Principles:**
+
+1. **Playable Milestones:** Each epic should result in something playable
+2. **Dependency Awareness:** Some epics must come before others
+3. **Vertical Slices:** Early epics often prove core gameplay
+4. **Scope Control:** 1-4 sprints per epic is ideal
+
+How would you like to group these features into epics?"
+
+### 2. Define Epic Structure
+
+**For each epic, elicit:**
+
+"Let's define **Epic {{number}}: {{epic_name}}**
+
+**Epic Definition Questions:**
+
+1. **Goal:** What does completing this epic achieve?
+2. **Includes:** What features/systems are in this epic?
+3. **Excludes:** What specifically is NOT in this epic?
+4. **Dependencies:** What epics must come before this?
+5. **Deliverable:** What's the playable result?
+
+Describe this epic."
+
+### 3. Generate High-Level Stories
+
+**For each epic, generate story candidates:**
+
+"For **Epic {{number}}: {{epic_name}}**, let's identify high-level stories.
+
+**Story Principles:**
+
+- Each story is independently valuable
+- Stories should be completable in 1-3 days
+- Use format: 'As a [player], I can [action] so that [benefit]'
+
+What are the main stories in this epic?"
+
+### 4. Determine Epic Order and Dependencies
+
+**Guide user through sequencing:**
+
+"Now let's determine the order for these epics.
+
+**Common Epic Sequences:**
+
+1. **Foundation First:** Core systems before content
+2. **Vertical Slice Early:** Prove gameplay ASAP
+3. **Polish Last:** Visual/audio polish after mechanics solid
+
+**Your epics:**
+{{list_of_epics}}
+
+What order makes sense for {{game_name}}?"
+
+### 5. Generate Epic Content
+
+Based on the conversation, prepare two outputs:
+
+**A. GDD Epic Summary (goes in gdd.md):**
+
+```markdown
+## Development Epics
+
+### Epic Overview
+
+| #   | Epic Name | Scope | Dependencies | Est. Stories |
+| --- | --------- | ----- | ------------ | ------------ |
+
+{{epic_table}}
+
+### Recommended Sequence
+
+{{epic_sequence_with_rationale}}
+
+### Vertical Slice
+
+**The first playable milestone:** {{vertical_slice_description}}
+```
+
+**B. Detailed Epics File (goes in epics.md):**
+
+```markdown
+# {{game_name}} - Development Epics
+
+## Epic Overview
+
+{{epic_overview_table}}
+
+---
+
+## Epic 1: {{epic_1_name}}
+
+### Goal
+
+{{epic_1_goal}}
+
+### Scope
+
+**Includes:**
+{{epic_1_includes}}
+
+**Excludes:**
+{{epic_1_excludes}}
+
+### Dependencies
+
+{{epic_1_dependencies}}
+
+### Deliverable
+
+{{epic_1_deliverable}}
+
+### Stories
+
+{{epic_1_stories_list}}
+
+---
+
+{{repeat_for_each_epic}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Epic Structure based on our conversation.
+
+**For the GDD (gdd.md):**
+[Show GDD epic summary]
+
+**For the Epics file (epics.md):**
+[Show detailed epics structure]
+
+**Validation Check:**
+
+- Does each epic deliver playable value?
+- Is the sequence achievable?
+- Are dependencies clear?
+
+**Select an Option:**
+[A] Advanced Elicitation - Refine epic organization
+[P] Party Mode - Get perspectives on epic structure
+[C] Continue - Save this and move to Success Metrics (Step 13 of 14)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append epic summary to `{outputFile}`
+- Write detailed epics to `{epicsOutputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [both epic content files saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Epics cover all major game features
+- Each epic has clear scope and deliverable
+- Dependencies identified and sequenced
+- Both gdd.md and epics.md updated
+- High-level stories drafted for each epic
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted
+
+### SYSTEM FAILURE:
+
+- Generating epics without user input
+- Epics that don't deliver playable value
+- Missing key features from GDD
+- Not creating separate epics.md file
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-13-metrics.md

@@ -0,0 +1,250 @@
+---
+name: 'step-13-metrics'
+description: 'Define success metrics for technical and gameplay evaluation'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-13-metrics.md'
+nextStepFile: '{workflow_path}/steps/step-14-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 13: Success Metrics
+
+**Progress: Step 13 of 14** - Next: Final Steps
+
+## STEP GOAL:
+
+Define measurable success metrics for both technical performance and gameplay quality. These metrics help evaluate whether the game meets its design goals.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Metrics should be measurable and actionable
+- Focus on metrics that indicate design success, not just technical success
+
+### Step-Specific Rules:
+
+- Focus on defining what success looks like
+- FORBIDDEN to generate metrics without user input
+- Metrics should relate back to game pillars and goals
+- Include both quantitative and qualitative measures
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into metric selection
+- **P (Party Mode)**: Get perspectives on success criteria
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All GDD content from previous steps available
+- Metrics should map to stated goals and pillars
+- Technical metrics from performance requirements
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Technical Metrics Discovery
+
+**Guide user through technical success criteria:**
+
+"Let's define how we'll measure technical success for {{game_name}}.
+
+**Technical Metric Categories:**
+
+| Category        | Example Metrics                                  |
+| --------------- | ------------------------------------------------ |
+| **Performance** | Frame rate consistency, load times, memory usage |
+| **Stability**   | Crash rate, bug severity distribution            |
+| **Platform**    | Certification pass rate, store review score      |
+| **Build**       | Build time, test coverage, asset size            |
+
+**Your performance targets from earlier:**
+
+- Frame rate: {{target_fps}}
+- Platform: {{platform}}
+
+**Questions to consider:**
+
+1. What technical metrics matter most for {{game_type}}?
+2. How will you measure performance in the field?
+3. What's an acceptable crash rate?
+4. Are there platform-specific metrics to track?
+
+What technical metrics will indicate success for {{game_name}}?"
+
+### 2. Gameplay Metrics Discovery
+
+**Guide user through gameplay success criteria:**
+
+"Now let's define gameplay metrics - how we know the design is working.
+
+**Gameplay Metric Categories:**
+
+| Category                | Example Metrics                                   |
+| ----------------------- | ------------------------------------------------- |
+| **Engagement**          | Session length, sessions per week, retention      |
+| **Progression**         | Completion rates, time-to-milestone, churn points |
+| **Difficulty**          | Death/retry rates, difficulty setting usage       |
+| **Feature Usage**       | Which mechanics are used, feature discovery       |
+| **Player Satisfaction** | Ratings, reviews, NPS                             |
+
+**Your game pillars are:** {{pillars}}
+**Your goals are:** {{goals}}
+
+**Questions to consider:**
+
+1. How will you know if players are having the intended experience?
+2. What retention rates would indicate success?
+3. How will you identify frustration points?
+4. What playtesting metrics will you track?
+
+What gameplay metrics will indicate success for {{game_name}}?"
+
+### 3. Qualitative Success Criteria
+
+**Guide user through qualitative measures:**
+
+"Finally, let's define qualitative success criteria - things that are harder to measure but equally important.
+
+**Qualitative Criteria Examples:**
+
+- 'Players describe the game using our pillar words'
+- 'Streamers enjoy playing without instruction'
+- 'Community creates fan content'
+- 'Players recommend to friends'
+- 'Reviews mention the unique selling points'
+
+What qualitative signs would tell you {{game_name}} is successful?"
+
+### 4. Generate Metrics Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Success Metrics
+
+### Technical Metrics
+
+{{technical_metrics_list}}
+
+#### Key Technical KPIs
+
+| Metric | Target | Measurement Method |
+| ------ | ------ | ------------------ |
+
+{{technical_kpi_table}}
+
+### Gameplay Metrics
+
+{{gameplay_metrics_list}}
+
+#### Key Gameplay KPIs
+
+| Metric | Target | Measurement Method |
+| ------ | ------ | ------------------ |
+
+{{gameplay_kpi_table}}
+
+### Qualitative Success Criteria
+
+{{qualitative_criteria_list}}
+
+### Metric Review Cadence
+
+{{when_and_how_metrics_will_be_reviewed}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Success Metrics based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Do metrics align with your game pillars?
+- Are targets achievable and measurable?
+- Can you actually collect this data?
+
+**Select an Option:**
+[A] Advanced Elicitation - Refine metric selection
+[P] Party Mode - Get perspectives on success criteria
+[C] Continue - Save this and move to Final Steps (Step 14 of 14)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [metrics content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Technical metrics defined with targets
+- Gameplay metrics tied to pillars and goals
+- Qualitative criteria documented
+- Metrics are actually measurable
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted
+
+### SYSTEM FAILURE:
+
+- Generating metrics without user input
+- Metrics that can't be measured
+- Missing connection to game pillars/goals
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/gdd/steps/step-14-complete.md

@@ -0,0 +1,335 @@
+---
+name: 'step-14-complete'
+description: 'Document out of scope items, capture assumptions, and provide handoff guidance'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-14-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+epicsFile: '{output_folder}/epics.md'
+
+# Workflow References
+narrativeWorkflow: '{project-root}/_bmad/bmgd/workflows/2-design/narrative/workflow.yaml'
+architectureWorkflow: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.yaml'
+---
+
+# Step 14: Complete & Handoff
+
+**Progress: Step 14 of 14** - GDD Complete!
+
+## STEP GOAL:
+
+Document what is explicitly out of scope, capture key assumptions and dependencies, and provide clear next steps for the game development process.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- This is the final step - ensure completeness
+- Provide clear actionable next steps
+
+### Step-Specific Rules:
+
+- Focus on scope boundaries and assumptions
+- Check if narrative workflow is recommended
+- Provide concrete next steps based on workflow status
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Generate final sections without A/P/C menu (just confirmation)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]`
+- Present completion summary and next steps
+
+## CONTEXT BOUNDARIES:
+
+- All GDD content from previous steps available
+- Check for `needs_narrative` flag from step 7
+- Reference workflow-status if integrated with BMM
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Out of Scope Discovery
+
+**Guide user through scope boundaries:**
+
+"Let's document what is explicitly NOT in scope for {{game_name}} v1.0.
+
+**Out of Scope Categories:**
+
+| Category         | Examples                               |
+| ---------------- | -------------------------------------- |
+| **Features**     | Multiplayer, level editor, mod support |
+| **Content**      | Additional game modes, DLC areas       |
+| **Platforms**    | Console ports, VR version              |
+| **Polish**       | Full voice acting, orchestral score    |
+| **Localization** | Additional languages                   |
+
+**Questions to consider:**
+
+1. What features have you intentionally cut for v1.0?
+2. What platforms are NOT in initial scope?
+3. What post-launch content are you deferring?
+4. What's 'nice to have' vs 'required for launch'?
+
+What's explicitly out of scope for {{game_name}} v1.0?"
+
+### 2. Assumptions and Dependencies Discovery
+
+**Guide user through assumptions:**
+
+"Now let's document key assumptions and dependencies.
+
+**Assumption Categories:**
+
+| Category      | Examples                                                          |
+| ------------- | ----------------------------------------------------------------- |
+| **Technical** | 'Unity LTS will remain stable', 'Players have controllers'        |
+| **Team**      | 'Art contractor available Q2', 'Solo developer capacity'          |
+| **External**  | 'Steam review approval in 2 weeks', 'Asset store assets licensed' |
+| **Market**    | 'Genre remains popular', 'Pricing assumptions'                    |
+
+**Dependency Categories:**
+
+| Category        | Examples                                  |
+| --------------- | ----------------------------------------- |
+| **Third-party** | Middleware, plugins, asset licenses       |
+| **Services**    | Backend providers, analytics, multiplayer |
+| **Content**     | External art, music, voice acting         |
+| **Platform**    | SDK versions, certification requirements  |
+
+What assumptions is {{game_name}} built on? What external dependencies exist?"
+
+### 3. Check Narrative Workflow Recommendation
+
+**Check if game type suggested narrative:**
+
+If `needs_narrative` flag is true (from step 7):
+
+"**Narrative Recommendation:**
+
+Based on your game type ({{game_type}}), a dedicated Narrative Design Document would benefit {{game_name}}. This covers:
+
+- Story structure and arcs
+- Character development
+- World lore and history
+- Dialogue framework
+- Environmental storytelling
+
+Would you like to create a Narrative Design Document as your next step?"
+
+Store user response for next steps.
+
+### 4. Generate Completion Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Out of Scope
+
+{{out_of_scope_items}}
+
+### Deferred to Post-Launch
+
+{{post_launch_items}}
+
+---
+
+## Assumptions and Dependencies
+
+### Key Assumptions
+
+{{assumptions_list}}
+
+### External Dependencies
+
+{{dependencies_list}}
+
+### Risk Factors
+
+{{risks_based_on_assumptions}}
+
+---
+
+## Document Information
+
+**Document:** {{game_name}} - Game Design Document
+**Version:** 1.0
+**Created:** {{date}}
+**Author:** {{user_name}}
+**Status:** Complete
+
+### Change Log
+
+| Version | Date     | Changes              |
+| ------- | -------- | -------------------- |
+| 1.0     | {{date}} | Initial GDD complete |
+```
+
+### 5. Present Completion Summary
+
+"**GDD Complete!**
+
+{{user_name}}, the Game Design Document for **{{game_name}}** is now complete!
+
+**Document Summary:**
+
+- **Game Type:** {{game_type}}
+- **Platform:** {{platform}}
+- **Epics:** {{epic_count}} development epics
+- **Estimated Stories:** {{story_estimate}}
+
+**Files Created:**
+
+- `gdd.md` - Full Game Design Document
+- `epics.md` - Detailed epic and story breakdown
+
+**GDD Sections Completed:**
+
+1. Executive Summary & Game Type
+2. Platforms & Target Audience
+3. Goals & Unique Selling Points
+4. Core Gameplay (Pillars, Loop, Win/Loss)
+5. Game Mechanics & Controls
+6. {{game_type}} Specific Design
+7. Progression & Balance
+8. Level Design Framework
+9. Art & Audio Direction
+10. Technical Specifications
+11. Development Epics
+12. Success Metrics
+13. Out of Scope & Assumptions
+
+Do you want me to add or modify anything before we finalize?"
+
+### 6. Present Next Steps
+
+**After user confirms completion:**
+
+"**Next Steps for {{game_name}}:**
+
+{{if needs_narrative and user_wants_narrative}}
+**Immediate Next Step:**
+
+1. **Narrative Design Document** - Create story, characters, and world lore
+   - Command: `narrative` (Game Designer agent)
+   - Input: This GDD
+   - Output: narrative-design.md
+     {{/if}}
+
+**Required Next Steps:**
+
+1. **Game Architecture** - Define engine, tech stack, and system design
+   - Command: `create-architecture` (Game Architect agent)
+   - Input: This GDD
+   - Output: architecture.md
+
+2. **Sprint Planning** - Set up your first development sprint
+   - Command: `sprint-planning` (Scrum Master agent)
+   - Input: GDD + epics.md
+   - Output: sprint-status.yaml
+
+**Recommended Actions:**
+
+- [ ] Review GDD with any team members or stakeholders
+- [ ] Create a prototype for core gameplay validation
+- [ ] Set up project repository and dev environment
+- [ ] Gather reference materials for art direction
+
+**Which would you like to do next?**
+
+1. {{if needs_narrative}}Create Narrative Design Document{{else}}Create Game Architecture{{/if}}
+2. Start Sprint Planning
+3. Review the completed GDD
+4. Exit workflow"
+
+### 7. Handle User Selection
+
+Based on user choice:
+
+**If 1 (Narrative or Architecture):**
+
+- Update frontmatter with final `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]`
+- Provide handoff guidance for next workflow
+
+**If 2 (Sprint Planning):**
+
+- Update frontmatter with final stepsCompleted
+- Provide handoff guidance for sprint planning
+
+**If 3 (Review):**
+
+- Present document summary
+- Offer to highlight any sections
+- Return to next steps menu
+
+**If 4 (Exit):**
+
+- Update frontmatter with final stepsCompleted
+- Confirm GDD is saved
+- Exit workflow gracefully
+
+## CRITICAL STEP COMPLETION NOTE
+
+This is the final step. Ensure:
+
+- All content is saved to gdd.md
+- Frontmatter shows all 14 steps completed
+- User has clear actionable next steps
+- Handoff to next workflow is smooth
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Out of scope clearly documented
+- Assumptions and dependencies captured
+- Narrative workflow recommendation handled
+- Final document status updated
+- Clear next steps provided
+- Smooth handoff to next workflow
+
+### SYSTEM FAILURE:
+
+- Missing out of scope documentation
+- Not checking for narrative flag
+- No clear next steps provided
+- Frontmatter not updated to show completion
+- User left without actionable guidance
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+---
+
+## GDD Workflow Complete
+
+The GDD workflow transforms a game concept into a comprehensive design document through 14 collaborative steps:
+
+1. **Initialize** - Set up workflow and discover input documents
+2. **Context** - Determine game type and load relevant guide
+3. **Platforms** - Define target platforms and audience
+4. **Vision** - Establish goals, context, and USPs
+5. **Core Gameplay** - Define pillars, loop, and win/loss
+6. **Mechanics** - Detail player actions and controls
+7. **Game Type** - Process genre-specific sections
+8. **Progression** - Design player growth and balance
+9. **Levels** - Structure playable content
+10. **Art & Audio** - Establish aesthetic direction
+11. **Technical** - Define performance requirements
+12. **Epics** - Organize features into development units
+13. **Metrics** - Define success criteria
+14. **Complete** - Document scope and hand off
+
+This step-file architecture ensures consistent, thorough GDD creation with user collaboration at every step.

src/modules/bmgd/workflows/2-design/gdd/workflow.md

@@ -0,0 +1,61 @@
+---
+name: create-gdd
+description: Creates a comprehensive Game Design Document through collaborative step-by-step discovery between game designer and user.
+main_config: '{project-root}/_bmad/bmgd/config.yaml'
+web_bundle: true
+---
+
+# GDD Workflow
+
+**Goal:** Create comprehensive Game Design Documents through collaborative step-by-step discovery between game designer and user.
+
+**Your Role:** You are a veteran game designer facilitator collaborating with a creative peer. This is a partnership, not a client-vendor relationship. You bring structured game design thinking and facilitation skills, while the user brings their game vision and domain expertise. Work together as equals. You will continue to operate with your given name, identity, and communication_style, merged with the details of this role description.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self contained instruction file that is a part of an overall workflow that must be followed exactly
+- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
+- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
+- **Append-Only Building**: Build documents by appending content as directed to the output file
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, load, read entire file, then execute the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- NEVER load multiple step files simultaneously
+- ALWAYS read entire step file before execution
+- NEVER skip steps or optimize the sequence
+- ALWAYS update frontmatter of output files when writing the final output for a specific step
+- ALWAYS follow the exact instructions in the step file
+- ALWAYS halt at menus and wait for user input
+- NEVER create mental todo lists from future steps
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from {main_config} and resolve:
+
+- `project_name`, `output_folder`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+
+### 2. First Step EXECUTION
+
+Load, read the full file and then execute `steps/step-01-init.md` to begin the workflow.

src/modules/bmgd/workflows/2-design/gdd/workflow.yaml

@@ -12,14 +12,14 @@ document_output_language: "{config_source}:document_output_language"
 game_dev_experience: "{config_source}:game_dev_experience"
 date: system-generated
 
-# Workflow components
+# Workflow components - Step-file architecture
 installed_path: "{project-root}/_bmad/bmgd/workflows/2-design/gdd"
-instructions: "{installed_path}/instructions-gdd.md"
-template: "{installed_path}/gdd-template.md"
+instructions: "{installed_path}/workflow.md"
+template: "{installed_path}/templates/gdd-template.md"
 game_types_csv: "{installed_path}/game-types.csv"
 
 # Output configuration
-default_output_file: "{output_folder}/GDD.md"
+default_output_file: "{output_folder}/gdd.md"
 
 # Game type references (loaded based on game type selection)
 game_type_guides: "{installed_path}/game-types/"
@@ -50,11 +50,31 @@ web_bundle:
   name: "gdd"
   description: "Game Design Document workflow for all game project levels - from small prototypes to full AAA games. Generates comprehensive GDD with game mechanics, systems, progression, and implementation guidance."
   author: "BMad"
-  instructions: "_bmad/bmgd/workflows/2-design/gdd/instructions-gdd.md"
+  instructions: "_bmad/bmgd/workflows/2-design/gdd/workflow.md"
   web_bundle_files:
-    - "_bmad/bmgd/workflows/2-design/gdd/instructions-gdd.md"
-    - "_bmad/bmgd/workflows/2-design/gdd/gdd-template.md"
+    # Main workflow file
+    - "_bmad/bmgd/workflows/2-design/gdd/workflow.md"
+    # Step files
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-01-init.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-01b-continue.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-02-context.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-03-platforms.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-04-vision.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-05-core-gameplay.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-06-mechanics.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-07-game-type.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-08-progression.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-09-levels.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-10-art-audio.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-11-technical.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-12-epics.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-13-metrics.md"
+    - "_bmad/bmgd/workflows/2-design/gdd/steps/step-14-complete.md"
+    # Template
+    - "_bmad/bmgd/workflows/2-design/gdd/templates/gdd-template.md"
+    # Data files
     - "_bmad/bmgd/workflows/2-design/gdd/game-types.csv"
+    # Game type guides
     - "_bmad/bmgd/workflows/2-design/gdd/game-types/action-platformer.md"
     - "_bmad/bmgd/workflows/2-design/gdd/game-types/adventure.md"
     - "_bmad/bmgd/workflows/2-design/gdd/game-types/card-game.md"

src/modules/bmgd/workflows/2-design/narrative/steps/step-01-init.md

@@ -0,0 +1,228 @@
+---
+name: 'step-01-init'
+description: 'Initialize narrative workflow, load GDD context, and assess narrative complexity'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-init.md'
+continueStepFile: '{workflow_path}/steps/step-01b-continue.md'
+nextStepFile: '{workflow_path}/steps/step-02-foundation.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+templateFile: '{workflow_path}/templates/narrative-template.md'
+---
+
+# Step 1: Initialize Narrative Workflow
+
+**Progress: Step 1 of 11** - Next: Story Foundation
+
+## STEP GOAL:
+
+Validate workflow readiness, check for existing narrative document, load GDD context, and assess the appropriate level of narrative complexity for this game.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Help users craft THEIR story, not yours
+- Narrative complexity should match the game
+
+### Step-Specific Rules:
+
+- Check for existing narrative before starting fresh
+- Load GDD to understand game context
+- Let user confirm narrative complexity level
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Wait for user confirmation at each checkpoint
+- Update frontmatter `stepsCompleted: [1]` before loading next step
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Check Workflow Status
+
+**Search for workflow status file:**
+
+Check if `{output_folder}/bmgd-workflow-status.yaml` exists.
+
+**If status file found:**
+
+- Load and parse workflow_status section
+- Check status of "narrative" workflow
+- Determine if this is the expected next workflow
+
+**Handle scenarios:**
+
+- If already completed: Ask about overwriting
+- If out of sequence: Warn and confirm continuation
+- Set `standalone_mode` appropriately
+
+### 2. Check for Existing Narrative
+
+**Search for existing narrative document:**
+
+Look for existing narrative files in {output_folder}:
+
+- `*narrative*.md`
+- `*story*.md`
+
+**If existing narrative found:**
+
+"I found an existing narrative document: `{{existing_file}}`
+
+**Options:**
+
+1. **Continue** - Resume from where you left off
+2. **Start Fresh** - Begin a new narrative (will overwrite)
+3. **Review** - Let me review the existing document first
+
+Which would you like to do?"
+
+**Handle selection:**
+
+- If **Continue**: Load `{continueStepFile}`
+- If **Start Fresh**: Continue with step 3
+- If **Review**: Show document summary
+
+### 3. Load GDD Context
+
+**Search for GDD:**
+
+Look for GDD files using patterns:
+
+- `{output_folder}/*gdd*.md`
+- `{output_folder}/*game-design*.md`
+
+**If GDD not found:**
+
+"**Note: GDD Not Found**
+
+The Narrative workflow works best with a completed GDD.
+
+**Options:**
+
+1. Continue without GDD (I'll ask more questions)
+2. Run GDD workflow first: `create-gdd`
+
+Your choice:"
+
+**If GDD found:**
+
+Load and extract:
+
+- `game_type`
+- `game_name`
+- Any existing narrative mentions
+- Core mechanics and themes
+
+### 4. Assess Narrative Complexity
+
+"**Narrative Complexity Assessment**
+
+Let's determine the right depth for your narrative design.
+
+**Narrative Complexity Levels:**
+
+| Level        | Description             | Examples                       |
+| ------------ | ----------------------- | ------------------------------ |
+| **Critical** | Story IS the game       | Visual Novel, Text Adventure   |
+| **Heavy**    | Story drives experience | Story RPG, Narrative Adventure |
+| **Moderate** | Story enhances gameplay | Metroidvania, Horror, Tactics  |
+| **Light**    | Story provides context  | Most action, puzzle, arcade    |
+
+**Based on {{game_type}}, I'd suggest: {{suggested_complexity}}**
+
+What level of narrative complexity does {{game_name}} have?"
+
+### 5. Validate Complexity Choice
+
+**If user selects Light:**
+
+"**Light narrative games usually don't need a full Narrative Design Document.**
+
+Your options:
+
+1. **Proceed anyway** - Create full narrative document
+2. **Quick narrative** - Just the essentials (premise, setting, key characters)
+3. **Expand GDD** - Add narrative sections to existing GDD instead
+
+What would you like to do?"
+
+**Handle selection appropriately.**
+
+### 6. Initialize Output Document
+
+**If proceeding with full narrative:**
+
+Create `{outputFile}` with frontmatter:
+
+```markdown
+---
+title: 'Narrative Design Document'
+project: '{{game_name}}'
+date: '{{date}}'
+author: '{{user_name}}'
+version: '1.0'
+stepsCompleted: [1]
+status: 'in-progress'
+narrativeComplexity: '{{selected_complexity}}'
+gdd: '{{gdd_file}}'
+---
+
+# Narrative Design Document
+
+## {{game_name}}
+
+### Document Status
+
+This narrative document is being created through the BMGD Narrative Workflow.
+
+**Narrative Complexity:** {{selected_complexity}}
+**Steps Completed:** 1 of 11 (Initialize)
+
+---
+
+_Content will be added as we progress through the workflow._
+```
+
+### 7. Proceed to Foundation Step
+
+After initialization:
+
+- Update frontmatter: `stepsCompleted: [1]`
+- Load `{nextStepFile}`
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Workflow status checked appropriately
+- Existing narrative check performed
+- GDD loaded and analyzed (if available)
+- Narrative complexity assessed with user
+- Output document initialized with proper frontmatter
+- Frontmatter updated with stepsCompleted: [1]
+
+### SYSTEM FAILURE:
+
+- Starting without complexity assessment
+- Not checking for existing narrative
+- Proceeding without user confirmation
+- Missing frontmatter initialization
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-01b-continue.md

@@ -0,0 +1,163 @@
+---
+name: 'step-01b-continue'
+description: 'Continue an existing narrative workflow from where it left off'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Step Files (for routing)
+step02: '{workflow_path}/steps/step-02-foundation.md'
+step03: '{workflow_path}/steps/step-03-story.md'
+step04: '{workflow_path}/steps/step-04-characters.md'
+step05: '{workflow_path}/steps/step-05-world.md'
+step06: '{workflow_path}/steps/step-06-dialogue.md'
+step07: '{workflow_path}/steps/step-07-environmental.md'
+step08: '{workflow_path}/steps/step-08-delivery.md'
+step09: '{workflow_path}/steps/step-09-integration.md'
+step10: '{workflow_path}/steps/step-10-production.md'
+step11: '{workflow_path}/steps/step-11-complete.md'
+---
+
+# Step 1b: Continue Existing Narrative
+
+**Resuming Narrative Workflow**
+
+## STEP GOAL:
+
+Load the existing narrative document, determine progress, and route to the appropriate next step.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Step-Specific Rules:
+
+- Parse frontmatter to determine completed steps
+- Present summary of current progress
+- Route to correct next step based on state
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Existing Narrative
+
+**Read the existing narrative document:**
+
+Load `{outputFile}` and parse the frontmatter to extract:
+
+- `stepsCompleted` array
+- `status`
+- `project` name
+- `narrativeComplexity`
+- GDD reference
+
+### 2. Analyze Progress
+
+**Determine workflow state:**
+
+Map completed steps to workflow progress:
+
+- Step 1: Initialize
+- Step 2: Foundation (premise, themes, structure)
+- Step 3: Story (beats and pacing)
+- Step 4: Characters (all characters and arcs)
+- Step 5: World (world, history, locations)
+- Step 6: Dialogue (dialogue systems)
+- Step 7: Environmental (environmental storytelling)
+- Step 8: Delivery (narrative delivery methods)
+- Step 9: Integration (gameplay integration)
+- Step 10: Production (scope and planning)
+- Step 11: Complete
+
+**Calculate next step:**
+
+Find the highest completed step and determine the next step file to load.
+
+### 3. Present Continuation Summary
+
+"**Resuming Narrative Workflow**
+
+{{user_name}}, I found your existing narrative for **{{game_name}}**.
+
+**Progress:** Steps completed: {{stepsCompleted}}
+
+**Narrative Complexity:** {{narrativeComplexity}}
+
+**Sections Completed:**
+{{list_of_completed_sections}}
+
+**Current Status:**
+
+- Last completed: {{last_step_name}}
+- Next step: {{next_step_name}} (Step {{next_step_number}} of 11)
+
+Would you like to:
+
+1. **Continue** - Resume from {{next_step_name}}
+2. **Review** - Show me what we've written so far
+3. **Restart Step** - Redo the last completed step
+
+Select an option:"
+
+### 4. Handle User Selection
+
+**If Continue:**
+
+- Load the next step file based on `stepsCompleted`
+
+**If Review:**
+
+- Present summary of all completed sections
+- Show key narrative elements (premise, characters, etc.)
+- Return to continuation options
+
+**If Restart Step:**
+
+- Decrement stepsCompleted to remove last step
+- Load the step file for the step being restarted
+
+### 5. Route to Next Step
+
+Based on next step number, load the appropriate step file:
+
+| Next Step | File     |
+| --------- | -------- |
+| 2         | {step02} |
+| 3         | {step03} |
+| 4         | {step04} |
+| 5         | {step05} |
+| 6         | {step06} |
+| 7         | {step07} |
+| 8         | {step08} |
+| 9         | {step09} |
+| 10        | {step10} |
+| 11        | {step11} |
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Existing document loaded and parsed
+- Progress accurately determined
+- User presented with clear options
+- Correct step file loaded based on state
+
+### SYSTEM FAILURE:
+
+- Failing to parse frontmatter correctly
+- Loading wrong step file
+- Not presenting continuation options
+- Overwriting existing progress without confirmation
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-02-foundation.md

@@ -0,0 +1,262 @@
+---
+name: 'step-02-foundation'
+description: 'Define narrative premise, themes, tone, and story structure'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-02-foundation.md'
+nextStepFile: '{workflow_path}/steps/step-03-story.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 2: Story Foundation
+
+**Progress: Step 2 of 11** - Next: Story Beats
+
+## STEP GOAL:
+
+Define the narrative foundation: premise, themes, tone/atmosphere, and overall story structure. These elements form the backbone of all narrative content.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Help users articulate THEIR story vision
+- The premise should come from the user
+
+### Step-Specific Rules:
+
+- FORBIDDEN to generate premise without user input
+- Draw out user's ideas through questions
+- Themes should resonate with user's intent
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore themes deeper
+- **P (Party Mode)**: Get perspectives on foundation
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Narrative Premise Discovery
+
+"Let's define the narrative foundation for **{{game_name}}**.
+
+**First, the premise - your story's elevator pitch in 2-3 sentences.**
+
+Good premises have:
+
+- A protagonist with a clear goal
+- An obstacle or conflict
+- Stakes (what happens if they fail?)
+
+**Examples:**
+
+- \"A young knight discovers they're the last hope to stop an ancient evil, but must choose between saving the kingdom or their own family.\"
+- \"After a mysterious pandemic, survivors must navigate a world where telling the truth is deadly but lying corrupts your soul.\"
+
+What's the premise for {{game_name}}?"
+
+### 2. Theme Discovery
+
+"**Now let's identify your core themes.**
+
+Themes are the underlying ideas or messages woven throughout the story.
+
+**Common game themes:**
+
+- Redemption, sacrifice, identity
+- Power and corruption
+- Hope vs. despair
+- Nature vs. technology
+- Freedom vs. control
+- Family, loyalty, betrayal
+
+**Questions to consider:**
+
+- What questions does your story ask?
+- What will players think about after playing?
+- What emotions do you want to evoke?
+
+What are 2-4 core themes for {{game_name}}?"
+
+### 3. Tone and Atmosphere Discovery
+
+"**Let's define the tone and atmosphere.**
+
+Tone shapes how the story feels moment-to-moment.
+
+**Tone spectrums:**
+
+- Dark ←→ Lighthearted
+- Serious ←→ Comedic
+- Gritty ←→ Fantastical
+- Intimate ←→ Epic
+- Hopeful ←→ Melancholic
+
+**Atmosphere elements:**
+
+- Visual mood (colors, lighting)
+- Audio mood (music style)
+- Pacing (contemplative vs. urgent)
+- Emotional register
+
+Describe the tone and atmosphere for {{game_name}}:"
+
+### 4. Story Structure Discovery
+
+"**What story structure will you use?**
+
+**Common structures:**
+
+| Structure          | Description                                            |
+| ------------------ | ------------------------------------------------------ |
+| **3-Act**          | Setup → Confrontation → Resolution                     |
+| **Hero's Journey** | Campbell's monomyth (departure, initiation, return)    |
+| **Kishōtenketsu**  | 4-act: Introduction → Development → Twist → Conclusion |
+| **Episodic**       | Self-contained episodes with overarching arc           |
+| **Branching**      | Multiple paths and endings                             |
+| **Freeform**       | Player-driven, emergent narrative                      |
+
+What structure fits {{game_name}}?"
+
+### 5. Act Breakdown
+
+"**Let's break down your story into acts/sections.**
+
+Based on {{selected_structure}}:
+
+{{structure_specific_prompts}}
+
+Describe each act/section for {{game_name}}:"
+
+### 6. Generate Foundation Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Story Foundation
+
+### Narrative Premise
+
+{{user_premise}}
+
+### Core Themes
+
+{{themes_list_with_descriptions}}
+
+### Tone and Atmosphere
+
+**Tone:** {{tone_description}}
+
+**Atmosphere:** {{atmosphere_description}}
+
+**Emotional Register:** {{emotional_goals}}
+
+---
+
+## Story Structure
+
+### Structure Type
+
+**{{structure_type}}**
+
+{{structure_description}}
+
+### Act Breakdown
+
+{{act_breakdown_details}}
+```
+
+### 7. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Story Foundation based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 6]
+
+**Validation Check:**
+
+- Does the premise capture your vision?
+- Do the themes resonate with your intent?
+- Does the structure fit your gameplay?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore themes and structure deeper
+[P] Party Mode - Get perspectives on foundation
+[C] Continue - Save this and move to Story Beats (Step 3 of 11)"
+
+### 8. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [foundation content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Premise captured from user input
+- Themes identified and described
+- Tone and atmosphere defined
+- Story structure selected and broken down
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2]
+
+### SYSTEM FAILURE:
+
+- Generating premise FOR user
+- Generic themes not connected to user's vision
+- Proceeding without structure breakdown
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-03-story.md

@@ -0,0 +1,238 @@
+---
+name: 'step-03-story'
+description: 'Define major story beats and narrative pacing'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-03-story.md'
+nextStepFile: '{workflow_path}/steps/step-04-characters.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 3: Story Beats
+
+**Progress: Step 3 of 11** - Next: Characters
+
+## STEP GOAL:
+
+Define the major story beats (key narrative moments) and establish pacing and flow throughout the game experience.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Story beats are the skeleton of the narrative
+- Help user identify key moments, don't create them
+
+### Step-Specific Rules:
+
+- FORBIDDEN to generate story beats without user input
+- Guide user through beat mapping
+- Connect beats to structure defined in Step 2
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore beats and connections
+- **P (Party Mode)**: Get perspectives on pacing
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Story Beats Discovery
+
+"**Let's map the major story beats for {{game_name}}.**
+
+Story beats are significant events that drive the narrative forward.
+
+**Key beat types:**
+
+- **Inciting Incident** - What sets the story in motion?
+- **Plot Points** - Major turning points
+- **Midpoint** - Central pivot moment
+- **Climax** - Highest tension point
+- **Resolution** - How things conclude
+
+**Based on your {{structure_type}} structure, list 10-20 key moments.**
+
+Format:
+
+1. [Beat name] - Brief description
+2. [Beat name] - Brief description
+
+What are the major story beats for {{game_name}}?"
+
+### 2. Beat Placement
+
+"**Now let's place these beats within your structure.**
+
+For {{structure_type}}:
+
+**Act 1 beats:**
+Which of your beats belong in the setup/introduction?
+
+**Act 2 beats:**
+Which beats drive the main conflict/development?
+
+**Act 3 beats:**
+Which beats resolve the story?
+
+Let's organize your beats:"
+
+### 3. Pacing Discovery
+
+"**Let's define the pacing and flow.**
+
+**Pacing considerations:**
+
+| Aspect              | Options                           |
+| ------------------- | --------------------------------- |
+| **Overall tempo**   | Slow burn vs. fast-paced          |
+| **Tension pattern** | Escalating vs. waves              |
+| **Story density**   | Heavy sections vs. light sections |
+| **Player agency**   | Mandatory vs. optional content    |
+
+**Questions:**
+
+- When should tension be highest?
+- Where are the breathing room moments?
+- How much story per gameplay hour?
+
+Describe the pacing for {{game_name}}:"
+
+### 4. Generate Story Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Story Beats
+
+### Major Story Beats
+
+{{beats_list_with_descriptions}}
+
+### Beat Placement by Act
+
+**Act 1: Setup**
+{{act1_beats}}
+
+**Act 2: Confrontation**
+{{act2_beats}}
+
+**Act 3: Resolution**
+{{act3_beats}}
+
+---
+
+## Pacing and Flow
+
+### Narrative Tempo
+
+{{pacing_description}}
+
+### Tension Curve
+
+{{tension_pattern}}
+
+### Story Density
+
+{{density_by_section}}
+
+### Key Moments
+
+**Highest tension:** {{peak_moment}}
+**Emotional climax:** {{emotional_peak}}
+**Resolution beat:** {{resolution_moment}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've mapped out the story beats and pacing.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Are all major moments captured?
+- Does pacing match your vision?
+- Are beats properly distributed?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore beats and connections
+[P] Party Mode - Get perspectives on pacing
+[C] Continue - Save this and move to Characters (Step 4 of 11)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [story content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 10-20 story beats identified from user input
+- Beats organized by act/structure
+- Pacing and flow defined
+- Tension curve established
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3]
+
+### SYSTEM FAILURE:
+
+- Generating beats FOR user
+- Beats not connected to structure
+- Missing pacing considerations
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-04-characters.md

@@ -0,0 +1,297 @@
+---
+name: 'step-04-characters'
+description: 'Develop all characters including protagonists, antagonists, supporting cast, and their arcs'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-characters.md'
+nextStepFile: '{workflow_path}/steps/step-05-world.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 4: Characters
+
+**Progress: Step 4 of 11** - Next: World Building
+
+## STEP GOAL:
+
+Develop all characters: protagonists, antagonists, and supporting cast. Define their backgrounds, motivations, relationships, and character arcs.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Characters should feel like user's creations
+- Draw out personality through questions
+
+### Step-Specific Rules:
+
+- FORBIDDEN to create characters without user input
+- Guide user through character development
+- Ensure characters connect to themes
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into characters
+- **P (Party Mode)**: Get perspectives on character design
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Protagonist Discovery
+
+"**Let's develop the protagonist(s) of {{game_name}}.**
+
+For each protagonist, tell me:
+
+- **Name and description** - Who are they?
+- **Background** - Where do they come from?
+- **Motivation** - What do they want?
+- **Strengths** - What are they good at?
+- **Flaws** - What holds them back?
+- **Internal conflict** - What do they struggle with inside?
+- **External conflict** - What obstacles do they face?
+
+Describe your protagonist(s):"
+
+### 2. Antagonist Discovery
+
+"**Now let's develop the antagonist(s).**
+
+Great antagonists:
+
+- Have understandable motivations
+- Challenge the protagonist meaningfully
+- May have sympathetic elements
+- Represent or oppose the themes
+
+For each antagonist:
+
+- **Name and description**
+- **Background** - How did they become this way?
+- **Goals** - What do they want?
+- **Methods** - How do they pursue their goals?
+- **Relationship to protagonist**
+- **Sympathetic elements** (if any)
+
+Describe your antagonist(s):"
+
+### 3. Supporting Cast Discovery
+
+"**Let's flesh out the supporting characters.**
+
+Common supporting roles:
+
+- **Mentor** - Guides the protagonist
+- **Ally/Companion** - Travels with protagonist
+- **Foil** - Contrasts protagonist's traits
+- **Love interest** - Romantic connection
+- **Comic relief** - Lightens tone
+- **Informant** - Provides information
+
+For each supporting character:
+
+- **Name and role**
+- **Personality and traits**
+- **Relationship to protagonist**
+- **Function in story**
+- **Key scenes/moments**
+
+Describe your supporting characters:"
+
+### 4. Character Arcs Discovery
+
+"**Now let's map character arcs.**
+
+A character arc shows how a character changes (or refuses to change) through the story.
+
+**Arc types:**
+
+- **Positive arc** - Character overcomes flaw, grows
+- **Negative arc** - Character falls, corrupts
+- **Flat arc** - Character's beliefs tested but hold
+- **Transformation** - Character becomes something new
+
+For major characters:
+
+- **Starting state** - Who are they at the beginning?
+- **Transformation moments** - What changes them?
+- **Ending state** - Who are they at the end?
+- **Lessons learned**
+
+Describe the character arcs:"
+
+### 5. Generate Characters Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Characters
+
+### Protagonist(s)
+
+#### {{protagonist_name}}
+
+**Description:** {{description}}
+
+**Background:** {{background}}
+
+**Motivation:** {{motivation}}
+
+**Strengths:** {{strengths}}
+
+**Flaws:** {{flaws}}
+
+**Conflicts:**
+
+- Internal: {{internal_conflict}}
+- External: {{external_conflict}}
+
+---
+
+### Antagonist(s)
+
+#### {{antagonist_name}}
+
+**Description:** {{description}}
+
+**Background:** {{background}}
+
+**Goals:** {{goals}}
+
+**Methods:** {{methods}}
+
+**Relationship to Protagonist:** {{relationship}}
+
+**Sympathetic Elements:** {{if_any}}
+
+---
+
+### Supporting Characters
+
+{{for_each_supporting_character}}
+
+#### {{character_name}}
+
+**Role:** {{role}}
+**Personality:** {{personality}}
+**Function:** {{story_function}}
+**Key Moments:** {{key_scenes}}
+{{/for_each}}
+
+---
+
+## Character Arcs
+
+### {{character_name}} Arc
+
+**Starting State:** {{beginning}}
+
+**Transformation Moments:**
+{{transformation_points}}
+
+**Ending State:** {{end}}
+
+**Lessons Learned:** {{lessons}}
+
+{{repeat_for_each_major_character}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented all characters and their arcs.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Character Summary:**
+
+- Protagonists: {{count}}
+- Antagonists: {{count}}
+- Supporting: {{count}}
+
+**Validation Check:**
+
+- Do characters connect to your themes?
+- Are arcs meaningful and complete?
+- Do relationships create conflict?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into characters
+[P] Party Mode - Get perspectives on character design
+[C] Continue - Save this and move to World Building (Step 5 of 11)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [characters content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Protagonists fully developed from user input
+- Antagonists with clear motivations
+- Supporting cast defined with functions
+- Character arcs mapped for major characters
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4]
+
+### SYSTEM FAILURE:
+
+- Creating characters without user input
+- Flat characters without depth
+- Missing character arcs
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-05-world.md

@@ -0,0 +1,262 @@
+---
+name: 'step-05-world'
+description: 'Build the world including setting, history, factions, and key locations'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-world.md'
+nextStepFile: '{workflow_path}/steps/step-06-dialogue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 5: World Building
+
+**Progress: Step 5 of 11** - Next: Dialogue Systems
+
+## STEP GOAL:
+
+Build the game's world including setting, history/backstory, factions/organizations, and key locations where the narrative unfolds.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- World should support and enhance the story
+- Draw out user's vision of their world
+
+### Step-Specific Rules:
+
+- FORBIDDEN to create world elements without user input
+- Connect world to themes and story
+- Focus on narrative-relevant world-building
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore world depth
+- **P (Party Mode)**: Get perspectives on world-building
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. World Overview Discovery
+
+"**Let's build the world of {{game_name}}.**
+
+Describe your world:
+
+- **Setting** - Where and when does this take place?
+- **World type** - Fantasy, sci-fi, modern, historical, etc.
+- **World rules** - Magic systems? Technology level? Physical laws?
+- **Atmosphere** - What mood does the world evoke?
+- **What makes it unique?**
+
+Describe the world:"
+
+### 2. History and Backstory Discovery
+
+"**What's the history of your world?**
+
+Consider:
+
+- **Major historical events** - Wars, discoveries, cataclysms?
+- **How did the world reach its current state?**
+- **Legends and myths** - What do people believe?
+- **Past conflicts** - What shaped the present?
+- **Secrets** - What is hidden or forgotten?
+
+Describe the history:"
+
+### 3. Factions Discovery (Optional)
+
+"**Are there factions, organizations, or groups?** (Optional)
+
+If applicable, for each faction:
+
+- **Name and purpose**
+- **Leadership and structure**
+- **Goals and methods**
+- **Relationships with other factions**
+- **Role in the story**
+
+Describe any factions:"
+
+### 4. Locations Discovery
+
+"**Describe the key locations in your world.**
+
+For each significant location:
+
+- **Name and description**
+- **Narrative significance** - Why does it matter to the story?
+- **Atmosphere and mood**
+- **Key events that occur there**
+- **Who controls/inhabits it?**
+
+What are the key locations?"
+
+### 5. Generate World Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## World Building
+
+### World Overview
+
+**Setting:** {{setting_description}}
+
+**World Type:** {{world_type}}
+
+**World Rules:**
+{{rules_and_systems}}
+
+**Atmosphere:** {{world_atmosphere}}
+
+**Unique Elements:** {{what_makes_it_unique}}
+
+---
+
+### History and Backstory
+
+**Timeline Overview:**
+{{historical_timeline}}
+
+**Major Events:**
+{{significant_events}}
+
+**Legends and Myths:**
+{{beliefs_and_legends}}
+
+**Hidden Secrets:**
+{{world_secrets}}
+
+---
+
+### Factions and Organizations
+
+{{for_each_faction}}
+
+#### {{faction_name}}
+
+**Purpose:** {{purpose}}
+**Leadership:** {{leadership}}
+**Goals:** {{goals}}
+**Methods:** {{methods}}
+**Relationships:** {{faction_relationships}}
+**Story Role:** {{narrative_function}}
+{{/for_each}}
+
+---
+
+### Key Locations
+
+{{for_each_location}}
+
+#### {{location_name}}
+
+**Description:** {{description}}
+**Narrative Significance:** {{why_important}}
+**Atmosphere:** {{mood}}
+**Key Events:** {{events_here}}
+**Inhabitants:** {{who_is_here}}
+{{/for_each}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented the world of {{game_name}}.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**World Summary:**
+
+- Setting: {{setting}}
+- Factions: {{count}}
+- Key locations: {{count}}
+
+**Validation Check:**
+
+- Does the world support your themes?
+- Are locations narratively significant?
+- Is history relevant to the present story?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore world depth
+[P] Party Mode - Get perspectives on world-building
+[C] Continue - Save this and move to Dialogue Systems (Step 6 of 11)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [world content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- World setting clearly defined
+- History connects to current story
+- Factions developed (if applicable)
+- Locations are narratively significant
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5]
+
+### SYSTEM FAILURE:
+
+- Creating world without user input
+- World disconnected from story
+- Generic locations without significance
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-06-dialogue.md

@@ -0,0 +1,250 @@
+---
+name: 'step-06-dialogue'
+description: 'Define dialogue style, key conversations, and branching systems'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-dialogue.md'
+nextStepFile: '{workflow_path}/steps/step-07-environmental.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 6: Dialogue Systems
+
+**Progress: Step 6 of 11** - Next: Environmental Storytelling
+
+## STEP GOAL:
+
+Define dialogue style, key conversations, and branching dialogue systems if applicable.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Dialogue is how characters come alive
+- Style should match tone and setting
+
+### Step-Specific Rules:
+
+- FORBIDDEN to write dialogue without user direction
+- Define style and systems, not actual dialogue
+- Consider technical implementation implications
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore dialogue depth
+- **P (Party Mode)**: Get perspectives on dialogue approach
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Dialogue Style Discovery
+
+"**Let's define how characters speak in {{game_name}}.**
+
+**Style considerations:**
+
+| Aspect        | Options                      |
+| ------------- | ---------------------------- |
+| **Formality** | Formal ←→ Casual             |
+| **Period**    | Period-appropriate ←→ Modern |
+| **Length**    | Verbose ←→ Concise           |
+| **Humor**     | Serious ←→ Comedic           |
+| **Profanity** | None ←→ Heavy                |
+
+**Questions:**
+
+- How do different characters speak differently?
+- Are there speech patterns or verbal tics?
+- What's the overall voice of the game?
+
+Describe your dialogue style:"
+
+### 2. Key Conversations Discovery
+
+"**List key conversations/dialogue moments.**
+
+For each important conversation:
+
+- **Who is involved?**
+- **When does it occur?**
+- **What's discussed?**
+- **Narrative purpose** - What does it accomplish?
+- **Emotional tone**
+
+What are the key conversations in {{game_name}}?"
+
+### 3. Branching Dialogue Discovery
+
+"**Does {{game_name}} have branching dialogue?**
+
+If yes, describe:
+
+- **How many branches/paths?**
+- **What determines branches?** (player choice, stats, flags)
+- **Do branches converge or stay separate?**
+- **How much unique dialogue?**
+- **What are the consequences of choices?**
+
+Describe your branching system (or indicate N/A):"
+
+### 4. Generate Dialogue Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Dialogue Framework
+
+### Dialogue Style
+
+**Overall Voice:** {{dialogue_voice}}
+
+**Style Elements:**
+
+- Formality: {{formality_level}}
+- Period: {{period_style}}
+- Verbosity: {{verbosity}}
+- Humor: {{humor_level}}
+- Profanity: {{profanity_level}}
+
+**Character Voice Distinctions:**
+{{how_characters_differ}}
+
+---
+
+### Key Conversations
+
+{{for_each_conversation}}
+
+#### {{conversation_name}}
+
+**Participants:** {{who}}
+**When:** {{timing}}
+**Topic:** {{what_discussed}}
+**Purpose:** {{narrative_function}}
+**Tone:** {{emotional_tone}}
+{{/for_each}}
+
+---
+
+### Branching Dialogue System
+
+{{if_branching}}
+**System Type:** {{branching_type}}
+
+**Branch Triggers:** {{what_causes_branches}}
+
+**Branch Scope:**
+
+- Total branches: {{branch_count}}
+- Convergence: {{do_they_converge}}
+- Unique content: {{percentage_unique}}
+
+**Consequence System:**
+{{how_choices_matter}}
+{{/if_branching}}
+
+{{if_not_branching}}
+**System:** Linear dialogue
+**Notes:** {{why_linear}}
+{{/if_not_branching}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented the dialogue framework.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Dialogue Summary:**
+
+- Style: {{style_summary}}
+- Key conversations: {{count}}
+- Branching: {{yes_no}}
+
+**Validation Check:**
+
+- Does style match your tone?
+- Are key conversations identified?
+- Is branching scope realistic?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore dialogue depth
+[P] Party Mode - Get perspectives on dialogue approach
+[C] Continue - Save this and move to Environmental Storytelling (Step 7 of 11)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [dialogue content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Dialogue style clearly defined
+- Key conversations identified
+- Branching system documented (if applicable)
+- Style matches game tone
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6]
+
+### SYSTEM FAILURE:
+
+- Writing actual dialogue without direction
+- Style disconnected from tone
+- Missing branching documentation
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-07-environmental.md

@@ -0,0 +1,244 @@
+---
+name: 'step-07-environmental'
+description: 'Plan environmental storytelling including visual, audio, and found documents'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-07-environmental.md'
+nextStepFile: '{workflow_path}/steps/step-08-delivery.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 7: Environmental Storytelling
+
+**Progress: Step 7 of 11** - Next: Narrative Delivery
+
+## STEP GOAL:
+
+Define how story is told through the environment: visual storytelling, audio storytelling, and found documents/collectibles.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Show, don't tell - environmental storytelling is powerful
+- Help user think beyond dialogue
+
+### Step-Specific Rules:
+
+- FORBIDDEN to design environmental narrative without user input
+- Connect environmental elements to story
+- Consider implementation effort
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore environmental depth
+- **P (Party Mode)**: Get perspectives on environmental storytelling
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Visual Storytelling Discovery
+
+"**How will you tell story through visuals in {{game_name}}?**
+
+**Visual storytelling elements:**
+
+- **Set dressing and props** - What objects tell stories?
+- **Environmental damage/aftermath** - What happened here?
+- **Visual symbolism** - Recurring images with meaning
+- **Color and lighting** - Mood and meaning through visuals
+- **Character design details** - What do appearances reveal?
+
+How will visuals tell story in {{game_name}}?"
+
+### 2. Audio Storytelling Discovery
+
+"**How will audio contribute to storytelling?**
+
+**Audio storytelling elements:**
+
+- **Ambient sounds** - What do players hear in the world?
+- **Music emotional cues** - How does music guide feeling?
+- **Voice acting** - How is it used beyond dialogue?
+- **Audio logs/recordings** - Found audio content?
+- **Sound design** - Sounds that carry meaning
+
+How will audio tell story in {{game_name}}?"
+
+### 3. Found Documents Discovery
+
+"**Will you have found documents?** (Journals, notes, emails, etc.)
+
+If yes, describe:
+
+- **Types of documents** - What forms do they take?
+- **How many** - Approximate count
+- **What they reveal** - Backstory? World-building? Character?
+- **Optional vs required** - Must players find them?
+- **Reward for finding** - Achievement? Story unlock? Lore only?
+
+Describe your found documents (or indicate N/A):"
+
+### 4. Generate Environmental Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Environmental Storytelling
+
+### Visual Storytelling
+
+**Set Dressing:**
+{{set_dressing_approach}}
+
+**Environmental Details:**
+{{environmental_storytelling_examples}}
+
+**Visual Symbolism:**
+{{symbolic_elements}}
+
+**Color and Lighting:**
+{{color_lighting_approach}}
+
+---
+
+### Audio Storytelling
+
+**Ambient Design:**
+{{ambient_sound_approach}}
+
+**Music Integration:**
+{{music_storytelling}}
+
+**Voice Elements:**
+{{voice_beyond_dialogue}}
+
+**Sound Design Narrative:**
+{{meaningful_sounds}}
+
+---
+
+### Found Documents
+
+{{if_has_documents}}
+**Document Types:**
+{{document_types}}
+
+**Quantity:** {{approximate_count}}
+
+**Content Focus:**
+{{what_documents_reveal}}
+
+**Discovery:**
+
+- Required: {{required_documents}}
+- Optional: {{optional_documents}}
+
+**Rewards:** {{finding_rewards}}
+{{/if_has_documents}}
+
+{{if_no_documents}}
+**Approach:** No found documents
+**Rationale:** {{why_no_documents}}
+{{/if_no_documents}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented the environmental storytelling approach.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Environmental Summary:**
+
+- Visual elements: Defined
+- Audio elements: Defined
+- Found documents: {{yes_no}}
+
+**Validation Check:**
+
+- Does visual storytelling match your world?
+- Is audio approach realistic for scope?
+- Are found documents well-integrated?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore environmental depth
+[P] Party Mode - Get perspectives on environmental storytelling
+[C] Continue - Save this and move to Narrative Delivery (Step 8 of 11)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [environmental content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Visual storytelling approach defined
+- Audio storytelling integrated
+- Found documents documented (if applicable)
+- Elements connect to story themes
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7]
+
+### SYSTEM FAILURE:
+
+- Creating environmental details without user input
+- Elements disconnected from story
+- Missing audio considerations
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-08-delivery.md

@@ -0,0 +1,264 @@
+---
+name: 'step-08-delivery'
+description: 'Design narrative delivery methods including cutscenes, in-game storytelling, and endings'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-08-delivery.md'
+nextStepFile: '{workflow_path}/steps/step-09-integration.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 8: Narrative Delivery
+
+**Progress: Step 8 of 11** - Next: Gameplay Integration
+
+## STEP GOAL:
+
+Define how narrative content is delivered to players: cutscenes, in-game storytelling, optional content, and ending structures.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Delivery method affects player experience
+- Balance story delivery with gameplay
+
+### Step-Specific Rules:
+
+- FORBIDDEN to decide delivery without user input
+- Consider production effort for each method
+- Match delivery to game type
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore delivery methods
+- **P (Party Mode)**: Get perspectives on delivery approach
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Cutscenes Discovery
+
+"**How will you use cutscenes in {{game_name}}?**
+
+**Cutscene considerations:**
+
+- **Quantity** - How many major cutscenes?
+- **Length** - Average duration?
+- **Style** - Real-time rendered? Pre-rendered? Animated?
+- **Skippable** - Can players skip?
+- **Interactive** - Any QTEs or choices during cutscenes?
+
+Describe your cutscene approach:"
+
+### 2. In-Game Storytelling Discovery
+
+"**How will story be delivered during gameplay?**
+
+**In-game storytelling methods:**
+
+- **NPC conversations** - Talking to characters
+- **Radio/comm chatter** - Voice in player's ear
+- **Environmental cues** - Reading the world
+- **Player actions** - Story through doing
+- **UI elements** - Quest logs, journals, etc.
+
+**Balance considerations:**
+
+- Show vs. tell - How much is shown vs. explained?
+- Interruption tolerance - How often stop for story?
+- Player control - Can players skip/speed up?
+
+How will you deliver story during gameplay?"
+
+### 3. Optional Content Discovery
+
+"**What narrative content is optional?**
+
+**Optional content types:**
+
+- **Side quests** - Optional story missions
+- **Collectible lore** - World-building items
+- **Optional conversations** - Extra NPC dialogue
+- **Secret endings** - Hidden conclusions
+- **Extended content** - Post-game, NG+, DLC hooks
+
+What optional narrative content will {{game_name}} have?"
+
+### 4. Endings Discovery
+
+"**If your game has multiple endings, describe them.**
+
+**Ending considerations:**
+
+- **How many endings?**
+- **What determines the ending?** (choices, stats, completion)
+- **Ending variety** - Minor variations vs. drastically different
+- **True/golden ending** - Is there a "best" ending?
+- **Replayability** - Can players see all endings?
+
+Describe your ending structure (or indicate single ending):"
+
+### 5. Generate Delivery Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Narrative Delivery
+
+### Cutscenes
+
+**Quantity:** {{cutscene_count}}
+**Average Length:** {{typical_duration}}
+**Style:** {{cutscene_style}}
+**Skippable:** {{yes_no}}
+**Interactive Elements:** {{if_any}}
+
+**Major Cutscenes:**
+{{list_of_major_cutscenes}}
+
+---
+
+### In-Game Storytelling
+
+**Primary Methods:**
+{{delivery_methods_list}}
+
+**Show vs. Tell Balance:** {{balance_description}}
+
+**Interruption Approach:** {{how_often_story_stops_gameplay}}
+
+**Player Control:** {{skip_speedup_options}}
+
+---
+
+### Optional Content
+
+{{for_each_optional_type}}
+**{{content_type}}:**
+{{description_and_scope}}
+{{/for_each}}
+
+---
+
+### Ending Structure
+
+{{if_multiple_endings}}
+**Number of Endings:** {{ending_count}}
+
+**Ending Triggers:** {{what_determines_ending}}
+
+**Ending Variety:**
+{{description_of_differences}}
+
+**True Ending:** {{if_exists}}
+
+**Replayability:** {{how_to_see_all}}
+{{/if_multiple_endings}}
+
+{{if_single_ending}}
+**Ending Type:** Single ending
+**Description:** {{ending_approach}}
+{{/if_single_ending}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented the narrative delivery approach.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Delivery Summary:**
+
+- Cutscenes: {{count_or_none}}
+- In-game methods: {{methods_list}}
+- Optional content: {{types}}
+- Endings: {{single_or_multiple}}
+
+**Validation Check:**
+
+- Is delivery method realistic for scope?
+- Does it match your narrative complexity?
+- Are endings meaningful?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore delivery methods
+[P] Party Mode - Get perspectives on delivery approach
+[C] Continue - Save this and move to Gameplay Integration (Step 9 of 11)"
+
+### 7. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [delivery content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Cutscene approach defined
+- In-game delivery methods established
+- Optional content scoped
+- Ending structure documented
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
+
+### SYSTEM FAILURE:
+
+- Deciding delivery without user input
+- Methods unrealistic for scope
+- Missing ending documentation
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-09-integration.md

@@ -0,0 +1,254 @@
+---
+name: 'step-09-integration'
+description: 'Define how narrative integrates with gameplay including gating, agency, and ludonarrative harmony'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-09-integration.md'
+nextStepFile: '{workflow_path}/steps/step-10-production.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 9: Gameplay Integration
+
+**Progress: Step 9 of 11** - Next: Production Planning
+
+## STEP GOAL:
+
+Define how narrative integrates with gameplay: story-gameplay connection, progression gating, and player agency within the narrative.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Ludonarrative harmony matters
+- Story and gameplay should reinforce each other
+
+### Step-Specific Rules:
+
+- FORBIDDEN to design integration without user input
+- Consider player experience flow
+- Address potential ludonarrative dissonance
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore integration depth
+- **P (Party Mode)**: Get perspectives on integration
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Narrative-Gameplay Connection Discovery
+
+"**How does narrative integrate with gameplay in {{game_name}}?**
+
+**Integration questions:**
+
+- Does story unlock new mechanics or abilities?
+- Do mechanics reflect the themes?
+- Is there harmony between what player DOES and what story SAYS?
+- What's the balance of story vs. gameplay sections?
+
+**Ludonarrative consideration:**
+Games work best when mechanics and narrative tell the same story. A game about pacifism shouldn't require combat.
+
+Describe how narrative and gameplay connect:"
+
+### 2. Story Gating Discovery
+
+"**How does story gate progression?**
+
+**Gating types:**
+
+- **Hard gates** - Must complete story to proceed
+- **Soft gates** - Story available but optional
+- **Skill gates** - Narrative rewards for mastery
+- **Exploration gates** - Story found through exploring
+
+**Questions:**
+
+- What areas are story-locked?
+- What triggers cutscenes?
+- What story beats are mandatory?
+- What's optional vs. required?
+
+How does story gate progress in {{game_name}}?"
+
+### 3. Player Agency Discovery
+
+"**How much narrative agency does the player have?**
+
+**Agency spectrum:**
+
+- **Full agency** - Player creates their own story
+- **Meaningful choices** - Player shapes outcomes
+- **Flavor choices** - Player affects tone, not outcome
+- **Witness** - Player observes a fixed story
+
+**Questions:**
+
+- Can player affect the story?
+- Are choices meaningful or cosmetic?
+- How much role-playing freedom?
+- Is the narrative predetermined or dynamic?
+
+Describe player agency in {{game_name}}:"
+
+### 4. Generate Integration Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Gameplay Integration
+
+### Narrative-Gameplay Connection
+
+**Integration Approach:**
+{{integration_description}}
+
+**Mechanic-Theme Alignment:**
+{{how_mechanics_reflect_themes}}
+
+**Story-Gameplay Balance:**
+{{balance_description}}
+
+**Ludonarrative Considerations:**
+{{harmony_or_dissonance_notes}}
+
+---
+
+### Story Gating
+
+**Gating Approach:** {{gating_type}}
+
+**Story-Locked Elements:**
+{{what_requires_story_progress}}
+
+**Cutscene Triggers:**
+{{when_cutscenes_play}}
+
+**Mandatory Story Beats:**
+{{required_narrative_content}}
+
+**Optional Narrative:**
+{{skippable_content}}
+
+---
+
+### Player Agency
+
+**Agency Level:** {{agency_type}}
+
+**Player Influence:**
+{{what_player_can_affect}}
+
+**Choice System:**
+{{if_has_choices}}
+
+- Choice types: {{choice_types}}
+- Consequence scope: {{how_choices_matter}}
+- Timing: {{when_choices_occur}}
+  {{/if_has_choices}}
+
+**Role-Playing Freedom:**
+{{roleplay_options}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented the gameplay-narrative integration.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Integration Summary:**
+
+- Connection: {{integration_type}}
+- Gating: {{gating_approach}}
+- Agency: {{agency_level}}
+
+**Validation Check:**
+
+- Do mechanics support themes?
+- Is gating appropriate for your game?
+- Is agency level what you want?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore integration depth
+[P] Party Mode - Get perspectives on integration
+[C] Continue - Save this and move to Production Planning (Step 10 of 11)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [integration content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Narrative-gameplay connection defined
+- Gating structure documented
+- Player agency level established
+- Ludonarrative harmony considered
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+### SYSTEM FAILURE:
+
+- Designing integration without user input
+- Ignoring ludonarrative harmony
+- Missing agency documentation
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-10-production.md

@@ -0,0 +1,262 @@
+---
+name: 'step-10-production'
+description: 'Plan production scope including writing estimates, localization, and voice acting'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-10-production.md'
+nextStepFile: '{workflow_path}/steps/step-11-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 10: Production Planning
+
+**Progress: Step 10 of 11** - Next: Complete
+
+## STEP GOAL:
+
+Plan the production scope for narrative content: writing scope estimates, localization considerations, and voice acting plans.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- Production planning ensures realistic scope
+- Help user understand what they're committing to
+
+### Step-Specific Rules:
+
+- FORBIDDEN to estimate scope without user input
+- Help user think through production needs
+- Be realistic about effort required
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore production details
+- **P (Party Mode)**: Get perspectives on scope
+- **C (Continue)**: Save the content and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Writing Scope Discovery
+
+"**Let's estimate the writing scope for {{game_name}}.**
+
+**Scope elements:**
+
+- **Word count estimate** - Total written content
+- **Scene/chapter count** - Major narrative sections
+- **Dialogue lines** - Approximate line count
+- **Branching complexity** - How much unique content per path?
+
+**For reference:**
+
+- Light narrative game: ~5,000-15,000 words
+- Moderate narrative: ~15,000-50,000 words
+- Heavy narrative: ~50,000-150,000 words
+- Story-driven/Visual novel: 100,000+ words
+
+Estimate your writing scope:"
+
+### 2. Localization Discovery
+
+"**Are you planning localization?**
+
+**Localization considerations:**
+
+- **Target languages** - Which languages?
+- **Cultural adaptation** - What needs to change per region?
+- **Text expansion** - Some languages use 30% more space
+- **UI implications** - Can UI handle longer text?
+- **Audio implications** - Will you dub or subtitle?
+
+Describe your localization plans (or indicate English-only):"
+
+### 3. Voice Acting Discovery
+
+"**What are your voice acting plans?**
+
+**Voice acting scope:**
+
+- **Fully voiced** - All dialogue recorded
+- **Partially voiced** - Key scenes only
+- **Grunts/barks only** - No full dialogue
+- **Text only** - No voice acting
+
+**If voiced:**
+
+- Number of characters needing voices?
+- Approximate dialogue volume?
+- Professional or placeholder voices?
+
+Describe your voice acting approach:"
+
+### 4. Generate Production Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Production Planning
+
+### Writing Scope
+
+**Estimated Word Count:** {{word_count}}
+
+**Content Breakdown:**
+
+- Main story: {{main_story_words}}
+- Side content: {{side_content_words}}
+- Environmental/lore: {{lore_words}}
+- UI/system text: {{ui_words}}
+
+**Scene Count:** {{scene_count}}
+
+**Dialogue Lines:** {{line_count}}
+
+**Branching Complexity:**
+{{branching_impact_on_scope}}
+
+---
+
+### Localization
+
+{{if_localizing}}
+**Target Languages:**
+{{language_list}}
+
+**Cultural Adaptation Notes:**
+{{adaptation_needs}}
+
+**Technical Considerations:**
+
+- Text expansion buffer: {{percentage}}
+- UI flexibility: {{notes}}
+- Audio approach: {{dub_or_subtitle}}
+  {{/if_localizing}}
+
+{{if_english_only}}
+**Approach:** English only
+**Future consideration:** {{maybe_later_notes}}
+{{/if_english_only}}
+
+---
+
+### Voice Acting
+
+**Approach:** {{voice_acting_level}}
+
+{{if_voiced}}
+**Characters Needing Voices:** {{character_count}}
+
+**Dialogue Volume:** {{line_count_for_recording}}
+
+**Voice Cast Notes:**
+{{casting_considerations}}
+
+**Recording Approach:**
+{{professional_or_placeholder}}
+{{/if_voiced}}
+
+{{if_not_voiced}}
+**Rationale:** {{why_no_voice}}
+{{/if_not_voiced}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented the production planning.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Production Summary:**
+
+- Writing: ~{{word_count}} words
+- Localization: {{languages_or_none}}
+- Voice acting: {{level}}
+
+**Validation Check:**
+
+- Is scope realistic for your resources?
+- Have you considered all production needs?
+- Are localization needs addressed?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore production details
+[P] Party Mode - Get perspectives on scope
+[C] Continue - Save this and move to Completion (Step 11 of 11)"
+
+### 6. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [production content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Writing scope estimated
+- Localization needs addressed
+- Voice acting approach defined
+- Realistic production expectations set
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+### SYSTEM FAILURE:
+
+- Estimating scope without user input
+- Missing major production considerations
+- Unrealistic expectations set
+- Not presenting A/P/C menu after content
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/2-design/narrative/steps/step-11-complete.md

@@ -0,0 +1,331 @@
+---
+name: 'step-11-complete'
+description: 'Complete the narrative workflow with final summary, visualizations, and handoff'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/narrative'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-11-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/narrative-design.md'
+
+# Handoff References
+architectureWorkflow: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.yaml'
+---
+
+# Step 11: Complete
+
+**Progress: Step 11 of 11** - Narrative Design Complete!
+
+## STEP GOAL:
+
+Generate final visualizations (character relationships, timeline), capture references, update workflow status, and provide clear handoff guidance.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a narrative design facilitator
+- This is the final step - ensure completeness
+- Provide actionable next steps
+
+### Step-Specific Rules:
+
+- Generate relationship map from characters defined
+- Generate timeline from story beats
+- Capture any references user wants to note
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Generate final visualizations
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]`
+- Present completion summary and next steps
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Generate Character Relationship Map
+
+**Create text-based relationship visualization:**
+
+Based on all characters documented, generate:
+
+```markdown
+## Appendix: Character Relationships
+
+### Relationship Map
+```
+
+                    [ANTAGONIST]
+                         |
+                    (opposes)
+                         |
+    [MENTOR] ---(guides)--- [PROTAGONIST] ---(allies)--- [COMPANION]
+                         |
+                    (romantic)
+                         |
+                  [LOVE INTEREST]
+
+```
+
+### Relationship Key
+
+- {{character_1}} → {{character_2}}: {{relationship_type}}
+- {{character_2}} → {{character_3}}: {{relationship_type}}
+{{continue_for_all_relationships}}
+```
+
+### 2. Generate Story Timeline
+
+**Create timeline visualization:**
+
+Based on story beats documented, generate:
+
+```markdown
+## Appendix: Story Timeline
+
+### Chronological Events
+```
+
+[BACKSTORY]
+|
+v
+[ACT 1: SETUP]
+├── {{beat_1}}
+├── {{beat_2}}
+└── {{inciting_incident}}
+|
+v
+[ACT 2: CONFRONTATION]
+├── {{beat_3}}
+├── {{midpoint}}
+├── {{beat_4}}
+└── {{crisis}}
+|
+v
+[ACT 3: RESOLUTION]
+├── {{climax}}
+└── {{resolution}}
+
+```
+
+### Timeline Notes
+
+{{any_timeline_clarifications}}
+```
+
+### 3. References Discovery
+
+"**Do you have any references or inspirations to note?**
+
+This helps future writers understand your vision:
+
+- Books, movies, games that inspired you
+- Reference materials for tone/style
+- Mood boards or concept art references
+- Theme or narrative references
+
+What references should be documented? (or 'none'):"
+
+### 4. Finalize Document
+
+**Update the document with final content:**
+
+Add relationship map and timeline to document.
+
+**Final frontmatter:**
+
+```yaml
+---
+title: 'Narrative Design Document'
+project: '{{game_name}}'
+date: '{{date}}'
+author: '{{user_name}}'
+version: '1.0'
+stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+status: 'complete'
+narrativeComplexity: '{{complexity}}'
+---
+```
+
+### 5. Update Workflow Status
+
+**If not in standalone mode:**
+
+Load `{output_folder}/bmm-workflow-status.yaml` and:
+
+- Update `narrative` status to the output file path
+- Preserve all comments and structure
+- Determine next workflow in sequence
+
+### 6. Present Completion Summary
+
+"**Narrative Design Complete!**
+
+{{user_name}}, the Narrative Design Document for **{{game_name}}** is complete!
+
+**Narrative Summary:**
+
+- **Premise:** {{premise_summary}}
+- **Themes:** {{themes_list}}
+- **Characters:** {{character_count}} ({{protagonist_count}} protagonist, {{antagonist_count}} antagonist, {{supporting_count}} supporting)
+- **Story Structure:** {{structure_type}}
+- **Writing Scope:** ~{{word_count}} words
+
+**Sections Completed:**
+
+1. Story Foundation (premise, themes, structure)
+2. Story Beats (major moments, pacing)
+3. Characters (all characters and arcs)
+4. World Building (setting, history, locations)
+5. Dialogue Framework (style, key conversations)
+6. Environmental Storytelling (visual, audio, documents)
+7. Narrative Delivery (cutscenes, in-game, endings)
+8. Gameplay Integration (gating, agency)
+9. Production Planning (scope, localization, voice)
+10. Appendices (relationships, timeline)
+
+**Document saved to:** `{outputFile}`
+
+Do you want to review or adjust anything before we finalize?"
+
+### 7. Handle Review Requests
+
+**If user wants to review:**
+
+"Which would you like to review?
+
+1. Story Foundation
+2. Story Beats
+3. Characters
+4. World Building
+5. Dialogue
+6. Environmental Storytelling
+7. Narrative Delivery
+8. Gameplay Integration
+9. Production Planning
+10. Full Document
+
+Select a section:"
+
+### 8. Present Next Steps Menu
+
+"**Recommended Next Steps:**
+
+1. **Technical Architecture** - Define how narrative systems will be implemented
+   - Workflow: `create-architecture`
+   - Input: GDD + Narrative Design
+   - Output: Technical architecture document
+
+2. **Create Script/Screenplay** - Write the actual dialogue and scenes
+   - This is done outside the workflow
+   - Use the Narrative Design as your blueprint
+
+3. **Review with Team** - Share with collaborators for feedback
+
+4. **Exit Workflow**
+
+**Which would you like to do next?**
+
+1. Start Architecture workflow
+2. Review the narrative document
+3. Exit workflow"
+
+### 9. Handle User Selection
+
+Based on user choice:
+
+**If 1 (Architecture):**
+
+- Confirm document is saved
+- Provide handoff guidance
+- Note narrative will inform technical decisions
+
+**If 2 (Review):**
+
+- Present full document or requested section
+- Return to next steps menu
+
+**If 3 (Exit):**
+
+- Confirm document is saved and complete
+- Exit workflow gracefully
+
+### 10. Final Completion Message
+
+"**Narrative Design Complete!**
+
+**Deliverables:**
+
+- Narrative design saved to: `{outputFile}`
+- {{character_count}} characters documented
+- {{beat_count}} story beats mapped
+- {{location_count}} locations defined
+
+{{#if standalone_mode != true}}
+**Status Updated:**
+
+- Progress tracking updated: narrative marked complete
+- Next recommended: Architecture workflow
+  {{/if}}
+
+**Your Narrative Is Ready For:**
+
+- Script/screenplay writing
+- Technical implementation planning
+- Team review and iteration
+- Production scheduling
+
+Excellent work crafting the narrative for {{game_name}}, {{user_name}}!"
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Relationship map generated
+- Timeline generated
+- References captured
+- All content saved to document
+- Workflow status updated (if tracking)
+- Frontmatter shows all 11 steps completed
+- User has clear next steps
+
+### SYSTEM FAILURE:
+
+- Missing visualizations
+- Incomplete document
+- Status not updated when tracking
+- No clear next steps provided
+- User left without guidance
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+---
+
+## Narrative Design Workflow Complete
+
+The Narrative Design workflow creates comprehensive narrative documentation through 11 collaborative steps:
+
+1. **Initialize** - Validate readiness, assess complexity
+2. **Foundation** - Premise, themes, tone, structure
+3. **Story** - Beats and pacing
+4. **Characters** - All characters and arcs
+5. **World** - Setting, history, factions, locations
+6. **Dialogue** - Style and systems
+7. **Environmental** - Environmental storytelling
+8. **Delivery** - Narrative delivery methods
+9. **Integration** - Gameplay-narrative connection
+10. **Production** - Scope and planning
+11. **Complete** - Visualizations and handoff
+
+This step-file architecture ensures consistent, thorough narrative design with user collaboration at every step.

src/modules/bmgd/workflows/2-design/narrative/workflow.md

@@ -0,0 +1,57 @@
+# Narrative Design Workflow
+
+**Comprehensive narrative design for story-driven games**
+
+## Overview
+
+This workflow creates detailed narrative content for games with significant story elements. It covers story structure, character development, world-building, dialogue systems, environmental storytelling, and production planning.
+
+## Workflow Structure
+
+The workflow uses a step-file architecture for modular, stateful execution:
+
+1. **Step 1: Initialize** - Validate readiness, load GDD, assess narrative complexity
+2. **Step 1b: Continue** - Resume existing narrative work
+3. **Step 2: Foundation** - Define premise, themes, tone, and story structure
+4. **Step 3: Story** - Map story beats and pacing
+5. **Step 4: Characters** - Develop all characters and their arcs
+6. **Step 5: World** - Build world, history, factions, and locations
+7. **Step 6: Dialogue** - Define dialogue style and systems
+8. **Step 7: Environmental** - Plan environmental storytelling
+9. **Step 8: Delivery** - Design narrative delivery methods
+10. **Step 9: Integration** - Plan gameplay-narrative integration
+11. **Step 10: Production** - Scope, localization, and voice acting
+12. **Step 11: Complete** - Final summary and handoff
+
+## State Tracking
+
+Progress is tracked in the narrative document frontmatter:
+
+```yaml
+stepsCompleted: [1, 2, 3, ...] # Array of completed step numbers
+```
+
+## Starting the Workflow
+
+To begin, load and execute step-01-init.md:
+
+```
+{workflow_path}/steps/step-01-init.md
+```
+
+## Critical Rules
+
+- **NEVER** generate narrative content without user input
+- **ALWAYS** facilitate user creativity - help them craft THEIR story
+- **NEVER** mention time estimates
+- **ALWAYS** present options and wait for user selection
+- **FOLLOW** the step sequence exactly - no skipping or optimizing
+
+## Agent Role
+
+You are a narrative design facilitator:
+
+- Draw out the user's story vision
+- Help weave user's ideas into cohesive narrative
+- Focus on what the user wants to create
+- The goal is for users to feel THEY crafted the narrative

src/modules/bmgd/workflows/2-design/narrative/workflow.yaml

@@ -1,6 +1,6 @@
 # Narrative Design Workflow
 name: narrative
-description: "Narrative design workflow for story-driven games and applications. Creates comprehensive narrative documentation including story structure, character arcs, dialogue systems, and narrative implementation guidance."
+description: "Narrative design workflow for story-driven games. Creates comprehensive narrative documentation including story structure, character arcs, world-building, dialogue systems, and production planning."
 author: "BMad"
 
 # Critical variables from config
@@ -12,21 +12,66 @@ document_output_language: "{config_source}:document_output_language"
 game_dev_experience: "{config_source}:game_dev_experience"
 date: system-generated
 
-# Workflow components
+# Workflow components - Step-file architecture
 installed_path: "{project-root}/_bmad/bmgd/workflows/2-design/narrative"
-instructions: "{installed_path}/instructions-narrative.md"
-template: "{installed_path}/narrative-template.md"
+instructions: "{installed_path}/workflow.md"
+template: "{installed_path}/templates/narrative-template.md"
+validation: "{installed_path}/checklist.md"
+
+# Smart input file references
+input_file_patterns:
+  gdd:
+    description: "Game Design Document with mechanics and systems"
+    whole: "{output_folder}/*gdd*.md"
+    sharded: "{output_folder}/*gdd*/index.md"
+    load_strategy: "INDEX_GUIDED"
+
+  brief:
+    description: "Game Brief with vision (optional)"
+    whole: "{output_folder}/*brief*.md"
+    sharded: "{output_folder}/*brief*/index.md"
+    load_strategy: "INDEX_GUIDED"
 
 # Output configuration
 default_output_file: "{output_folder}/narrative-design.md"
 
+# Workflow metadata
+version: "2.0.0"
+paradigm: "step-file-architecture"
+features:
+  - "Step-file architecture for modular execution"
+  - "Narrative complexity assessment"
+  - "Character development facilitation"
+  - "World-building guidance"
+  - "Dialogue system design"
+  - "Environmental storytelling planning"
+  - "Production scope estimation"
+  - "State tracking via frontmatter"
+
 standalone: true
 
 web_bundle:
   name: "narrative"
-  description: "Narrative design workflow for story-driven games and applications. Creates comprehensive narrative documentation including story structure, character arcs, dialogue systems, and narrative implementation guidance."
+  description: "Narrative design workflow for story-driven games"
   author: "BMad"
-  instructions: "_bmad/bmgd/workflows/2-design/narrative/instructions-narrative.md"
+  instructions: "_bmad/bmgd/workflows/2-design/narrative/workflow.md"
   web_bundle_files:
-    - "_bmad/bmgd/workflows/2-design/narrative/instructions-narrative.md"
-    - "_bmad/bmgd/workflows/2-design/narrative/narrative-template.md"
+    # Main workflow file
+    - "_bmad/bmgd/workflows/2-design/narrative/workflow.md"
+    # Step files
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-01-init.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-01b-continue.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-02-foundation.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-03-story.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-04-characters.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-05-world.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-06-dialogue.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-07-environmental.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-08-delivery.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-09-integration.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-10-production.md"
+    - "_bmad/bmgd/workflows/2-design/narrative/steps/step-11-complete.md"
+    # Template
+    - "_bmad/bmgd/workflows/2-design/narrative/templates/narrative-template.md"
+    # Validation checklist
+    - "_bmad/bmgd/workflows/2-design/narrative/checklist.md"

src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-01-init.md

@@ -0,0 +1,223 @@
+---
+name: 'step-01-init'
+description: 'Initialize the architecture workflow, validate readiness, and discover input documents'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-init.md'
+continueStepFile: '{workflow_path}/steps/step-01b-continue.md'
+nextStepFile: '{workflow_path}/steps/step-02-context.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+templateFile: '{workflow_path}/templates/architecture-template.md'
+
+# Knowledge Bases
+decisionCatalog: '{workflow_path}/decision-catalog.yaml'
+architecturePatterns: '{workflow_path}/architecture-patterns.yaml'
+patternCategories: '{workflow_path}/pattern-categories.csv'
+---
+
+# Step 1: Initialize Architecture Workflow
+
+**Progress: Step 1 of 9** - Next: Project Context
+
+## STEP GOAL:
+
+Validate workflow readiness, check for existing architecture work, discover input documents (GDD, Epics), and initialize the output document with proper frontmatter.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Focus on architectural decisions that prevent AI agent conflicts
+- This is a decision-focused workflow, not an implementation spec
+
+### Step-Specific Rules:
+
+- Check for existing architecture before starting fresh
+- Validate that required input documents exist (GDD at minimum)
+- Initialize document with proper frontmatter for state tracking
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Wait for user confirmation at each checkpoint
+- Update frontmatter `stepsCompleted: [1]` before loading next step
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Check for Existing Architecture
+
+**Search for existing architecture document:**
+
+Look for existing architecture files in {output_folder}:
+
+- `*architecture*.md`
+- `*arch*.md`
+
+**If existing architecture found:**
+
+"I found an existing architecture document: `{{existing_file}}`
+
+**Options:**
+
+1. **Continue** - Resume from where you left off
+2. **Start Fresh** - Begin a new architecture (will overwrite)
+3. **Review** - Let me review the existing document first
+
+Which would you like to do?"
+
+**Handle user selection:**
+
+- If **Continue**: Load `{continueStepFile}`
+- If **Start Fresh**: Continue with step 2 below
+- If **Review**: Show document summary and return to options
+
+### 2. Discover Required Input Documents
+
+**Search for GDD:**
+
+Look for GDD files using patterns:
+
+- `{output_folder}/*gdd*.md`
+- `{output_folder}/*game-design*.md`
+
+**If GDD not found:**
+
+"**GDD Not Found**
+
+The Architecture workflow works from your Game Design Document (GDD).
+
+The GDD provides:
+
+- Core mechanics and systems to architect
+- Technical requirements and constraints
+- Platform targets and performance needs
+
+Please run the GDD workflow first: `create-gdd`"
+
+**Exit workflow - GDD required**
+
+**If GDD found:**
+
+"**Input Document Found:**
+
+- GDD: `{{gdd_file}}`
+
+I'll analyze this to understand your game's technical requirements."
+
+### 3. Discover Optional Input Documents
+
+**Search for additional documents:**
+
+- **Epics**: `{output_folder}/*epic*.md`
+- **Game Brief**: `{output_folder}/*brief*.md`
+- **Narrative**: `{output_folder}/*narrative*.md`
+
+**Report findings:**
+
+"**Additional Documents Found:**
+{{list_of_found_documents}}
+
+These will provide additional context for architectural decisions."
+
+### 4. Confirm Workflow Start
+
+**Present start confirmation:**
+
+"**Ready to Start Architecture Workflow**
+
+{{user_name}}, I'm ready to help you create the game architecture for your project.
+
+**What we'll cover:**
+
+1. Engine/framework selection and validation
+2. Core architectural decisions (rendering, physics, networking, etc.)
+3. Project structure and code organization
+4. Implementation patterns for AI agent consistency
+5. Cross-cutting concerns (error handling, logging, etc.)
+
+**Input documents:**
+
+- GDD: `{{gdd_file}}`
+  {{additional_documents_list}}
+
+**The goal:** Create an architecture document that ensures all AI agents implement your game consistently.
+
+Ready to begin? [Y/N]"
+
+### 5. Initialize Output Document
+
+**If user confirms, create the initial document:**
+
+Create `{outputFile}` with frontmatter:
+
+```markdown
+---
+title: 'Game Architecture'
+project: '{{project_name}}'
+date: '{{date}}'
+author: '{{user_name}}'
+version: '1.0'
+stepsCompleted: [1]
+status: 'in-progress'
+
+# Source Documents
+gdd: '{{gdd_file}}'
+epics: '{{epics_file_or_null}}'
+brief: '{{brief_file_or_null}}'
+---
+
+# Game Architecture
+
+## Document Status
+
+This architecture document is being created through the BMGD Architecture Workflow.
+
+**Steps Completed:** 1 of 9 (Initialize)
+
+---
+
+_Content will be added as we progress through the workflow._
+```
+
+### 6. Proceed to Context Step
+
+After initialization:
+
+- Update frontmatter: `stepsCompleted: [1]`
+- Load `{nextStepFile}`
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Existing architecture check performed
+- GDD discovered and validated
+- Optional documents discovered
+- User confirmed workflow start
+- Output document initialized with proper frontmatter
+- Frontmatter updated with stepsCompleted: [1]
+
+### SYSTEM FAILURE:
+
+- Skipping input document discovery
+- Starting without user confirmation
+- Not checking for existing architecture
+- Missing frontmatter initialization
+- Proceeding without GDD
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-01b-continue.md

@@ -0,0 +1,153 @@
+---
+name: 'step-01b-continue'
+description: 'Continue an existing architecture workflow from where it left off'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Step Files (for routing)
+step02: '{workflow_path}/steps/step-02-context.md'
+step03: '{workflow_path}/steps/step-03-starter.md'
+step04: '{workflow_path}/steps/step-04-decisions.md'
+step05: '{workflow_path}/steps/step-05-crosscutting.md'
+step06: '{workflow_path}/steps/step-06-structure.md'
+step07: '{workflow_path}/steps/step-07-patterns.md'
+step08: '{workflow_path}/steps/step-08-validation.md'
+step09: '{workflow_path}/steps/step-09-complete.md'
+---
+
+# Step 1b: Continue Existing Architecture
+
+**Resuming Architecture Workflow**
+
+## STEP GOAL:
+
+Load the existing architecture document, determine progress, and route to the appropriate next step.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Step-Specific Rules:
+
+- Parse frontmatter to determine completed steps
+- Present summary of current progress
+- Route to correct next step based on state
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Existing Architecture
+
+**Read the existing architecture document:**
+
+Load `{outputFile}` and parse the frontmatter to extract:
+
+- `stepsCompleted` array
+- `status`
+- `project` name
+- Source document references
+
+### 2. Analyze Progress
+
+**Determine workflow state:**
+
+Map completed steps to workflow progress:
+
+- Step 1: Initialize
+- Step 2: Context
+- Step 3: Starter/Engine
+- Step 4: Decisions
+- Step 5: Cross-cutting
+- Step 6: Structure
+- Step 7: Patterns
+- Step 8: Validation
+- Step 9: Complete
+
+**Calculate next step:**
+
+Find the highest completed step and determine the next step file to load.
+
+### 3. Present Continuation Summary
+
+"**Resuming Architecture Workflow**
+
+{{user_name}}, I found your existing architecture for **{{project_name}}**.
+
+**Progress:** Steps completed: {{stepsCompleted}}
+
+**Current Status:**
+
+- Last completed: {{last_step_name}}
+- Next step: {{next_step_name}} (Step {{next_step_number}} of 9)
+
+**Document sections completed:**
+{{list_of_completed_sections}}
+
+Would you like to:
+
+1. **Continue** - Resume from {{next_step_name}}
+2. **Review** - Show me what we've documented so far
+3. **Restart Step** - Redo the last completed step
+
+Select an option:"
+
+### 4. Handle User Selection
+
+**If Continue:**
+
+- Load the next step file based on `stepsCompleted`
+
+**If Review:**
+
+- Present summary of all completed sections
+- Return to continuation options
+
+**If Restart Step:**
+
+- Decrement stepsCompleted to remove last step
+- Load the step file for the step being restarted
+
+### 5. Route to Next Step
+
+Based on next step number, load the appropriate step file:
+
+| Next Step | File     |
+| --------- | -------- |
+| 2         | {step02} |
+| 3         | {step03} |
+| 4         | {step04} |
+| 5         | {step05} |
+| 6         | {step06} |
+| 7         | {step07} |
+| 8         | {step08} |
+| 9         | {step09} |
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Existing document loaded and parsed
+- Progress accurately determined
+- User presented with clear options
+- Correct step file loaded based on state
+
+### SYSTEM FAILURE:
+
+- Failing to parse frontmatter correctly
+- Loading wrong step file
+- Not presenting continuation options
+- Overwriting existing progress without confirmation
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-02-context.md

@@ -0,0 +1,262 @@
+---
+name: 'step-02-context'
+description: 'Load and understand project context from GDD and supporting documents'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-02-context.md'
+nextStepFile: '{workflow_path}/steps/step-03-starter.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 2: Project Context
+
+**Progress: Step 2 of 9** - Next: Engine/Starter Selection
+
+## STEP GOAL:
+
+Load and analyze the GDD and supporting documents to understand the game's technical requirements, systems, and constraints that will drive architectural decisions.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Extract technical implications from game design
+- Identify complexity drivers and novel requirements
+
+### Step-Specific Rules:
+
+- Load ALL referenced input documents
+- Identify systems that need architectural support
+- Flag novel concepts requiring special attention
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after context analysis
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into technical requirements
+- **P (Party Mode)**: Get multiple perspectives on complexity
+- **C (Continue)**: Confirm understanding and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load GDD Document
+
+**Load the full GDD:**
+
+Read the GDD file identified in initialization. Extract:
+
+- Game title and core concept
+- Platform targets
+- Core mechanics and systems
+- Technical requirements section
+- Performance constraints
+- Multiplayer/networking needs
+- Any technical risks identified
+
+### 2. Load Supporting Documents
+
+**Load any available supporting documents:**
+
+- **Epics**: User stories and acceptance criteria
+- **Game Brief**: Vision and scope constraints
+- **Narrative**: Story-driven technical needs
+
+### 3. Analyze Technical Requirements
+
+**Extract and categorize technical needs:**
+
+**Core Systems Identified:**
+
+| System          | Complexity          | GDD Reference |
+| --------------- | ------------------- | ------------- |
+| {{system_name}} | {{low/medium/high}} | {{section}}   |
+
+**Platform Requirements:**
+
+- Primary platform: {{platform}}
+- Secondary platforms: {{if_any}}
+- Cross-platform considerations: {{if_applicable}}
+
+**Performance Constraints:**
+
+- Frame rate target: {{fps}}
+- Resolution support: {{resolutions}}
+- Memory constraints: {{if_specified}}
+- Load time requirements: {{if_specified}}
+
+**Networking Requirements:**
+
+- Multiplayer type: {{none/local/online}}
+- Network architecture: {{p2p/client-server/hybrid}}
+- Sync requirements: {{if_applicable}}
+
+### 4. Identify Complexity Drivers
+
+**Flag areas requiring architectural attention:**
+
+"Based on my analysis, these are the complexity drivers:
+
+**High Complexity:**
+{{list_of_high_complexity_items}}
+
+**Novel Concepts:**
+{{unique_features_without_standard_patterns}}
+
+**Technical Risks:**
+{{risks_from_gdd}}"
+
+### 5. Reflect Understanding
+
+**Present analysis to user:**
+
+"{{user_name}}, I've analyzed the technical requirements for **{{game_name}}**.
+
+**Project Summary:**
+
+- {{core_concept}}
+- Platform: {{platform}}
+- {{key_distinguishing_features}}
+
+**Key Systems Requiring Architecture:**
+
+1. {{system_1}} - {{brief_description}}
+2. {{system_2}} - {{brief_description}}
+3. {{system_3}} - {{brief_description}}
+
+**Complexity Assessment:**
+
+- Overall complexity: {{low/medium/high}}
+- Novel elements: {{count}} requiring custom patterns
+- Critical decisions: {{estimated_count}}
+
+**Technical Constraints:**
+{{summary_of_constraints}}
+
+Does this match your understanding of the project?"
+
+### 6. Generate Context Section
+
+Based on the analysis, prepare the content:
+
+```markdown
+## Project Context
+
+### Game Overview
+
+**{{game_name}}** - {{core_concept}}
+
+### Technical Scope
+
+**Platform:** {{platform}}
+**Genre:** {{genre}}
+**Project Level:** {{complexity_level}}
+
+### Core Systems
+
+{{systems_table}}
+
+### Technical Requirements
+
+{{requirements_summary}}
+
+### Complexity Drivers
+
+{{complexity_analysis}}
+
+### Technical Risks
+
+{{identified_risks}}
+```
+
+### 7. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Project Context section based on my analysis.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 6]
+
+**Validation Check:**
+
+- Have I captured all core systems?
+- Are the complexity assessments accurate?
+- Any technical constraints I missed?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into technical requirements
+[P] Party Mode - Get multiple perspectives on complexity
+[C] Continue - Save this and move to Engine Selection (Step 3 of 9)"
+
+### 8. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [context content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- GDD fully loaded and analyzed
+- Supporting documents incorporated
+- Systems and complexity identified
+- Technical constraints documented
+- User confirmed understanding accuracy
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2]
+
+### SYSTEM FAILURE:
+
+- Generating analysis without reading documents
+- Missing critical systems from GDD
+- Proceeding without user confirmation
+- Not presenting A/P/C menu after analysis
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-03-starter.md

@@ -0,0 +1,290 @@
+---
+name: 'step-03-starter'
+description: 'Discover and evaluate game engine and starter template options'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-03-starter.md'
+nextStepFile: '{workflow_path}/steps/step-04-decisions.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 3: Engine & Starter Selection
+
+**Progress: Step 3 of 9** - Next: Architectural Decisions
+
+## STEP GOAL:
+
+Discover and evaluate game engine options and starter templates based on project requirements. Modern engines/starters make many architectural decisions automatically.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Modern starters/engines provide many architectural decisions out of the box
+- Verify current versions via web search - NEVER trust hardcoded versions
+
+### Step-Specific Rules:
+
+- ALWAYS search web for current versions
+- Document which decisions the engine provides
+- Help user understand engine trade-offs
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after engine selection
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore alternative engines
+- **P (Party Mode)**: Get perspectives on engine choice
+- **C (Continue)**: Confirm selection and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Identify Engine Requirements
+
+**Based on project context, determine engine needs:**
+
+"Let's determine the right engine/framework for **{{game_name}}**.
+
+**Your Requirements:**
+
+- Platform: {{platform}}
+- Genre: {{genre}}
+- Key systems: {{key_systems}}
+
+**Engine Considerations:**
+
+| Requirement         | Implications          |
+| ------------------- | --------------------- |
+| **2D vs 3D**        | {{2d_or_3d}}          |
+| **Performance**     | {{performance_needs}} |
+| **Networking**      | {{networking_needs}}  |
+| **Platform Export** | {{platform_targets}}  |
+
+What engine or framework are you considering, or would you like recommendations?"
+
+### 2. Research Engine Options
+
+**If user has an engine in mind:**
+
+Search the web to verify:
+
+- Current stable version
+- Platform support status
+- Recent updates and roadmap
+
+**If user wants recommendations:**
+
+Based on requirements, search for appropriate options:
+
+| Game Type    | Recommended Options         |
+| ------------ | --------------------------- |
+| **2D Indie** | Godot, Unity 2D, Phaser     |
+| **3D Indie** | Godot, Unity, Unreal        |
+| **Web Game** | Phaser, PixiJS, Three.js    |
+| **Mobile**   | Unity, Godot, Flutter Flame |
+| **VR/AR**    | Unity, Unreal               |
+
+Search web: "{{recommended_engine}} game engine {{current_year}} version features"
+
+### 3. Present Engine Options
+
+**Present findings to user:**
+
+"Based on your requirements, here are the engine options:
+
+**Option 1: {{engine_1}}**
+
+- Version: {{verified_version}}
+- Strengths: {{strengths}}
+- Considerations: {{considerations}}
+- Best for: {{best_use_case}}
+
+**Option 2: {{engine_2}}**
+
+- Version: {{verified_version}}
+- Strengths: {{strengths}}
+- Considerations: {{considerations}}
+- Best for: {{best_use_case}}
+
+**Option 3: {{engine_3}}**
+
+- Version: {{verified_version}}
+- Strengths: {{strengths}}
+- Considerations: {{considerations}}
+- Best for: {{best_use_case}}
+
+Which engine would you like to use for {{game_name}}?"
+
+### 4. Document Engine Selection
+
+**After user selects engine:**
+
+"**Engine Selected:** {{selected_engine}} v{{version}}
+
+**Decisions Provided by Engine:**
+
+| Category             | Decision               | Provided By |
+| -------------------- | ---------------------- | ----------- |
+| **Rendering**        | {{rendering_approach}} | Engine      |
+| **Physics**          | {{physics_system}}     | Engine      |
+| **Audio**            | {{audio_system}}       | Engine      |
+| **Input**            | {{input_system}}       | Engine      |
+| **Scene Management** | {{scene_approach}}     | Engine      |
+| **Build System**     | {{build_approach}}     | Engine      |
+
+**Remaining Decisions:**
+These architectural decisions still need to be made:
+{{list_of_remaining_decisions}}
+
+Does this look correct?"
+
+### 5. Discover Starter Templates
+
+**Search for project templates:**
+
+Search web: "{{engine}} starter template {{game_type}} {{current_year}}"
+
+**If templates found:**
+
+"I found some starter templates for {{engine}}:
+
+**{{template_1}}:**
+
+- What it provides: {{features}}
+- Setup command: `{{command}}`
+
+**{{template_2}}:**
+
+- What it provides: {{features}}
+- Setup command: `{{command}}`
+
+Would you like to use a starter template, or start from scratch?"
+
+### 6. Generate Engine Section
+
+Based on the conversation, prepare the content:
+
+````markdown
+## Engine & Framework
+
+### Selected Engine
+
+**{{engine_name}}** v{{version}}
+
+**Rationale:** {{why_selected}}
+
+### Project Initialization
+
+{{if_starter_template}}
+
+```bash
+{{initialization_command}}
+```
+````
+
+{{/if_starter_template}}
+
+### Engine-Provided Architecture
+
+| Component | Solution | Notes |
+| --------- | -------- | ----- |
+
+{{engine_provided_table}}
+
+### Remaining Architectural Decisions
+
+The following decisions must be made explicitly:
+
+{{remaining_decisions_list}}
+
+```
+
+### 7. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Engine & Framework section.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 6]
+
+**Validation Check:**
+- Is the engine version current?
+- Are the engine-provided decisions accurate?
+- Have we identified all remaining decisions?
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore alternative engines
+[P] Party Mode - Get perspectives on engine choice
+[C] Continue - Save this and move to Architectural Decisions (Step 4 of 9)"
+
+### 8. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [engine content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Engine requirements clearly identified
+- Current versions verified via web search
+- Engine-provided decisions documented
+- Remaining decisions identified
+- Starter template evaluated if applicable
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3]
+
+### SYSTEM FAILURE:
+
+- Using hardcoded versions without verification
+- Not documenting engine-provided decisions
+- Proceeding without user engine selection
+- Not presenting A/P/C menu after selection
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+```

src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-04-decisions.md

@@ -0,0 +1,300 @@
+---
+name: 'step-04-decisions'
+description: 'Facilitate collaborative architectural decision making for game systems'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-decisions.md'
+nextStepFile: '{workflow_path}/steps/step-05-crosscutting.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Knowledge Bases
+decisionCatalog: '{workflow_path}/decision-catalog.yaml'
+architecturePatterns: '{workflow_path}/architecture-patterns.yaml'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 4: Architectural Decisions
+
+**Progress: Step 4 of 9** - Next: Cross-cutting Concerns
+
+## STEP GOAL:
+
+Facilitate collaborative decision-making for all remaining architectural choices. Each decision must be made WITH the user, not FOR them.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Each decision must be made WITH the user
+- Present options, explain trade-offs, accept user choice
+
+### Step-Specific Rules:
+
+- Load decision catalog for structured guidance
+- Verify technology versions via web search
+- Document rationale for every decision
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after all decisions documented
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Challenge decisions and explore alternatives
+- **P (Party Mode)**: Get multiple perspectives on choices
+- **C (Continue)**: Confirm decisions and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Decision Framework
+
+**Load decision catalog if available:**
+
+Load `{decisionCatalog}` and `{architecturePatterns}` to guide the decision process.
+
+**Identify required decisions based on game type:**
+
+| Category               | Decisions Needed            |
+| ---------------------- | --------------------------- |
+| **State Management**   | {{if_applicable}}           |
+| **Data Persistence**   | Save system, config storage |
+| **Networking**         | {{if_multiplayer}}          |
+| **AI Systems**         | {{if_has_ai}}               |
+| **Asset Loading**      | Streaming, caching          |
+| **Scene Structure**    | Scene graph, loading        |
+| **UI Framework**       | In-game, menus              |
+| **Audio Architecture** | Channels, mixing            |
+
+### 2. Prioritize Decisions
+
+**Create decision priority list:**
+
+"Based on your project, here are the architectural decisions we need to make:
+
+**CRITICAL (blocks everything):**
+{{critical_decisions}}
+
+**IMPORTANT (shapes architecture):**
+{{important_decisions}}
+
+**NICE-TO-HAVE (can defer):**
+{{optional_decisions}}
+
+Let's work through these in priority order."
+
+### 3. Facilitate Each Decision
+
+**For each decision, follow this pattern:**
+
+"**Decision: {{decision_name}}**
+
+{{context_about_why_this_matters}}
+
+**Options:**
+
+| Option       | Pros     | Cons     |
+| ------------ | -------- | -------- |
+| {{option_1}} | {{pros}} | {{cons}} |
+| {{option_2}} | {{pros}} | {{cons}} |
+| {{option_3}} | {{pros}} | {{cons}} |
+
+**Recommendation:** {{recommendation}} because {{reason}}
+
+What's your preference? (or 'explain more' for details)"
+
+**After user decides:**
+
+Record:
+
+- Category: {{category}}
+- Decision: {{user_choice}}
+- Version: {{if_applicable}}
+- Rationale: {{user_reasoning}}
+
+### 4. Game-Specific Decision Categories
+
+**State Management:**
+
+"How should game state be managed?
+
+**Options:**
+
+- **Singleton Pattern** - Simple, global access, harder to test
+- **State Machine** - Clear transitions, good for game modes
+- **ECS (Entity Component System)** - Scalable, decoupled, learning curve
+- **Redux-style** - Predictable, time travel debugging, more boilerplate
+
+For {{game_type}}, {{recommendation}} works well because {{reason}}.
+
+Your choice?"
+
+**Save System:**
+
+"How should player progress be saved?
+
+**Options:**
+
+- **Local files** - JSON/binary, works offline
+- **Cloud saves** - Cross-device, requires backend
+- **Hybrid** - Local primary, cloud sync
+- **Platform-specific** - Steam Cloud, console saves
+
+Your choice?"
+
+**Asset Loading:**
+
+"How should assets be loaded?
+
+**Options:**
+
+- **Preload all** - Simple, longer initial load
+- **Lazy loading** - Fast startup, potential hitches
+- **Streaming** - Seamless, complex implementation
+- **Scene-based** - Load per scene, clear boundaries
+
+Your choice?"
+
+### 5. Handle Version Verification
+
+**For any technology-specific decisions:**
+
+Search web: "{{technology}} latest stable version {{current_year}}"
+
+Document:
+
+- Technology: {{name}}
+- Verified Version: {{version}}
+- Verification Date: {{today}}
+
+### 6. Generate Decisions Section
+
+After all decisions are made, prepare the content:
+
+```markdown
+## Architectural Decisions
+
+### Decision Summary
+
+| Category | Decision | Version | Rationale |
+| -------- | -------- | ------- | --------- |
+
+{{decision_table_rows}}
+
+### State Management
+
+**Approach:** {{state_management_choice}}
+
+{{state_management_details}}
+
+### Data Persistence
+
+**Save System:** {{save_system_choice}}
+
+{{save_system_details}}
+
+### Asset Management
+
+**Loading Strategy:** {{asset_loading_choice}}
+
+{{asset_loading_details}}
+
+### {{Additional_Categories}}
+
+{{additional_decision_details}}
+
+### Architecture Decision Records
+
+{{key_decisions_with_context}}
+```
+
+### 7. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented all our architectural decisions.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 6]
+
+**Decisions Made:** {{count}} decisions documented
+
+**Validation Check:**
+
+- Are all critical decisions captured?
+- Are versions current and verified?
+- Does the rationale reflect your reasoning?
+
+**Select an Option:**
+[A] Advanced Elicitation - Challenge decisions, explore alternatives
+[P] Party Mode - Get different perspectives on choices
+[C] Continue - Save this and move to Cross-cutting Concerns (Step 5 of 9)"
+
+### 8. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [decisions content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- All required decisions identified
+- User made each decision (not generated)
+- Versions verified via web search
+- Rationale documented for each decision
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4]
+
+### SYSTEM FAILURE:
+
+- Making decisions FOR the user
+- Using unverified versions
+- Missing critical decisions
+- Not documenting rationale
+- Not presenting A/P/C menu after decisions
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-05-crosscutting.md

@@ -0,0 +1,319 @@
+---
+name: 'step-05-crosscutting'
+description: 'Address cross-cutting concerns that affect all game systems'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-crosscutting.md'
+nextStepFile: '{workflow_path}/steps/step-06-structure.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 5: Cross-cutting Concerns
+
+**Progress: Step 5 of 9** - Next: Project Structure
+
+## STEP GOAL:
+
+Define patterns for concerns that affect EVERY system in the game: error handling, logging, configuration, events, and debugging. These decisions ensure consistency across all AI agent implementations.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Cross-cutting concerns affect EVERY system
+- Consistency here prevents major integration issues
+
+### Step-Specific Rules:
+
+- Focus on patterns that prevent AI agent conflicts
+- Every decision must have a concrete example
+- These become mandatory rules for all implementations
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after all concerns documented
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into specific concerns
+- **P (Party Mode)**: Get perspectives on patterns
+- **C (Continue)**: Confirm patterns and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Explain Cross-cutting Importance
+
+"Now let's define cross-cutting concerns - patterns that apply to EVERY system.
+
+**Why this matters:**
+If one AI agent handles errors differently than another, your game breaks.
+If logging formats vary, debugging becomes impossible.
+These patterns are the 'constitution' that all code must follow.
+
+Let's define each one."
+
+### 2. Error Handling Strategy
+
+"**Error Handling**
+
+How should ALL systems handle errors?
+
+**Options:**
+
+| Approach                 | Description                     | Best For            |
+| ------------------------ | ------------------------------- | ------------------- |
+| **Try-Catch Everywhere** | Explicit handling at each point | Critical systems    |
+| **Global Handler**       | Centralized error management    | Consistent recovery |
+| **Signal/Event Based**   | Emit errors as events           | Decoupled systems   |
+| **Result Objects**       | Return success/failure objects  | Functional style    |
+
+**Game-specific considerations:**
+
+- Should errors pause the game?
+- How should critical vs recoverable errors differ?
+- Should errors be visible to players?
+
+What's your error handling strategy?"
+
+### 3. Logging Approach
+
+"**Logging Strategy**
+
+How should ALL systems log information?
+
+**Log Levels:**
+
+- **ERROR**: Something broke
+- **WARN**: Something unexpected but handled
+- **INFO**: Normal operation milestones
+- **DEBUG**: Detailed diagnostic info
+- **TRACE**: Extremely verbose (development only)
+
+**Questions:**
+
+- What format? (structured JSON, plain text, engine-native)
+- Where do logs go? (console, file, external service)
+- What should always be logged vs conditional?
+- How should performance-critical paths handle logging?
+
+What's your logging approach?"
+
+### 4. Configuration Management
+
+"**Configuration Management**
+
+How will game settings be organized and accessed?
+
+**Configuration Types:**
+
+- **Game constants** - Values that never change
+- **Balancing values** - Tweakable gameplay numbers
+- **Player settings** - User preferences
+- **Platform settings** - Per-platform adjustments
+
+**Storage options:**
+
+- Hardcoded constants
+- Configuration files (JSON, YAML)
+- Engine-native systems
+- Remote configuration
+
+How should configuration be managed?"
+
+### 5. Event/Signal System
+
+"**Event System**
+
+How should systems communicate without tight coupling?
+
+**Options:**
+
+| Pattern           | Description           | Complexity |
+| ----------------- | --------------------- | ---------- |
+| **Observer**      | Direct subscription   | Simple     |
+| **Event Bus**     | Central dispatcher    | Medium     |
+| **Signal/Slot**   | Type-safe connections | Medium     |
+| **Message Queue** | Async processing      | Complex    |
+
+**Questions:**
+
+- Typed events or stringly-typed?
+- Sync or async event processing?
+- Event history/replay for debugging?
+
+What's your event system approach?"
+
+### 6. Debug/Development Tools
+
+"**Debug & Development Tools**
+
+What development tools should be built in?
+
+**Common debug features:**
+
+- Debug console/command system
+- Visual debugging overlays
+- State inspection tools
+- Performance profiling hooks
+- Cheat/testing commands
+
+**Questions:**
+
+- How are debug features enabled/disabled?
+- Should they be in release builds?
+- What's the debug key/activation method?
+
+What debug tools do you want?"
+
+### 7. Generate Cross-cutting Section
+
+Based on the conversation, prepare the content:
+
+````markdown
+## Cross-cutting Concerns
+
+These patterns apply to ALL systems and must be followed by every implementation.
+
+### Error Handling
+
+**Strategy:** {{error_strategy}}
+
+**Error Levels:**
+{{error_level_definitions}}
+
+**Example:**
+
+```{{language}}
+{{error_handling_example}}
+```
+````
+
+### Logging
+
+**Format:** {{logging_format}}
+**Destination:** {{log_destination}}
+
+**Log Levels:**
+{{log_level_usage}}
+
+**Example:**
+
+```{{language}}
+{{logging_example}}
+```
+
+### Configuration
+
+**Approach:** {{config_approach}}
+
+**Configuration Structure:**
+{{config_structure}}
+
+### Event System
+
+**Pattern:** {{event_pattern}}
+
+**Event Naming:** {{naming_convention}}
+
+**Example:**
+
+```{{language}}
+{{event_example}}
+```
+
+### Debug Tools
+
+**Available Tools:**
+{{debug_tool_list}}
+
+**Activation:** {{how_to_enable}}
+
+```
+
+### 8. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented all cross-cutting concerns.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 7]
+
+**Validation Check:**
+- Do these patterns cover all systems?
+- Are the examples clear enough for AI agents?
+- Any edge cases we missed?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into specific concerns
+[P] Party Mode - Get perspectives on patterns
+[C] Continue - Save this and move to Project Structure (Step 6 of 9)"
+
+### 9. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [cross-cutting content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Error handling strategy defined with example
+- Logging approach documented
+- Configuration management established
+- Event system pattern selected
+- Debug tools identified
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5]
+
+### SYSTEM FAILURE:
+
+- Missing any cross-cutting concern
+- No concrete examples provided
+- Patterns too vague for AI agents to follow
+- Not presenting A/P/C menu after documentation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+```

src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-06-structure.md

@@ -0,0 +1,304 @@
+---
+name: 'step-06-structure'
+description: 'Define project structure, directory organization, and architectural boundaries'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-structure.md'
+nextStepFile: '{workflow_path}/steps/step-07-patterns.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 6: Project Structure
+
+**Progress: Step 6 of 9** - Next: Implementation Patterns
+
+## STEP GOAL:
+
+Define the complete project structure including directory organization, file naming conventions, and architectural boundaries. This ensures all AI agents place code consistently.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Project structure prevents "where does this go?" confusion
+- Clear boundaries enable parallel development
+
+### Step-Specific Rules:
+
+- Structure must be complete, not generic placeholders
+- Map every major system to a location
+- Define naming conventions explicitly
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after structure defined
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Refine structure organization
+- **P (Party Mode)**: Get perspectives on layout
+- **C (Continue)**: Confirm structure and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Determine Organization Pattern
+
+"Let's define how your project will be organized.
+
+**Organization Patterns:**
+
+| Pattern           | Description                      | Best For      |
+| ----------------- | -------------------------------- | ------------- |
+| **By Feature**    | All related files together       | Feature teams |
+| **By Type**       | Scripts, assets, scenes separate | Traditional   |
+| **Hybrid**        | Types at top, features within    | Balanced      |
+| **Domain-Driven** | By game domain/system            | Complex games |
+
+**Engine Conventions:**
+
+- {{engine}} typically uses: {{engine_convention}}
+
+What organization pattern do you prefer?"
+
+### 2. Define Root Structure
+
+"Based on {{selected_pattern}}, let's define your root structure.
+
+**For {{engine}}, typical root looks like:**
+
+```
+{{project_name}}/
+├── {{source_folder}}/          # Game source code
+├── {{assets_folder}}/          # Art, audio, data
+├── {{scenes_folder}}/          # Scene/level files
+├── {{tests_folder}}/           # Test files
+├── {{docs_folder}}/            # Documentation
+└── {{config_files}}            # Project config
+```
+
+Does this work, or would you like to adjust?"
+
+### 3. Detail Source Structure
+
+"Now let's detail the source code organization.
+
+**Based on your systems:**
+{{list_of_systems_from_context}}
+
+**Proposed structure:**
+
+```
+{{source_folder}}/
+├── core/                   # Core systems (singletons, managers)
+│   ├── {{core_systems}}
+├── gameplay/               # Gameplay mechanics
+│   ├── {{gameplay_systems}}
+├── ui/                     # User interface
+│   ├── {{ui_organization}}
+├── utils/                  # Utilities and helpers
+│   ├── {{util_types}}
+└── data/                   # Data structures and models
+    └── {{data_types}}
+```
+
+What adjustments would you make?"
+
+### 4. Define Asset Structure
+
+"Let's organize your assets.
+
+**Asset Categories:**
+
+- Art (sprites, textures, models)
+- Audio (music, sfx, voice)
+- Data (configurations, levels)
+- UI (interface assets)
+
+**Proposed asset structure:**
+
+```
+{{assets_folder}}/
+├── art/
+│   ├── {{art_categories}}
+├── audio/
+│   ├── music/
+│   ├── sfx/
+│   └── {{audio_categories}}
+├── data/
+│   └── {{data_file_types}}
+└── ui/
+    └── {{ui_asset_types}}
+```
+
+How should assets be organized?"
+
+### 5. Map Systems to Locations
+
+"Let's map each major system to its location.
+
+| System | Location | Notes |
+| ------ | -------- | ----- |
+
+{{system_location_mapping}}
+
+Does this mapping make sense for your project?"
+
+### 6. Define Naming Conventions
+
+"Finally, let's establish naming conventions.
+
+**Files:**
+
+- Scripts: {{script_naming}} (e.g., PlayerController, enemy_spawner)
+- Scenes: {{scene_naming}} (e.g., Level01, main_menu)
+- Assets: {{asset_naming}} (e.g., player_idle, btn_play)
+
+**Code Elements:**
+
+- Classes: {{class_naming}} (e.g., PascalCase)
+- Functions: {{function_naming}} (e.g., snake_case, camelCase)
+- Variables: {{variable_naming}}
+- Constants: {{constant_naming}} (e.g., UPPER_SNAKE)
+
+**Game-Specific:**
+
+- Prefabs/Scenes: {{prefab_naming}}
+- Animation clips: {{animation_naming}}
+- Event names: {{event_naming}}
+
+What are your naming preferences?"
+
+### 7. Generate Structure Section
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Project Structure
+
+### Organization Pattern
+
+**Pattern:** {{organization_pattern}}
+
+**Rationale:** {{why_this_pattern}}
+
+### Directory Structure
+```
+
+{{project_name}}/
+{{complete_directory_tree}}
+
+```
+
+### System Location Mapping
+
+| System | Location | Responsibility |
+|--------|----------|----------------|
+{{system_mapping_table}}
+
+### Naming Conventions
+
+#### Files
+{{file_naming_rules}}
+
+#### Code Elements
+| Element | Convention | Example |
+|---------|------------|---------|
+{{code_naming_table}}
+
+#### Game Assets
+{{asset_naming_rules}}
+
+### Architectural Boundaries
+
+{{boundary_rules}}
+```
+
+### 8. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've defined the complete project structure.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 7]
+
+**Validation Check:**
+
+- Can every system find its home?
+- Are naming conventions clear and consistent?
+- Will AI agents know exactly where to place new code?
+
+**Select an Option:**
+[A] Advanced Elicitation - Refine structure organization
+[P] Party Mode - Get perspectives on layout
+[C] Continue - Save this and move to Implementation Patterns (Step 7 of 9)"
+
+### 9. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [structure content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Complete directory structure defined
+- Every system mapped to location
+- Naming conventions explicit and consistent
+- No placeholder or generic structures
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6]
+
+### SYSTEM FAILURE:
+
+- Generic structure with placeholders
+- Systems without clear locations
+- Vague naming conventions
+- Not presenting A/P/C menu after structure
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.