Merge 52bd250a8c into 23f650ff4d

.gitignore

@@ -29,7 +29,6 @@ Thumbs.db
 .prettierrc
 
 # IDE and editor configs
-.idea/
 .windsurf/
 .trae/
 _bmad*/.cursor/
@@ -67,7 +66,6 @@ shared-modules
 z*/
 
 _bmad
-_bmad-output/
 .claude
 .codex
 .github/chatmodes

CHANGELOG.md

@@ -1,25 +1,5 @@
 # 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**

README.md

@@ -292,8 +292,6 @@ MIT License - See [LICENSE](LICENSE) for details.
 
 **Trademarks:** BMad™ and BMAD-METHOD™ are trademarks of BMad Code, LLC.
 
-Supported by:&nbsp;&nbsp;<a href="https://m.do.co/c/00f11bd932bb"><img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" height="24" alt="DigitalOcean" style="vertical-align: middle;"></a>
-
 ---
 
 <p align="center">

docs/non-interactive-installation-guide.md

@@ -21,7 +21,6 @@ npx bmad-method@alpha install -y
 ```
 
 This installs BMAD with:
-
 - Default user name from system (USER environment variable)
 - Intermediate skill level
 - Default output folder (`_bmad-output`)
@@ -50,11 +49,10 @@ cat _bmad/bmm/config.yaml
 ```
 
 Example output:
-
 ```yaml
 user_name: Alice
 user_skill_level: intermediate
-output_folder: '{project-root}/_bmad-output'
+output_folder: "{project-root}/_bmad-output"
 communication_language: English
 ```
 
@@ -172,7 +170,7 @@ npx bmad-method@alpha install -y \
 ### Core Options
 
 | Option | Description | Default | Example |
-| --------------------------------- | ---------------------- | -------------- | ---------------------------------- |
+|--------|-------------|---------|---------|
 | `-y, --non-interactive` | Skip all prompts | `false` | `install -y` |
 | `--user-name <name>` | User name | System user | `--user-name=Alice` |
 | `--skill-level <level>` | Skill level | `intermediate` | `--skill-level=advanced` |
@@ -183,7 +181,7 @@ npx bmad-method@alpha install -y \
 ### Module & Selection Options
 
 | Option | Description | Example |
-| -------------------- | ------------------------- | ---------------------------------- |
+|--------|-------------|---------|
 | `--modules <list>` | Comma-separated modules | `--modules=core,bmm,bmbb` |
 | `--agents <list>` | Comma-separated agents | `--agents=dev,architect,pm` |
 | `--workflows <list>` | Comma-separated workflows | `--workflows=create-prd,dev-story` |
@@ -191,7 +189,7 @@ npx bmad-method@alpha install -y \
 ### Team & Profile Options
 
 | Option | Description | Example |
-| ------------------ | ----------------------- | ------------------- |
+|--------|-------------|---------|
 | `--team <name>` | Install predefined team | `--team=fullstack` |
 | `--profile <name>` | Installation profile | `--profile=minimal` |
 
@@ -208,7 +206,6 @@ npx bmad-method@alpha install -y --team=fullstack
 ```
 
 **Includes:**
-
 - Agents: analyst, architect, pm, sm, ux-designer
 - Module: BMM
 
@@ -221,7 +218,6 @@ npx bmad-method@alpha install -y --team=gamedev
 ```
 
 **Includes:**
-
 - Agents: game-designer, game-dev, game-architect, game-scrum-master
 - Workflows: brainstorm-game, game-brief, gdd, narrative
 - Module: BMGD (Game Development)
@@ -256,7 +252,6 @@ npx bmad-method@alpha install -y --profile=minimal
 ```
 
 **Includes:**
-
 - Modules: core
 - Agents: dev
 - Workflows: create-tech-spec, quick-dev
@@ -270,7 +265,6 @@ npx bmad-method@alpha install -y --profile=solo-dev
 ```
 
 **Includes:**
-
 - Modules: core, bmm
 - Agents: dev, architect, analyst, tech-writer
 - Workflows: create-tech-spec, quick-dev, dev-story, code-review, create-prd, create-architecture
@@ -284,7 +278,6 @@ npx bmad-method@alpha install -y --profile=full
 ```
 
 **Includes:**
-
 - All modules
 - All agents
 - All workflows
@@ -298,7 +291,6 @@ npx bmad-method@alpha install -y --profile=team
 ```
 
 **Includes:**
-
 - Modules: core, bmm
 - Agents: dev, architect, pm, sm, analyst, ux-designer
 - Workflows: create-product-brief, create-prd, create-architecture, create-epics-and-stories, sprint-planning, create-story, dev-story, code-review, workflow-init
@@ -445,4 +437,4 @@ fi
 ## Feedback
 
 Found an issue or have a suggestion? Please report it at:
-<https://github.com/bmad-code-org/BMAD-METHOD/issues>
+https://github.com/bmad-code-org/BMAD-METHOD/issues

package.json

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

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

@@ -33,10 +33,6 @@ agent:
       exec: "{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.md"
       description: Produce a Scale Adaptive Game Architecture
 
-    - trigger: generate-project-context
-      exec: "{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context/workflow.md"
-      description: Create optimized project-context.md for AI agent consistency
-
     - trigger: correct-course
       workflow: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml"
       description: Course Correction Analysis (when implementation is off-track)

src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md

@@ -12,7 +12,6 @@ outputFile: '{output_folder}/game-architecture.md'
 
 # Handoff References
 epicWorkflow: '{project-root}/_bmad/bmgd/workflows/4-production/epic-workflow/workflow.yaml'
-projectContextWorkflow: '{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context/workflow.md'
 ---
 
 # Step 9: Completion
@@ -132,17 +131,7 @@ platform: '{{platform}}'
 ---
 ````
 
-### 4. Update Workflow Status
+### 4. Present Completion Summary
-
-**If not in standalone mode:**
-
-Load `{output_folder}/bmgd-workflow-status.yaml` and:
-
-- Update `create-architecture` status to the output file path
-- Preserve all comments and structure
-- Determine next workflow in sequence
-
-### 5. Present Completion Summary
 
 "**Architecture Complete!**
 
@@ -169,50 +158,9 @@ Load `{output_folder}/bmgd-workflow-status.yaml` and:
 
 **Document saved to:** `{outputFile}`
 
-Do you want to review or adjust anything before we finalize?
+Do you want to review or adjust anything before we finalize?"
 
-**Optional Enhancement: Project Context File**
+### 5. Handle Review Requests
-
-Would you like to create a `project-context.md` file? This is a concise, optimized guide for AI agents that captures:
-
-- Critical engine-specific rules they might miss
-- Specific patterns and conventions for your game project
-- Performance and optimization requirements
-- Anti-patterns and edge cases to avoid
-
-{if_existing_project_context}
-I noticed you already have a project context file. Would you like to update it with your new architectural decisions?
-{else}
-This file helps ensure AI agents implement game code consistently with your project's unique requirements and patterns.
-{/if_existing_project_context}
-
-**Create/Update project context?** [Y/N]"
-
-### 6. Handle Project Context Creation Choice
-
-If user responds 'Y' or 'yes' to creating/updating project context:
-
-"Excellent choice! Let me launch the Generate Project Context workflow to create a comprehensive guide for AI agents.
-
-This will help ensure consistent implementation by capturing:
-
-- Engine-specific patterns and rules
-- Performance and optimization conventions from your architecture
-- Testing and quality standards
-- Anti-patterns to avoid
-
-The workflow will collaborate with you to create an optimized `project-context.md` file that AI agents will read before implementing any game code."
-
-**Execute the Generate Project Context workflow:**
-
-- Load and execute: `{projectContextWorkflow}`
-- The workflow will handle discovery, generation, and completion of the project context file
-- After completion, return here for final handoff
-
-If user responds 'N' or 'no':
-"Understood! Your architecture is complete and ready for implementation. You can always create a project context file later using the Generate Project Context workflow if needed."
-
-### 7. Handle Review Requests
 
 **If user wants to review:**
 
@@ -231,7 +179,7 @@ Or type 'all' to see the complete document."
 
 **Show requested section and allow edits.**
 
-### 8. Present Next Steps Menu
+### 6. Present Next Steps Menu
 
 **After user confirms completion:**
 
@@ -256,7 +204,7 @@ Or type 'all' to see the complete document."
 2. Proceed to Epic creation workflow
 3. Exit workflow"
 
-### 9. Handle User Selection
+### 7. Handle User Selection
 
 Based on user choice:
 
@@ -276,7 +224,7 @@ Based on user choice:
 - Confirm document is saved and complete
 - Exit workflow gracefully
 
-### 10. Provide Handoff Guidance
+### 8. Provide Handoff Guidance
 
 **For Epic Creation handoff:**
 
@@ -322,7 +270,6 @@ This is the final step. Ensure:
 - Development setup is complete
 - Document status updated to 'complete'
 - Frontmatter shows all steps completed
-- Workflow status updated (if tracking)
 - User has clear next steps
 - Document saved and ready for AI agent consumption
 
@@ -331,7 +278,6 @@ This is the final step. Ensure:
 - Missing executive summary
 - Incomplete development setup
 - Frontmatter not updated
-- Status not updated when tracking
 - No clear next steps provided
 - User left without actionable guidance
 

src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md

@@ -1,20 +0,0 @@
----
-project_name: '{{project_name}}'
-user_name: '{{user_name}}'
-date: '{{date}}'
-sections_completed: []
----
-
-# Project Context for AI Agents
-
-_This file contains critical rules and patterns that AI agents must follow when implementing game code in this project. Focus on unobvious details that agents might otherwise miss._
-
----
-
-## Technology Stack & Versions
-
-_Documented after discovery phase_
-
-## Critical Implementation Rules
-
-_Documented after discovery phase_

src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md

@@ -1,201 +0,0 @@
-# Step 1: Context Discovery & Initialization
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- NEVER generate content without user input
-- ALWAYS treat this as collaborative discovery between technical peers
-- YOU ARE A FACILITATOR, not a content generator
-- FOCUS on discovering existing project context and technology stack
-- IDENTIFY critical implementation rules that AI agents need
-- ABSOLUTELY NO TIME ESTIMATES
-
-## EXECUTION PROTOCOLS:
-
-- Show your analysis before taking any action
-- Read existing project files to understand current context
-- Initialize document and update frontmatter
-- FORBIDDEN to load next step until discovery is complete
-
-## CONTEXT BOUNDARIES:
-
-- Variables from workflow.md are available in memory
-- Focus on existing project files and architecture decisions
-- Look for patterns, conventions, and unique requirements
-- Prioritize rules that prevent implementation mistakes
-
-## YOUR TASK:
-
-Discover the project's game engine, technology stack, existing patterns, and critical implementation rules that AI agents must follow when writing game code.
-
-## DISCOVERY SEQUENCE:
-
-### 1. Check for Existing Project Context
-
-First, check if project context already exists:
-
-- Look for file at `{output_folder}/project-context.md`
-- If exists: Read complete file to understand existing rules
-- Present to user: "Found existing project context with {number_of_sections} sections. Would you like to update this or create a new one?"
-
-### 2. Discover Game Engine & Technology Stack
-
-Load and analyze project files to identify technologies:
-
-**Architecture Document:**
-
-- Look for `{output_folder}/game-architecture.md` or `{output_folder}/architecture.md`
-- Extract engine choice with specific version (Unity, Unreal, Godot, custom)
-- Note architectural decisions that affect implementation
-
-**Engine-Specific Files:**
-
-- Unity: Check for `ProjectSettings/ProjectVersion.txt`, `Packages/manifest.json`
-- Unreal: Check for `.uproject` files, `Config/DefaultEngine.ini`
-- Godot: Check for `project.godot`, `export_presets.cfg`
-- Custom: Check for engine config files, build scripts
-
-**Package/Dependency Files:**
-
-- Unity: `Packages/manifest.json`, NuGet packages
-- Unreal: `.Build.cs` files, plugin configs
-- Godot: `addons/` directory, GDExtension configs
-- Web-based: `package.json`, `requirements.txt`
-
-**Configuration Files:**
-
-- Build tool configs
-- Linting and formatting configs
-- Testing configurations
-- CI/CD pipeline configs
-
-### 3. Identify Existing Code Patterns
-
-Search through existing codebase for patterns:
-
-**Naming Conventions:**
-
-- Script/class naming patterns
-- Asset naming conventions
-- Scene/level naming patterns
-- Test file naming patterns
-
-**Code Organization:**
-
-- How components/scripts are structured
-- Where utilities and helpers are placed
-- How systems are organized
-- Folder hierarchy patterns
-
-**Engine-Specific Patterns:**
-
-- Unity: MonoBehaviour patterns, ScriptableObject usage, serialization rules
-- Unreal: Actor/Component patterns, Blueprint integration, UE macros
-- Godot: Node patterns, signal usage, autoload patterns
-
-### 4. Extract Critical Implementation Rules
-
-Look for rules that AI agents might miss:
-
-**Engine-Specific Rules:**
-
-- Unity: Assembly definitions, Unity lifecycle methods, coroutine patterns
-- Unreal: UPROPERTY/UFUNCTION usage, garbage collection rules, tick patterns
-- Godot: `_ready` vs `_enter_tree`, node ownership, scene instancing
-
-**Performance Rules:**
-
-- Frame budget constraints
-- Memory allocation patterns
-- Hot path optimization requirements
-- Object pooling patterns
-
-**Platform-Specific Rules:**
-
-- Target platform constraints
-- Input handling conventions
-- Platform-specific code patterns
-- Build configuration rules
-
-**Testing Rules:**
-
-- Test structure requirements
-- Mock usage conventions
-- Integration vs unit test boundaries
-- Play mode vs edit mode testing
-
-### 5. Initialize Project Context Document
-
-Based on discovery, create or update the context document:
-
-#### A. Fresh Document Setup (if no existing context)
-
-Copy template from `{installed_path}/project-context-template.md` to `{output_folder}/project-context.md`
-Initialize frontmatter with:
-
-```yaml
----
-project_name: '{{project_name}}'
-user_name: '{{user_name}}'
-date: '{{date}}'
-sections_completed: ['technology_stack']
-existing_patterns_found: { { number_of_patterns_discovered } }
----
-```
-
-#### B. Existing Document Update
-
-Load existing context and prepare for updates
-Set frontmatter `sections_completed` to track what will be updated
-
-### 6. Present Discovery Summary
-
-Report findings to user:
-
-"Welcome {{user_name}}! I've analyzed your game project for {{project_name}} to discover the context that AI agents need.
-
-**Game Engine & Stack Discovered:**
-{{engine_and_version}}
-{{list_of_technologies_with_versions}}
-
-**Existing Patterns Found:**
-
-- {{number_of_patterns}} implementation patterns
-- {{number_of_conventions}} coding conventions
-- {{number_of_rules}} critical rules
-
-**Key Areas for Context Rules:**
-
-- {{area_1}} (e.g., Engine lifecycle and patterns)
-- {{area_2}} (e.g., Performance and optimization)
-- {{area_3}} (e.g., Platform-specific requirements)
-
-{if_existing_context}
-**Existing Context:** Found {{sections}} sections already defined. We can update or add to these.
-{/if_existing_context}
-
-Ready to create/update your project context. This will help AI agents implement game code consistently with your project's standards.
-
-[C] Continue to context generation"
-
-## SUCCESS METRICS:
-
-- Existing project context properly detected and handled
-- Game engine and technology stack accurately identified with versions
-- Critical implementation patterns discovered
-- Project context document properly initialized
-- Discovery findings clearly presented to user
-- User ready to proceed with context generation
-
-## FAILURE MODES:
-
-- Not checking for existing project context before creating new one
-- Missing critical engine versions or configurations
-- Overlooking important coding patterns or conventions
-- Not initializing frontmatter properly
-- Not presenting clear discovery summary to user
-
-## NEXT STEP:
-
-After user selects [C] to continue, load `./step-02-generate.md` to collaboratively generate the specific project context rules.
-
-Remember: Do NOT proceed to step-02 until user explicitly selects [C] from the menu and discovery is confirmed!

src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md

@@ -1,373 +0,0 @@
-# Step 2: Context Rules Generation
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- NEVER generate content without user input
-- ALWAYS treat this as collaborative discovery between technical peers
-- YOU ARE A FACILITATOR, not a content generator
-- FOCUS on unobvious rules that AI agents need to be reminded of
-- KEEP CONTENT LEAN - optimize for LLM context efficiency
-- ABSOLUTELY NO TIME ESTIMATES
-
-## EXECUTION PROTOCOLS:
-
-- Show your analysis before taking any action
-- Focus on specific, actionable rules rather than general advice
-- Present A/P/C menu after each major rule category
-- ONLY save when user chooses C (Continue)
-- Update frontmatter with completed sections
-- FORBIDDEN to load next step until all sections are complete
-
-## COLLABORATION MENUS (A/P/C):
-
-This step will generate content and present choices for each rule category:
-
-- **A (Advanced Elicitation)**: Use discovery protocols to explore nuanced implementation rules
-- **P (Party Mode)**: Bring multiple perspectives to identify critical edge cases
-- **C (Continue)**: Save the current rules and proceed to next category
-
-## PROTOCOL INTEGRATION:
-
-- When 'A' selected: Execute {project-root}/\_bmad/core/tasks/advanced-elicitation.xml
-- When 'P' selected: Execute {project-root}/\_bmad/core/workflows/party-mode
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-
-## CONTEXT BOUNDARIES:
-
-- Discovery results from step-1 are available
-- Game engine and existing patterns are identified
-- Focus on rules that prevent implementation mistakes
-- Prioritize unobvious details that AI agents might miss
-
-## YOUR TASK:
-
-Collaboratively generate specific, critical rules that AI agents must follow when implementing game code in this project.
-
-## CONTEXT GENERATION SEQUENCE:
-
-### 1. Technology Stack & Versions
-
-Document the exact technology stack from discovery:
-
-**Core Technologies:**
-Based on user skill level, present findings:
-
-**Expert Mode:**
-"Technology stack from your architecture and project files:
-{{exact_technologies_with_versions}}
-
-Any critical version constraints I should document for agents?"
-
-**Intermediate Mode:**
-"I found your technology stack:
-
-**Game Engine:**
-{{engine_with_version}}
-
-**Key Dependencies:**
-{{important_dependencies_with_versions}}
-
-Are there any version constraints or compatibility notes agents should know about?"
-
-**Beginner Mode:**
-"Here are the technologies you're using:
-
-**Game Engine:**
-{{friendly_description_of_engine}}
-
-**Important Notes:**
-{{key_things_agents_need_to_know_about_versions}}
-
-Should I document any special version rules or compatibility requirements?"
-
-### 2. Engine-Specific Rules
-
-Focus on unobvious engine patterns agents might miss:
-
-**Unity Rules (if applicable):**
-"Based on your Unity project, I notice some specific patterns:
-
-**Lifecycle Rules:**
-{{unity_lifecycle_patterns}}
-
-**Serialization Rules:**
-{{serialization_requirements}}
-
-**Assembly Definitions:**
-{{assembly_definition_rules}}
-
-**Coroutine/Async Patterns:**
-{{async_patterns}}
-
-Are these patterns correct? Any other Unity-specific rules agents should follow?"
-
-**Unreal Rules (if applicable):**
-"Based on your Unreal project, I notice some specific patterns:
-
-**UPROPERTY/UFUNCTION Rules:**
-{{macro_usage_patterns}}
-
-**Blueprint Integration:**
-{{blueprint_rules}}
-
-**Garbage Collection:**
-{{gc_patterns}}
-
-**Tick Patterns:**
-{{tick_optimization_rules}}
-
-Are these patterns correct? Any other Unreal-specific rules agents should follow?"
-
-**Godot Rules (if applicable):**
-"Based on your Godot project, I notice some specific patterns:
-
-**Node Lifecycle:**
-{{node_lifecycle_patterns}}
-
-**Signal Usage:**
-{{signal_conventions}}
-
-**Scene Instancing:**
-{{scene_patterns}}
-
-**Autoload Patterns:**
-{{autoload_rules}}
-
-Are these patterns correct? Any other Godot-specific rules agents should follow?"
-
-### 3. Performance Rules
-
-Document performance-critical patterns:
-
-**Frame Budget Rules:**
-"Your game has these performance requirements:
-
-**Target Frame Rate:**
-{{target_fps}}
-
-**Frame Budget:**
-{{milliseconds_per_frame}}
-
-**Critical Systems:**
-{{systems_that_must_meet_budget}}
-
-**Hot Path Rules:**
-{{hot_path_patterns}}
-
-Any other performance rules agents must follow?"
-
-**Memory Management:**
-"Memory patterns for your project:
-
-**Allocation Rules:**
-{{allocation_patterns}}
-
-**Pooling Requirements:**
-{{object_pooling_rules}}
-
-**Asset Loading:**
-{{asset_loading_patterns}}
-
-Are there memory constraints agents should know about?"
-
-### 4. Code Organization Rules
-
-Document project structure and organization:
-
-**Folder Structure:**
-"Your project organization:
-
-**Script Organization:**
-{{script_folder_structure}}
-
-**Asset Organization:**
-{{asset_folder_patterns}}
-
-**Scene/Level Organization:**
-{{scene_organization}}
-
-Any organization rules agents must follow?"
-
-**Naming Conventions:**
-"Your naming patterns:
-
-**Script/Class Names:**
-{{class_naming_patterns}}
-
-**Asset Names:**
-{{asset_naming_patterns}}
-
-**Variable/Method Names:**
-{{variable_naming_patterns}}
-
-Any other naming rules?"
-
-### 5. Testing Rules
-
-Focus on testing patterns that ensure consistency:
-
-**Test Structure Rules:**
-"Your testing setup shows these patterns:
-
-**Test Organization:**
-{{test_file_organization}}
-
-**Test Categories:**
-{{unit_vs_integration_boundaries}}
-
-**Mocking Patterns:**
-{{mock_usage_conventions}}
-
-**Play Mode Testing:**
-{{play_mode_test_patterns}}
-
-Are there testing rules agents should always follow?"
-
-### 6. Platform & Build Rules
-
-Document platform-specific requirements:
-
-**Target Platforms:**
-"Your platform configuration:
-
-**Primary Platform:**
-{{primary_platform}}
-
-**Platform-Specific Code:**
-{{platform_conditional_patterns}}
-
-**Build Configurations:**
-{{build_config_rules}}
-
-**Input Handling:**
-{{input_abstraction_patterns}}
-
-Any platform rules agents must know?"
-
-### 7. Critical Don't-Miss Rules
-
-Identify rules that prevent common mistakes:
-
-**Anti-Patterns to Avoid:**
-"Based on your codebase, here are critical things agents must NOT do:
-
-{{critical_anti_patterns_with_examples}}
-
-**Edge Cases:**
-{{specific_edge_cases_agents_should_handle}}
-
-**Common Gotchas:**
-{{engine_specific_gotchas}}
-
-**Performance Traps:**
-{{performance_patterns_to_avoid}}
-
-Are there other 'gotchas' agents should know about?"
-
-### 8. Generate Context Content
-
-For each category, prepare lean content for the project context file:
-
-#### Content Structure:
-
-```markdown
-## Technology Stack & Versions
-
-{{concise_technology_list_with_exact_versions}}
-
-## Critical Implementation Rules
-
-### Engine-Specific Rules
-
-{{bullet_points_of_engine_rules}}
-
-### Performance Rules
-
-{{bullet_points_of_performance_requirements}}
-
-### Code Organization Rules
-
-{{bullet_points_of_organization_patterns}}
-
-### Testing Rules
-
-{{bullet_points_of_testing_requirements}}
-
-### Platform & Build Rules
-
-{{bullet_points_of_platform_requirements}}
-
-### Critical Don't-Miss Rules
-
-{{bullet_points_of_anti_patterns_and_gotchas}}
-```
-
-### 9. Present Content and Menu
-
-After each category, show the generated rules and present choices:
-
-"I've drafted the {{category_name}} rules for your project context.
-
-**Here's what I'll add:**
-
-[Show the complete markdown content for this category]
-
-**What would you like to do?**
-[A] Advanced Elicitation - Explore nuanced rules for this category
-[P] Party Mode - Review from different implementation perspectives
-[C] Continue - Save these rules and move to next category"
-
-### 10. Handle Menu Selection
-
-#### If 'A' (Advanced Elicitation):
-
-- Execute advanced-elicitation.xml with current category rules
-- Process enhanced rules that come back
-- Ask user: "Accept these enhanced rules for {{category}}? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'P' (Party Mode):
-
-- Execute party-mode workflow with category rules context
-- Process collaborative insights on implementation patterns
-- Ask user: "Accept these changes to {{category}} rules? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-
-#### If 'C' (Continue):
-
-- Save the current category content to project context file
-- Update frontmatter: `sections_completed: [...]`
-- Proceed to next category or step-03 if complete
-
-## APPEND TO PROJECT CONTEXT:
-
-When user selects 'C' for a category, append the content directly to `{output_folder}/project-context.md` using the structure from step 8.
-
-## SUCCESS METRICS:
-
-- All critical technology versions accurately documented
-- Engine-specific rules cover unobvious patterns
-- Performance rules capture project-specific requirements
-- Code organization rules maintain project standards
-- Testing rules ensure consistent test quality
-- Platform rules prevent cross-platform issues
-- Content is lean and optimized for LLM context
-- A/P/C menu presented and handled correctly for each category
-
-## FAILURE MODES:
-
-- Including obvious rules that agents already know
-- Making content too verbose for LLM context efficiency
-- Missing critical anti-patterns or edge cases
-- Not getting user validation for each rule category
-- Not documenting exact versions and configurations
-- Not presenting A/P/C menu after content generation
-
-## NEXT STEP:
-
-After completing all rule categories and user selects 'C' for the final category, load `./step-03-complete.md` to finalize the project context file.
-
-Remember: Do NOT proceed to step-03 until all categories are complete and user explicitly selects 'C' for each!

src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md

@@ -1,279 +0,0 @@
-# Step 3: Context Completion & Finalization
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- NEVER generate content without user input
-- ALWAYS treat this as collaborative completion between technical peers
-- YOU ARE A FACILITATOR, not a content generator
-- FOCUS on finalizing a lean, LLM-optimized project context
-- ENSURE all critical rules are captured and actionable
-- ABSOLUTELY NO TIME ESTIMATES
-
-## EXECUTION PROTOCOLS:
-
-- Show your analysis before taking any action
-- Review and optimize content for LLM context efficiency
-- Update frontmatter with completion status
-- NO MORE STEPS - this is the final step
-
-## CONTEXT BOUNDARIES:
-
-- All rule categories from step-2 are complete
-- Technology stack and versions are documented
-- Focus on final review, optimization, and completion
-- Ensure the context file is ready for AI agent consumption
-
-## YOUR TASK:
-
-Complete the project context file, optimize it for LLM efficiency, and provide guidance for usage and maintenance.
-
-## COMPLETION SEQUENCE:
-
-### 1. Review Complete Context File
-
-Read the entire project context file and analyze:
-
-**Content Analysis:**
-
-- Total length and readability for LLMs
-- Clarity and specificity of rules
-- Coverage of all critical areas
-- Actionability of each rule
-
-**Structure Analysis:**
-
-- Logical organization of sections
-- Consistency of formatting
-- Absence of redundant or obvious information
-- Optimization for quick scanning
-
-### 2. Optimize for LLM Context
-
-Ensure the file is lean and efficient:
-
-**Content Optimization:**
-
-- Remove any redundant rules or obvious information
-- Combine related rules into concise bullet points
-- Use specific, actionable language
-- Ensure each rule provides unique value
-
-**Formatting Optimization:**
-
-- Use consistent markdown formatting
-- Implement clear section hierarchy
-- Ensure scannability with strategic use of bolding
-- Maintain readability while maximizing information density
-
-### 3. Final Content Structure
-
-Ensure the final structure follows this optimized format:
-
-```markdown
-# Project Context for AI Agents
-
-_This file contains critical rules and patterns that AI agents must follow when implementing game code in this project. Focus on unobvious details that agents might otherwise miss._
-
----
-
-## Technology Stack & Versions
-
-{{concise_technology_list}}
-
-## Critical Implementation Rules
-
-### Engine-Specific Rules
-
-{{engine_rules}}
-
-### Performance Rules
-
-{{performance_requirements}}
-
-### Code Organization Rules
-
-{{organization_patterns}}
-
-### Testing Rules
-
-{{testing_requirements}}
-
-### Platform & Build Rules
-
-{{platform_requirements}}
-
-### Critical Don't-Miss Rules
-
-{{anti_patterns_and_gotchas}}
-
----
-
-## Usage Guidelines
-
-**For AI Agents:**
-
-- Read this file before implementing any game code
-- Follow ALL rules exactly as documented
-- When in doubt, prefer the more restrictive option
-- Update this file if new patterns emerge
-
-**For Humans:**
-
-- Keep this file lean and focused on agent needs
-- Update when technology stack changes
-- Review quarterly for outdated rules
-- Remove rules that become obvious over time
-
-Last Updated: {{date}}
-```
-
-### 4. Present Completion Summary
-
-Based on user skill level, present the completion:
-
-**Expert Mode:**
-"Project context complete. Optimized for LLM consumption with {{rule_count}} critical rules across {{section_count}} sections.
-
-File saved to: `{output_folder}/project-context.md`
-
-Ready for AI agent integration."
-
-**Intermediate Mode:**
-"Your project context is complete and optimized for AI agents!
-
-**What we created:**
-
-- {{rule_count}} critical implementation rules
-- Technology stack with exact versions
-- Engine-specific patterns and conventions
-- Performance and optimization guidelines
-- Testing and platform requirements
-
-**Key benefits:**
-
-- AI agents will implement consistently with your standards
-- Reduced context switching and implementation errors
-- Clear guidance for unobvious project requirements
-
-**Next steps:**
-
-- AI agents should read this file before implementing
-- Update as your project evolves
-- Review periodically for optimization"
-
-**Beginner Mode:**
-"Excellent! Your project context guide is ready!
-
-**What this does:**
-Think of this as a 'rules of the road' guide for AI agents working on your game. It ensures they all follow the same patterns and avoid common mistakes.
-
-**What's included:**
-
-- Exact engine and technology versions to use
-- Critical coding rules they might miss
-- Performance and optimization standards
-- Testing and platform requirements
-
-**How AI agents use it:**
-They read this file before writing any code, ensuring everything they create follows your project's standards perfectly.
-
-Your project context is saved and ready to help agents implement consistently!"
-
-### 5. Final File Updates
-
-Update the project context file with completion information:
-
-**Frontmatter Update:**
-
-```yaml
----
-project_name: '{{project_name}}'
-user_name: '{{user_name}}'
-date: '{{date}}'
-sections_completed:
-  ['technology_stack', 'engine_rules', 'performance_rules', 'organization_rules', 'testing_rules', 'platform_rules', 'anti_patterns']
-status: 'complete'
-rule_count: { { total_rules } }
-optimized_for_llm: true
----
-```
-
-**Add Usage Section:**
-Append the usage guidelines from step 3 to complete the document.
-
-### 6. Completion Validation
-
-Final checks before completion:
-
-**Content Validation:**
-
-- All critical technology versions documented
-- Engine-specific rules are specific and actionable
-- Performance rules capture project requirements
-- Code organization rules maintain standards
-- Testing rules ensure consistency
-- Platform rules prevent cross-platform issues
-- Anti-pattern rules prevent common mistakes
-
-**Format Validation:**
-
-- Content is lean and optimized for LLMs
-- Structure is logical and scannable
-- No redundant or obvious information
-- Consistent formatting throughout
-
-### 7. Completion Message
-
-Present final completion to user:
-
-"**Project Context Generation Complete!**
-
-Your optimized project context file is ready at:
-`{output_folder}/project-context.md`
-
-**Context Summary:**
-
-- {{rule_count}} critical rules for AI agents
-- {{section_count}} comprehensive sections
-- Optimized for LLM context efficiency
-- Ready for immediate agent integration
-
-**Key Benefits:**
-
-- Consistent implementation across all AI agents
-- Reduced common mistakes and edge cases
-- Clear guidance for project-specific patterns
-- Minimal LLM context usage
-
-**Next Steps:**
-
-1. AI agents will automatically read this file when implementing
-2. Update this file when your technology stack or patterns evolve
-3. Review quarterly to optimize and remove outdated rules
-
-Your project context will help ensure high-quality, consistent game implementation across all development work. Great work capturing your project's critical implementation requirements!"
-
-## SUCCESS METRICS:
-
-- Complete project context file with all critical rules
-- Content optimized for LLM context efficiency
-- All technology versions and patterns documented
-- File structure is logical and scannable
-- Usage guidelines included for agents and humans
-- Frontmatter properly updated with completion status
-- User provided with clear next steps and benefits
-
-## FAILURE MODES:
-
-- Final content is too verbose for LLM consumption
-- Missing critical implementation rules or patterns
-- Not optimizing content for agent readability
-- Not providing clear usage guidelines
-- Frontmatter not properly updated
-- Not validating file completion before ending
-
-## WORKFLOW COMPLETE:
-
-This is the final step of the Generate Project Context workflow. The user now has a comprehensive, optimized project context file that will ensure consistent, high-quality game implementation across all AI agents working on the project.
-
-The project context file serves as the critical "rules of the road" that agents need to implement game code consistently with the project's standards and patterns.

src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md

@@ -1,48 +0,0 @@
----
-name: generate-project-context
-description: Creates a concise project-context.md file with critical rules and patterns that AI agents must follow when implementing game code. Optimized for LLM context efficiency.
----
-
-# Generate Project Context Workflow
-
-**Goal:** Create a concise, optimized `project-context.md` file containing critical rules, patterns, and guidelines that AI agents must follow when implementing game code. This file focuses on unobvious details that LLMs need to be reminded of.
-
-**Your Role:** You are a technical facilitator working with a peer to capture the essential implementation rules that will ensure consistent, high-quality game code generation across all AI agents working on the project.
-
----
-
-## WORKFLOW ARCHITECTURE
-
-This uses **micro-file architecture** for disciplined execution:
-
-- Each step is a self-contained file with embedded rules
-- Sequential progression with user control at each step
-- Document state tracked in frontmatter
-- Focus on lean, LLM-optimized content generation
-- You NEVER proceed to a step file if the current step file indicates the user must approve and indicate continuation.
-
----
-
-## INITIALIZATION
-
-### Configuration Loading
-
-Load config from `{project-root}/_bmad/bmgd/config.yaml` and resolve:
-
-- `project_name`, `output_folder`, `user_name`
-- `communication_language`, `document_output_language`, `game_dev_experience`
-- `date` as system-generated current datetime
-
-### Paths
-
-- `installed_path` = `{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context`
-- `template_path` = `{installed_path}/project-context-template.md`
-- `output_file` = `{output_folder}/project-context.md`
-
----
-
-## EXECUTION
-
-Load and execute `steps/step-01-discover.md` to begin the workflow.
-
-**Note:** Input document discovery and initialization protocols are handled in step-01-discover.md.

tools/cli/installers/lib/core/config-collector.js

@@ -885,38 +885,23 @@ class ConfigCollector {
       // Resolution order: CLI → ENV → existing → default → hardcoded
       if (moduleName === 'core') {
         // Core module has special mappings
-        switch (key) {
+        if (key === 'user_name') {
-          case 'user_name': {
           value = resolveValue(cliOptions.userName, null, envDefaults.userName);
-
+        } else if (key === 'user_skill_level') {
-            break;
-          }
-          case 'user_skill_level': {
           value = resolveValue(cliOptions.skillLevel, null, item.default || 'intermediate');
-
+        } else if (key === 'communication_language') {
-            break;
+          value = resolveValue(
-          }
+            cliOptions.communicationLanguage,
-          case 'communication_language': {
+            null,
-            value = resolveValue(cliOptions.communicationLanguage, null, envDefaults.communicationLanguage);
+            envDefaults.communicationLanguage,
-
+          );
-            break;
+        } else if (key === 'document_output_language') {
-          }
-          case 'document_output_language': {
           value = resolveValue(cliOptions.documentLanguage, null, envDefaults.documentLanguage);
-
+        } else if (key === 'output_folder') {
-            break;
-          }
-          case 'output_folder': {
           value = resolveValue(cliOptions.outputFolder, null, item.default);
-
+        } else if (item.default !== undefined) {
-            break;
-          }
-          default: {
-            if (item.default !== undefined) {
           value = item.default;
         }
-          }
-        }
       } else {
         // For other modules, use defaults
         if (item.default !== undefined) {

tools/cli/installers/lib/core/env-resolver.js

@@ -26,7 +26,7 @@ function getUserName() {
     if (userInfo.username) {
       return userInfo.username;
     }
-  } catch {
+  } catch (error) {
     // os.userInfo() can fail in some environments
   }
 

tools/cli/installers/lib/core/manifest-generator.js

@@ -161,7 +161,7 @@ class ManifestGenerator {
 
         // Wildcard matching: create-* matches create-prd, create-tech-spec, etc.
         if (pattern.includes('*')) {
-          const regex = new RegExp('^' + pattern.replaceAll('*', '.*') + '$');
+          const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
           return regex.test(workflowName);
         }
 
@@ -318,7 +318,7 @@ class ManifestGenerator {
 
         // Wildcard matching: dev* matches dev, dev-story, etc.
         if (pattern.includes('*')) {
-          const regex = new RegExp('^' + pattern.replaceAll('*', '.*') + '$');
+          const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
           return regex.test(agentName);
         }
 

tools/cli/installers/lib/core/options-parser.js

@@ -58,9 +58,9 @@ function separateModifiers(list) {
 
   for (const item of list) {
     if (item.startsWith('+')) {
-      result.add.push(item.slice(1));
+      result.add.push(item.substring(1));
     } else if (item.startsWith('-')) {
-      result.remove.push(item.slice(1));
+      result.remove.push(item.substring(1));
     } else {
       result.base.push(item);
     }
@@ -118,19 +118,27 @@ function parseOptions(cliOptions) {
   if (normalized.profile) {
     const profile = getProfile(normalized.profile);
     if (!profile) {
-      throw new Error(`Unknown profile: ${normalized.profile}. Valid profiles: minimal, full, solo-dev, team`);
+      throw new Error(
+        `Unknown profile: ${normalized.profile}. Valid profiles: minimal, full, solo-dev, team`,
+      );
     }
 
-    // Use profile values as defaults when CLI options not provided
+    // Profile provides defaults, but CLI options override
-    // Ensure strings like 'all' are wrapped in arrays for consistency
+    normalized.profileModules = profile.modules;
+    normalized.profileAgents = profile.agents;
+    normalized.profileWorkflows = profile.workflows;
+
+    // If no explicit modules/agents/workflows, use profile values
     if (!normalized.modules) {
-      normalized.modules = Array.isArray(profile.modules) ? profile.modules : [profile.modules];
+      normalized.modules = Array.isArray(profile.modules) ? profile.modules : profile.modules;
     }
     if (!normalized.agents) {
-      normalized.agents = Array.isArray(profile.agents) ? profile.agents : [profile.agents];
+      normalized.agents = Array.isArray(profile.agents) ? profile.agents : profile.agents;
     }
     if (!normalized.workflows) {
-      normalized.workflows = Array.isArray(profile.workflows) ? profile.workflows : [profile.workflows];
+      normalized.workflows = Array.isArray(profile.workflows)
+        ? profile.workflows
+        : profile.workflows;
     }
   }
 
@@ -149,7 +157,9 @@ function validateOptions(options) {
   if (options.skillLevel) {
     const validLevels = ['beginner', 'intermediate', 'advanced'];
     if (!validLevels.includes(options.skillLevel.toLowerCase())) {
-      errors.push(`Invalid skill level: ${options.skillLevel}. Valid values: beginner, intermediate, advanced`);
+      errors.push(
+        `Invalid skill level: ${options.skillLevel}. Valid values: beginner, intermediate, advanced`,
+      );
     }
   }
 
@@ -157,7 +167,9 @@ function validateOptions(options) {
   if (options.profile) {
     const validProfiles = ['minimal', 'full', 'solo-dev', 'team'];
     if (!validProfiles.includes(options.profile.toLowerCase())) {
-      errors.push(`Invalid profile: ${options.profile}. Valid values: minimal, full, solo-dev, team`);
+      errors.push(
+        `Invalid profile: ${options.profile}. Valid values: minimal, full, solo-dev, team`,
+      );
     }
   }
 

tools/cli/installers/lib/profiles/definitions.js

@@ -28,7 +28,14 @@ const PROFILES = {
     description: 'Single developer setup - dev tools and planning workflows',
     modules: ['core', 'bmm'],
     agents: ['dev', 'architect', 'analyst', 'tech-writer'],
-    workflows: ['create-tech-spec', 'quick-dev', 'dev-story', 'code-review', 'create-prd', 'create-architecture'],
+    workflows: [
+      'create-tech-spec',
+      'quick-dev',
+      'dev-story',
+      'code-review',
+      'create-prd',
+      'create-architecture',
+    ],
   },
 
   team: {

tools/cli/installers/lib/teams/team-loader.js

@@ -49,7 +49,7 @@ async function discoverTeams(projectRoot) {
     }
 
     return teams;
-  } catch {
+  } catch (error) {
     // If glob fails, return empty array
     return [];
   }
@@ -75,7 +75,9 @@ async function loadTeam(teamName, projectRoot) {
   if (!team) {
     // Provide helpful error with suggestions
     const availableTeams = teams.map((t) => t.name).join(', ');
-    throw new Error(`Team '${teamName}' not found. Available teams: ${availableTeams || 'none'}`);
+    throw new Error(
+      `Team '${teamName}' not found. Available teams: ${availableTeams || 'none'}`,
+    );
   }
 
   // Load full team definition
@@ -128,12 +130,12 @@ function applyTeamModifiers(team, agentModifiers = [], workflowModifiers = []) {
   // Parse and apply agent modifiers
   for (const modifier of agentModifiers) {
     if (modifier.startsWith('+')) {
-      const agent = modifier.slice(1);
+      const agent = modifier.substring(1);
       if (!result.agents.includes(agent)) {
         result.agents.push(agent);
       }
     } else if (modifier.startsWith('-')) {
-      const agent = modifier.slice(1);
+      const agent = modifier.substring(1);
       result.agents = result.agents.filter((a) => a !== agent);
     }
   }
@@ -141,12 +143,12 @@ function applyTeamModifiers(team, agentModifiers = [], workflowModifiers = []) {
   // Parse and apply workflow modifiers
   for (const modifier of workflowModifiers) {
     if (modifier.startsWith('+')) {
-      const workflow = modifier.slice(1);
+      const workflow = modifier.substring(1);
       if (!result.workflows.includes(workflow)) {
         result.workflows.push(workflow);
       }
     } else if (modifier.startsWith('-')) {
-      const workflow = modifier.slice(1);
+      const workflow = modifier.substring(1);
       result.workflows = result.workflows.filter((w) => w !== workflow);
     }
   }

tools/cli/lib/ui.js

@@ -1545,7 +1545,7 @@ class UI {
       }
     } else if (options.modules) {
       // Module-based installation
-      if (options.modules === 'all' || (Array.isArray(options.modules) && options.modules.includes('all'))) {
+      if (options.modules === 'all') {
         selectedModules = ['bmm', 'bmbb', 'cis', 'bmgd'];
       } else if (Array.isArray(options.modules)) {
         selectedModules = options.modules.filter((m) => m !== 'core');
@@ -1554,7 +1554,7 @@ class UI {
       // Profile-based installation
       const { getProfile } = require('../installers/lib/profiles/definitions');
       const profile = getProfile(options.profile);
-      if (profile.modules === 'all' || (Array.isArray(profile.modules) && profile.modules.includes('all'))) {
+      if (profile.modules === 'all') {
         selectedModules = ['bmm', 'bmbb', 'cis', 'bmgd'];
       } else if (Array.isArray(profile.modules)) {
         selectedModules = profile.modules.filter((m) => m !== 'core');