bmad-method 6.0.0-alpha.17 → 6.0.0-alpha.19

package/CHANGELOG.md

@@ -1,5 +1,122 @@
 # Changelog
 
+## [6.0.0-alpha.19]
+
+**Release: December 18, 2025**
+
+### 🐛 Bug Fixes
+
+**Installer Stability:**
+
+- **Fixed \_bmad Folder Stutter**: Resolved issue with duplicate \_bmad folder creation when applying agent custom files
+- **Cleaner Installation**: Removed unnecessary backup file that was causing bloat in the installer
+- **Streamlined Agent Customization**: Fixed path handling for agent custom files to prevent folder duplication
+
+### 📊 Statistics
+
+- **3 files changed** with critical fix
+- **3,688 lines removed** by eliminating backup files
+- **Improved installer performance** and stability
+
+---
+
+## [6.0.0-alpha.18]
+
+**Release: December 18, 2025**
+
+### 🎮 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/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.19",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",

package/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 };

package/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 };

package/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 };

package/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

package/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
 
-  menu:
-    - trigger: brainstorm-game
-      workflow: "{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game/workflow.yaml"
-      description: 1. Guide me through Game Brainstorming
-
-    - trigger: create-game-brief
-      workflow: "{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.yaml"
-      description: 3. Create Game Brief
+  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"
 
-    - 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)
+  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
+
+    - 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: 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

package/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: 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: 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-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

package/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