@bmad/bmad-game-dev-studio 0.1.4

package/.markdownlint-cli2.yaml

@@ -0,0 +1,35 @@
+# markdownlint-cli2 configuration
+# https://github.com/DavidAnson/markdownlint-cli2
+
+ignores:
+  - node_modules/**
+  - test/fixtures/**
+  - CODE_OF_CONDUCT.md
+  - _bmad/**
+  - _bmad*/**
+  - .*/**
+  - z*/**
+
+# Rule configuration
+config:
+  # Disable all rules by default
+  default: false
+
+  # Heading levels should increment by one (h1 -> h2 -> h3, not h1 -> h3)
+  MD001: true
+
+  # Duplicate sibling headings (same heading text at same level under same parent)
+  MD024:
+    siblings_only: true
+
+  # Trailing commas in headings (likely typos)
+  MD026:
+    punctuation: ","
+
+  # Bare URLs - may not render as links in all parsers
+  # Should use <url> or [text](url) format
+  MD034: true
+
+  # Spaces inside emphasis markers - breaks rendering
+  # e.g., "* text *" won't render as emphasis
+  MD037: true

package/.nvmrc

@@ -0,0 +1 @@
+22

package/.prettierignore

@@ -0,0 +1,9 @@
+# Test fixtures with intentionally broken/malformed files
+test/fixtures/**
+
+# Contributor Covenant (external standard)
+CODE_OF_CONDUCT.md
+
+# BMAD runtime folders (user-specific, not in repo)
+_bmad/
+_bmad*/

package/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2026 BMad Code, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+TRADEMARK NOTICE:
+BMad™ , BMAD-CORE™ and BMAD-METHOD™ are trademarks of BMad Code, LLC. The use of these 
+trademarks in this software does not grant any rights to use the trademarks 
+for any other purpose.

package/README.md

@@ -0,0 +1,119 @@
+# BMad Game Dev Studio
+
+[![Version](https://img.shields.io/npm/v/bmad-game-dev-studio?color=blue&label=version)](https://www.npmjs.com/package/bmad-game-dev-studio)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white)](https://discord.gg/gk8jAdXWmj)
+
+**BMGD brings BMad's structured development to game development.** Create working prototypes quickly in Unity, Unreal, Godot—or any engine you choose.
+
+![BMGD Logo](docs/bmgd-logo.png)
+
+## About BMGD
+
+BMad Game Dev Studio (BMGD) adapts the BMad Method framework for game development. Developed by game industry veterans, BMGD guides you through product research, technical design, narrative design, and a full epic-driven production cycle.
+
+## Supported Engines
+
+BMGD has first-class support for:
+
+- [Unity](https://unity.com) — C# scripting, industry-standard for many game types
+- [Unreal Engine](https://www.unrealengine.com/) — Blueprint and C++, AAA powerhouse
+- [Godot](https://godotengine.org/) — Open-source, GDScript, rapidly growing
+
+But you're not limited to these—BMGD works with any platform, from pure C to custom engines.
+
+## What You Can Create
+
+BMGD supports **21 game types**, including:
+
+| Genre | Examples |
+|-------|----------|
+| Action | Platformers, shooters, hack-and-slash |
+| RPG | Action RPG, tactical RPG, dungeon crawlers |
+| Strategy | Turn-based, RTS, tower defense |
+| Simulation | Life sim, tycoon, management |
+| Adventure | Visual novels, point-and-click, walking simulators |
+| And more... | Survival, horror, puzzle, racing, etc. |
+
+## What BMGD Does
+
+- **Product Research** — Market analysis, competitor research, positioning
+- **Game Design Document** — Comprehensive GDD with mechanics, progression, and balance
+- **Narrative Design** — Story structure, characters, dialogue, world-building
+- **Technical Architecture** — Engine patterns, performance considerations
+- **Production Planning** — Epic-driven sprints, story tracking, retrospectives
+- **Quick Prototyping** — Skip the planning, jump straight into building
+
+## What BMGD Doesn't Do
+
+BMGD works *with* coding agents like Claude Code, Cursor, or GitHub Copilot—but it can't create everything:
+
+- Art assets (models, textures, sprites)
+- Animations
+- Music and sound effects
+- Full game implementation from scratch
+
+Think of BMGD as your senior game dev colleague—not a replacement for your entire team.
+
+## Installation
+
+BMGD is installed as a module during BMad Method setup:
+
+```bash
+npx bmad-method@alpha install
+```
+
+Select **Game Dev Studio** from the modules list.
+
+## Quick Start
+
+After installing, run from your project root:
+
+```
+/bmgd-help          # Get guided help for game development
+/bmgd-quick-dev     # Jump straight into prototyping
+/bmgd-gdd           # Create a Game Design Document
+/bmgd-narrative     # Design your game's story
+```
+
+## Two Ways to Work
+
+| Approach | When to Use | Workflow |
+|----------|-------------|----------|
+| **Quick Flow** | Rapid prototyping, small projects | `/bmgd-quick-dev` |
+| **Full Production** | Full games, teams, long-term | `/bmgd-help` for guided path |
+
+## Example: Starting a New Game
+
+```
+You: /bmgd-help
+BMGD: What kind of game are you making?
+You: A tactical sci-fi RPG
+BMGD: Great choice! Here's what I recommend...
+    [Guides you through genre-specific planning]
+    [Helps select appropriate workflows]
+```
+
+## Documentation
+
+- [BMad Method Docs](http://docs.bmad-method.org)
+- [BMGD Guide](http://docs.bmad-method.org/bmgd/)
+
+## Community
+
+- [Discord](https://discord.gg/gk8jAdXWmj) — Get help from other game devs
+- [GitHub Issues](https://github.com/bmad-code-org/bmad-module-game-dev-studio/issues) — Report bugs
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.
+
+---
+
+**BMad Game Dev Studio** — Part of the [BMad Method](https://github.com/bmad-code-org/BMAD-METHOD) ecosystem.
+
+[![Contributors](https://contrib.rocks/image?repo=bmad-code-org/bmad-module-game-dev-studio)](https://github.com/bmad-code-org/bmad-module-game-dev-studio/graphs/contributors)
+
+See [CONTRIBUTORS.md](CONTRIBUTORS.md) for contributor information.
+
+*If you can dream it, you can build it.*

package/eslint.config.mjs

@@ -0,0 +1,152 @@
+import js from '@eslint/js';
+import eslintConfigPrettier from 'eslint-config-prettier/flat';
+import nodePlugin from 'eslint-plugin-n';
+import unicorn from 'eslint-plugin-unicorn';
+import yml from 'eslint-plugin-yml';
+
+export default [
+  // Global ignores for files/folders that should not be linted
+  {
+    ignores: [
+      'dist/**',
+      'coverage/**',
+      '**/*.min.js',
+      'test/template-test-generator/**',
+      'test/template-test-generator/**/*.js',
+      'test/template-test-generator/**/*.md',
+      'test/fixtures/**',
+      'test/fixtures/**/*.yaml',
+      '_bmad/**',
+      '_bmad*/**',
+      // Build output
+      'build/**',
+      // Website uses ESM/Astro - separate linting ecosystem
+      'website/**',
+      // Gitignored patterns
+      'z*/**', // z-samples, z1, z2, etc.
+      '.claude/**',
+      '.codex/**',
+      '.github/chatmodes/**',
+      '.agent/**',
+      '.agentvibes/**',
+      '.kiro/**',
+      '.roo/**',
+      'test-project-install/**',
+      'sample-project/**',
+      'tools/template-test-generator/test-scenarios/**',
+      'src/modules/*/sub-modules/**',
+      '.bundler-temp/**',
+    ],
+  },
+
+  // Base JavaScript recommended rules
+  js.configs.recommended,
+
+  // Node.js rules
+  ...nodePlugin.configs['flat/mixed-esm-and-cjs'],
+
+  // Unicorn rules (modern best practices)
+  unicorn.configs.recommended,
+
+  // YAML linting
+  ...yml.configs['flat/recommended'],
+
+  // Place Prettier last to disable conflicting stylistic rules
+  eslintConfigPrettier,
+
+  // Project-specific tweaks
+  {
+    rules: {
+      // Allow console for CLI tools in this repo
+      'no-console': 'off',
+      // Enforce .yaml file extension for consistency
+      'yml/file-extension': [
+        'error',
+        {
+          extension: 'yaml',
+          caseSensitive: true,
+        },
+      ],
+      // Prefer double quotes in YAML wherever quoting is used, but allow the other to avoid escapes
+      'yml/quotes': [
+        'error',
+        {
+          prefer: 'double',
+          avoidEscape: true,
+        },
+      ],
+      // Relax some Unicorn rules that are too opinionated for this codebase
+      'unicorn/prevent-abbreviations': 'off',
+      'unicorn/no-null': 'off',
+    },
+  },
+
+  // CLI scripts under tools/** and test/**
+  {
+    files: ['tools/**/*.js', 'tools/**/*.mjs', 'test/**/*.js'],
+    rules: {
+      // Allow CommonJS patterns for Node CLI scripts
+      'unicorn/prefer-module': 'off',
+      'unicorn/import-style': 'off',
+      'unicorn/no-process-exit': 'off',
+      'n/no-process-exit': 'off',
+      'unicorn/no-await-expression-member': 'off',
+      'unicorn/prefer-top-level-await': 'off',
+      // Avoid failing CI on incidental unused vars in internal scripts
+      'no-unused-vars': 'off',
+      // Reduce style-only churn in internal tools
+      'unicorn/prefer-ternary': 'off',
+      'unicorn/filename-case': 'off',
+      'unicorn/no-array-reduce': 'off',
+      'unicorn/no-array-callback-reference': 'off',
+      'unicorn/consistent-function-scoping': 'off',
+      'n/no-extraneous-require': 'off',
+      'n/no-extraneous-import': 'off',
+      'n/no-unpublished-require': 'off',
+      'n/no-unpublished-import': 'off',
+      // Some scripts intentionally use globals provided at runtime
+      'no-undef': 'off',
+      // Additional relaxed rules for legacy/internal scripts
+      'no-useless-catch': 'off',
+      'unicorn/prefer-number-properties': 'off',
+      'no-unreachable': 'off',
+      'unicorn/text-encoding-identifier-case': 'off',
+    },
+  },
+
+  // Module installer scripts use CommonJS for compatibility
+  {
+    files: ['**/_module-installer/**/*.js'],
+    rules: {
+      // Allow CommonJS patterns for installer scripts
+      'unicorn/prefer-module': 'off',
+      'n/no-missing-require': 'off',
+      'n/no-unpublished-require': 'off',
+    },
+  },
+
+  // ESLint config file should not be checked for publish-related Node rules
+  {
+    files: ['eslint.config.mjs'],
+    rules: {
+      'n/no-unpublished-import': 'off',
+    },
+  },
+
+  // GitHub workflow files in this repo may use empty mapping values
+  {
+    files: ['.github/workflows/**/*.yaml'],
+    rules: {
+      'yml/no-empty-mapping-value': 'off',
+    },
+  },
+
+  // Other GitHub YAML files may intentionally use empty values and reserved filenames
+  {
+    files: ['.github/**/*.yaml'],
+    rules: {
+      'yml/no-empty-mapping-value': 'off',
+      'unicorn/filename-case': 'off',
+    },
+  },
+];

package/package.json

@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@bmad/bmad-game-dev-studio",
+  "version": "0.1.4",
+  "description": "A BMad MEthod Core Module that offers a substantial stand alone module for Game Development across multiple supported platforms",
+  "keywords": [
+    "bmad",
+    "game-dev"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bmad-code-org/bmad-module-game-dev-studio.git"
+  },
+  "license": "MIT",
+  "author": "Brian (BMad) Madison",
+  "main": "",
+  "scripts": {
+    "format:check": "prettier --check \"**/*.{js,cjs,mjs,json,yaml}\"",
+    "format:fix": "prettier --write \"**/*.{js,cjs,mjs,json,yaml}\"",
+    "lint": "eslint . --ext .js,.cjs,.mjs,.yaml --max-warnings=0",
+    "lint:fix": "eslint . --ext .js,.cjs,.mjs,.yaml --fix",
+    "lint:md": "markdownlint-cli2 \"**/*.md\"",
+    "prepare": "husky || exit 0",
+    "release": "npm run release:patch",
+    "release:major": "npm version major && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:patch": "npm version patch && git push --follow-tags",
+    "release:prerelease": "npm version prerelease && git push --follow-tags",
+    "test": "npm run test:schemas && npm run validate:schemas && npm run lint && npm run lint:md && npm run format:check",
+    "test:schemas": "node test/test-agent-schema.js",
+    "validate:schemas": "node test/validate-agent-schema.js"
+  },
+  "lint-staged": {
+    "*.{js,cjs,mjs}": [
+      "npm run lint:fix",
+      "npm run format:fix"
+    ],
+    "*.yaml": [
+      "eslint --fix",
+      "npm run format:fix"
+    ],
+    "*.json": [
+      "npm run format:fix"
+    ],
+    "*.md": [
+      "markdownlint-cli2"
+    ]
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.3.0"
+  },
+  "devDependencies": {
+    "@astrojs/sitemap": "^3.6.0",
+    "@astrojs/starlight": "^0.37.0",
+    "@eslint/js": "^9.33.0",
+    "archiver": "^7.0.1",
+    "astro": "^5.16.0",
+    "c8": "^10.1.3",
+    "csv-parse": "^6.1.0",
+    "eslint": "^9.33.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-n": "^17.21.3",
+    "eslint-plugin-unicorn": "^60.0.0",
+    "eslint-plugin-yml": "^1.18.0",
+    "figlet": "^1.8.0",
+    "glob": "^11.0.3",
+    "husky": "^9.1.7",
+    "ignore": "^7.0.5",
+    "jest": "^30.0.4",
+    "js-yaml": "^4.1.0",
+    "lint-staged": "^16.1.1",
+    "markdownlint-cli2": "^0.19.1",
+    "ora": "^5.4.1",
+    "prettier": "^3.7.4",
+    "prettier-plugin-packagejson": "^2.5.19",
+    "semver": "^7.6.3",
+    "sharp": "^0.33.5",
+    "wrap-ansi": "^7.0.0",
+    "xml2js": "^0.6.2",
+    "yaml": "^2.7.0",
+    "yaml-eslint-parser": "^1.2.3",
+    "yaml-lint": "^1.7.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/prettier.config.mjs

@@ -0,0 +1,32 @@
+export default {
+  $schema: 'https://json.schemastore.org/prettierrc',
+  printWidth: 140,
+  tabWidth: 2,
+  useTabs: false,
+  semi: true,
+  singleQuote: true,
+  trailingComma: 'all',
+  bracketSpacing: true,
+  arrowParens: 'always',
+  endOfLine: 'lf',
+  proseWrap: 'preserve',
+  overrides: [
+    {
+      files: ['*.md'],
+      options: { proseWrap: 'preserve' },
+    },
+    {
+      files: ['*.yaml'],
+      options: { singleQuote: false },
+    },
+    {
+      files: ['*.json', '*.jsonc'],
+      options: { singleQuote: false },
+    },
+    {
+      files: ['*.cjs'],
+      options: { parser: 'babel' },
+    },
+  ],
+  plugins: ['prettier-plugin-packagejson'],
+};

package/src/_module-installer/installer.js

@@ -0,0 +1,110 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const chalk = require('chalk');
+
+/**
+ * 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, 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 implementation_artifacts for compatibility
+    const implConfig = config['implementation_artifacts'] || config['implementation_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(', ')}`));
+    }
+
+    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;
+  }
+}
+
+module.exports = { install };

package/src/_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/_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/agents/game-architect.agent.yaml

@@ -0,0 +1,40 @@
+# Game Architect Agent Definition
+
+agent:
+  metadata:
+    id: "_bmad/gds/agents/game-architect.md"
+    name: Cloud Dragonborn
+    title: Game Architect
+    icon: 🏛️
+    module: gds
+    hasSidecar: false
+
+  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 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: GA or fuzzy match on game-architecture
+      exec: "{project-root}/_bmad/gds/workflows/3-technical/game-architecture/workflow.md"
+      description: "[GA] Produce a Scale Adaptive Game Architecture"
+
+    - trigger: PC or fuzzy match on project-context
+      exec: "{project-root}/_bmad/gds/workflows/3-technical/generate-project-context/workflow.md"
+      description: "[PC] Create optimized project-context.md for AI agent consistency"
+
+    - trigger: CC or fuzzy match on correct-course
+      workflow: "{project-root}/_bmad/gds/workflows/4-production/correct-course/workflow.yaml"
+      description: "[CC] Course Correction Analysis (when implementation is off-track)"
+      ide-only: true