Merge 251ec93150 into e39aa33eea

Removed unused properties that were set but never read:
- normalized.profileModules
- normalized.profileAgents
- normalized.profileWorkflows

These values were:
1. Stored as unwrapped (strings like 'all' or arrays)
2. Never accessed anywhere in the codebase
3. Created confusion - actual values used are normalized.modules/agents/workflows
4. Inconsistent with the wrapped versions actually used downstream

The profile values are already correctly processed and stored in
normalized.modules/agents/workflows (with proper array wrapping),
which are then passed to installer via config.cliOptions.

No functional change - just removing dead code that served no purpose.

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

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

.gitignore

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

CHANGELOG.md

@@ -1,5 +1,25 @@
 # 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,6 +292,8 @@ 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,6 +21,7 @@ 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`)
@@ -49,10 +50,11 @@ 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
 ```
 
@@ -170,7 +172,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`           |
@@ -181,7 +183,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` |
@@ -189,7 +191,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` |
 
@@ -206,6 +208,7 @@ npx bmad-method@alpha install -y --team=fullstack
 ```
 
 **Includes:**
+
 - Agents: analyst, architect, pm, sm, ux-designer
 - Module: BMM
 
@@ -218,6 +221,7 @@ 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)
@@ -252,6 +256,7 @@ npx bmad-method@alpha install -y --profile=minimal
 ```
 
 **Includes:**
+
 - Modules: core
 - Agents: dev
 - Workflows: create-tech-spec, quick-dev
@@ -265,6 +270,7 @@ 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
@@ -278,6 +284,7 @@ npx bmad-method@alpha install -y --profile=full
 ```
 
 **Includes:**
+
 - All modules
 - All agents
 - All workflows
@@ -291,6 +298,7 @@ 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
@@ -437,4 +445,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.18",
+  "version": "6.0.0-alpha.19",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",

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

@@ -33,6 +33,10 @@ 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,6 +12,7 @@ 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
@@ -131,7 +132,17 @@ platform: '{{platform}}'
 ---
 ````
 
-### 4. Present Completion Summary
+### 4. Update Workflow Status
+
+**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!**
 
@@ -158,9 +169,50 @@ platform: '{{platform}}'
 
 **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?
 
-### 5. Handle Review Requests
+**Optional Enhancement: Project Context File**
+
+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:**
 
@@ -179,7 +231,7 @@ Or type 'all' to see the complete document."
 
 **Show requested section and allow edits.**
 
-### 6. Present Next Steps Menu
+### 8. Present Next Steps Menu
 
 **After user confirms completion:**
 
@@ -204,7 +256,7 @@ Or type 'all' to see the complete document."
 2. Proceed to Epic creation workflow
 3. Exit workflow"
 
-### 7. Handle User Selection
+### 9. Handle User Selection
 
 Based on user choice:
 
@@ -224,7 +276,7 @@ Based on user choice:
 - Confirm document is saved and complete
 - Exit workflow gracefully
 
-### 8. Provide Handoff Guidance
+### 10. Provide Handoff Guidance
 
 **For Epic Creation handoff:**
 
@@ -270,6 +322,7 @@ 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
 
@@ -278,6 +331,7 @@ 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

@@ -0,0 +1,20 @@
+---
+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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,373 @@
+# 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

@@ -0,0 +1,279 @@
+# 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

@@ -0,0 +1,48 @@
+---
+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,23 +885,38 @@ class ConfigCollector {
       // Resolution order: CLI → ENV → existing → default → hardcoded
       if (moduleName === 'core') {
         // Core module has special mappings
-        if (key === 'user_name') {
+        switch (key) {
+          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') {
+
-          value = resolveValue(
+            break;
-            cliOptions.communicationLanguage,
+          }
-            null,
+          case 'communication_language': {
-            envDefaults.communicationLanguage,
+            value = resolveValue(cliOptions.communicationLanguage, null, envDefaults.communicationLanguage);
-          );
+
-        } else if (key === 'document_output_language') {
+            break;
+          }
+          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 (error) {
+  } catch {
     // 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.replace(/\*/g, '.*') + '$');
+          const regex = new RegExp('^' + pattern.replaceAll('*', '.*') + '$');
           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.replace(/\*/g, '.*') + '$');
+          const regex = new RegExp('^' + pattern.replaceAll('*', '.*') + '$');
           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.substring(1));
+      result.add.push(item.slice(1));
     } else if (item.startsWith('-')) {
-      result.remove.push(item.substring(1));
+      result.remove.push(item.slice(1));
     } else {
       result.base.push(item);
     }
@@ -118,27 +118,19 @@ function parseOptions(cliOptions) {
   if (normalized.profile) {
     const profile = getProfile(normalized.profile);
     if (!profile) {
-      throw new Error(
+      throw new Error(`Unknown profile: ${normalized.profile}. Valid profiles: minimal, full, solo-dev, team`);
-        `Unknown profile: ${normalized.profile}. Valid profiles: minimal, full, solo-dev, team`,
-      );
     }
 
-    // Profile provides defaults, but CLI options override
+    // Use profile values as defaults when CLI options not provided
-    normalized.profileModules = profile.modules;
+    // Ensure strings like 'all' are wrapped in arrays for consistency
-    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)
+      normalized.workflows = Array.isArray(profile.workflows) ? profile.workflows : [profile.workflows];
-        ? profile.workflows
-        : profile.workflows;
     }
   }
 
@@ -157,9 +149,7 @@ function validateOptions(options) {
   if (options.skillLevel) {
     const validLevels = ['beginner', 'intermediate', 'advanced'];
     if (!validLevels.includes(options.skillLevel.toLowerCase())) {
-      errors.push(
+      errors.push(`Invalid skill level: ${options.skillLevel}. Valid values: beginner, intermediate, advanced`);
-        `Invalid skill level: ${options.skillLevel}. Valid values: beginner, intermediate, advanced`,
-      );
     }
   }
 
@@ -167,9 +157,7 @@ function validateOptions(options) {
   if (options.profile) {
     const validProfiles = ['minimal', 'full', 'solo-dev', 'team'];
     if (!validProfiles.includes(options.profile.toLowerCase())) {
-      errors.push(
+      errors.push(`Invalid profile: ${options.profile}. Valid values: minimal, full, solo-dev, team`);
-        `Invalid profile: ${options.profile}. Valid values: minimal, full, solo-dev, team`,
-      );
     }
   }
 

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

@@ -28,14 +28,7 @@ const PROFILES = {
     description: 'Single developer setup - dev tools and planning workflows',
     modules: ['core', 'bmm'],
     agents: ['dev', 'architect', 'analyst', 'tech-writer'],
-    workflows: [
+    workflows: ['create-tech-spec', 'quick-dev', 'dev-story', 'code-review', 'create-prd', 'create-architecture'],
-      '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 (error) {
+  } catch {
     // If glob fails, return empty array
     return [];
   }
@@ -75,9 +75,7 @@ async function loadTeam(teamName, projectRoot) {
   if (!team) {
     // Provide helpful error with suggestions
     const availableTeams = teams.map((t) => t.name).join(', ');
-    throw new Error(
+    throw new Error(`Team '${teamName}' not found. Available teams: ${availableTeams || 'none'}`);
-      `Team '${teamName}' not found. Available teams: ${availableTeams || 'none'}`,
-    );
   }
 
   // Load full team definition
@@ -130,12 +128,12 @@ function applyTeamModifiers(team, agentModifiers = [], workflowModifiers = []) {
   // Parse and apply agent modifiers
   for (const modifier of agentModifiers) {
     if (modifier.startsWith('+')) {
-      const agent = modifier.substring(1);
+      const agent = modifier.slice(1);
       if (!result.agents.includes(agent)) {
         result.agents.push(agent);
       }
     } else if (modifier.startsWith('-')) {
-      const agent = modifier.substring(1);
+      const agent = modifier.slice(1);
       result.agents = result.agents.filter((a) => a !== agent);
     }
   }
@@ -143,12 +141,12 @@ function applyTeamModifiers(team, agentModifiers = [], workflowModifiers = []) {
   // Parse and apply workflow modifiers
   for (const modifier of workflowModifiers) {
     if (modifier.startsWith('+')) {
-      const workflow = modifier.substring(1);
+      const workflow = modifier.slice(1);
       if (!result.workflows.includes(workflow)) {
         result.workflows.push(workflow);
       }
     } else if (modifier.startsWith('-')) {
-      const workflow = modifier.substring(1);
+      const workflow = modifier.slice(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') {
+      if (options.modules === 'all' || (Array.isArray(options.modules) && options.modules.includes('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') {
+      if (profile.modules === 'all' || (Array.isArray(profile.modules) && profile.modules.includes('all'))) {
         selectedModules = ['bmm', 'bmbb', 'cis', 'bmgd'];
       } else if (Array.isArray(profile.modules)) {
         selectedModules = profile.modules.filter((m) => m !== 'core');