bmad-game-dev-studio 0.1.0

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,41 @@
+# GDS - BMAD Game Development Suite
+
+![](docs/bmgd-logo.png)
+
+BMAD Game Development Suite (GDS) brings the power of BMAD's project planning and structured development to game development. Create working prototypes quickly in three of the industry's leading 3D engines (Unity, Unreal, and Godot) or whatever platform you like. GDS will lead you through product research, technical design, narrative design, and a full epic-driven production cycle, developed by game industry veterans off of BMAD Method's core.
+
+Sound like *too much* power? You can also use GDS to quickly prototype an idea, skipping most of the planning steps and going straight into breaking things in your engine of choice!
+
+## What can BMGD do?
+
+GDS, out of the box, contains support for game development and testing in:
+
+* [Unity](https://unity.com)
+* [Unreal](https://www.unrealengine.com/)
+* [Godot](https://godotengine.org/)
+
+However, these engines *aren't a requirement* - if you want to make a roguelike in pure C, BMGD can handle it.  The GDS process will guide you through every step of creating a game project, all the way to release.
+
+As for what kind of games you can create? GDS has support for *21* game types, from turn-based strategy to visual novels to survival games. And if your game idea doesn't fit in any one of those, that's fine, too.
+
+## What can't GDS do?
+
+With very few simple exceptions, *GDS cannot create an entire game from scratch for you.* 
+
+GDS is designed to work with *coding agents* such as Claude Code, Codex, Gemini, or Github Copilot. There are *many* aspects of game development that are outside the scope of these agents - such as art assets such as models and textures, animations, music, and sound effects. GDS can work to integrate these into your chosen engine, but it *can't* create them. 
+
+As such, it's designed to be part of your development team, not a one-stop solution for creating a game.
+
+## What do I need to do to begin?
+
+To install GDS, just select it as part of the BMAD Method install. To update it, simply re-install BMAD Method.
+
+* Follow this walkthrough TODO! to install GDS and create your first project.
+* Read this tutorial TODO! on using Quick-Dev to create a prototype quickly
+* Consult the tomes of documentation TODO! on all the functionality GDS has to offer.
+
+## This is a lot! Can I get some help?
+
+Absolutely! The best place to get help is on our friendly BMAD Method Discord. There's a specific GDS forum (link TODO!!) where the developers and other GDS users will be glad to help out!
+
+*BMAD GDS - If you can dream it, you can do 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,92 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "bmad-game-dev-studio",
+  "version": "0.1.0",
+  "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": "",
+  "bin": {},
+  "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",
+    "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-eslint-parser": "^1.2.3",
+    "yaml-lint": "^1.7.0",
+    "yaml": "^2.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, 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 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

package/src/agents/game-designer.agent.yaml

@@ -0,0 +1,45 @@
+# Game Designer Agent Definition
+
+agent:
+  metadata:
+    id: "_bmad/gds/agents/game-designer.md"
+    name: Samus Shepard
+    title: Game Designer
+    icon: 🎲
+    module: gds
+    hasSidecar: false
+
+  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 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: BG or fuzzy match on brainstorm-game
+      exec: "{project-root}/_bmad/gds/workflows/1-preproduction/brainstorm-game/workflow.md"
+      description: "[BG] Brainstorm Game ideas and concepts"
+
+    - trigger: GB or fuzzy match on game-brief
+      exec: "{project-root}/_bmad/gds/workflows/1-preproduction/game-brief/workflow.md"
+      description: "[GB] Create a Game Brief document"
+
+    - trigger: GDD or fuzzy match on create-gdd
+      exec: "{project-root}/_bmad/gds/workflows/2-design/gdd/workflow.md"
+      description: "[GDD] Create a Game Design Document"
+
+    - trigger: ND or fuzzy match on narrative-design
+      exec: "{project-root}/_bmad/gds/workflows/2-design/narrative/workflow.md"
+      description: "[ND] Design narrative elements and story"
+
+    - trigger: QP or fuzzy match on quick-prototype
+      workflow: "{project-root}/_bmad/gds/workflows/gds-quick-flow/quick-prototype/workflow.yaml"
+      description: "[QP] Rapid game prototyping - test mechanics and ideas quickly"
+      ide-only: true