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

package/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-08-validation.md

@@ -0,0 +1,293 @@
+---
+name: 'step-08-validation'
+description: 'Validate architectural coherence and completeness'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-08-validation.md'
+nextStepFile: '{workflow_path}/steps/step-09-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+checklistFile: '{workflow_path}/checklist.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 8: Validation
+
+**Progress: Step 8 of 9** - Next: Completion
+
+## STEP GOAL:
+
+Validate that the architecture is coherent, complete, and ready to guide AI agent implementation. Check for conflicts, gaps, and missing coverage.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Validation ensures document completeness
+- Catch gaps before implementation begins
+
+### Step-Specific Rules:
+
+- Run through all validation checks
+- Fix any issues before proceeding
+- User must confirm document is ready
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after validation complete
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into gaps
+- **P (Party Mode)**: Get perspectives on completeness
+- **C (Continue)**: Confirm validation and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Validation Checklist
+
+**Load the checklist if available:**
+
+Load `{checklistFile}` for structured validation criteria.
+
+### 2. Decision Compatibility Check
+
+"**Checking Decision Compatibility...**
+
+Verifying all architectural decisions work together:
+
+| Check                          | Status        | Notes     |
+| ------------------------------ | ------------- | --------- |
+| Engine + patterns compatible   | {{pass/fail}} | {{notes}} |
+| Cross-cutting + engine align   | {{pass/fail}} | {{notes}} |
+| Structure supports all systems | {{pass/fail}} | {{notes}} |
+| No conflicting decisions       | {{pass/fail}} | {{notes}} |
+
+{{if_issues_found}}
+**Issues Found:**
+{{list_of_conflicts}}
+
+How should we resolve these?
+{{/if_issues_found}}"
+
+### 3. GDD Coverage Check
+
+"**Checking GDD Coverage...**
+
+Verifying every GDD requirement has architectural support:
+
+**Core Systems:**
+| System | Architecture Support | Status |
+|--------|---------------------|--------|
+{{systems_coverage_table}}
+
+**Technical Requirements:**
+| Requirement | How Addressed | Status |
+|-------------|---------------|--------|
+{{requirements_coverage_table}}
+
+{{if_gaps_found}}
+**Gaps Found:**
+{{list_of_gaps}}
+
+How should we address these?
+{{/if_gaps_found}}"
+
+### 4. Pattern Completeness Check
+
+"**Checking Pattern Completeness...**
+
+Verifying implementation patterns cover all scenarios:
+
+| Scenario                | Pattern Defined | Status     |
+| ----------------------- | --------------- | ---------- |
+| Entity creation         | {{yes/no}}      | {{status}} |
+| Component communication | {{yes/no}}      | {{status}} |
+| State management        | {{yes/no}}      | {{status}} |
+| Error handling          | {{yes/no}}      | {{status}} |
+| Data access             | {{yes/no}}      | {{status}} |
+| Event handling          | {{yes/no}}      | {{status}} |
+
+{{if_missing_patterns}}
+**Missing Patterns:**
+{{list_of_missing}}
+
+Should we define these now?
+{{/if_missing_patterns}}"
+
+### 5. Epic Mapping Check
+
+"**Checking Epic Mapping...**
+
+Verifying every epic/feature maps to architecture:
+
+| Epic/Feature | Location | Patterns | Status |
+| ------------ | -------- | -------- | ------ |
+
+{{epic_mapping_table}}
+
+{{if_unmapped_epics}}
+**Unmapped Features:**
+{{list_of_unmapped}}
+
+Where should these live?
+{{/if_unmapped_epics}}"
+
+### 6. Document Completeness Check
+
+"**Checking Document Completeness...**
+
+Mandatory sections:
+
+- [ ] Engine/Framework selection with version
+- [ ] Decision summary table
+- [ ] Project structure (complete, not placeholder)
+- [ ] Cross-cutting concerns
+- [ ] Implementation patterns with examples
+- [ ] Naming conventions
+- [ ] No placeholder text ({{placeholders}}, TODO, etc.)
+
+{{if_incomplete}}
+**Incomplete Sections:**
+{{list_of_incomplete}}
+
+Let's fix these before proceeding.
+{{/if_incomplete}}"
+
+### 7. Resolve Any Issues
+
+**If issues were found in any check:**
+
+For each issue:
+
+1. Present the problem clearly
+2. Propose a solution
+3. Get user confirmation
+4. Update the document
+
+**Repeat validation if significant changes made.**
+
+### 8. Generate Validation Summary
+
+Based on the checks, prepare the summary:
+
+```markdown
+## Architecture Validation
+
+### Validation Summary
+
+| Check                  | Result        | Notes     |
+| ---------------------- | ------------- | --------- |
+| Decision Compatibility | {{pass/fail}} | {{notes}} |
+| GDD Coverage           | {{pass/fail}} | {{notes}} |
+| Pattern Completeness   | {{pass/fail}} | {{notes}} |
+| Epic Mapping           | {{pass/fail}} | {{notes}} |
+| Document Completeness  | {{pass/fail}} | {{notes}} |
+
+### Coverage Report
+
+**Systems Covered:** {{count}}/{{total}}
+**Patterns Defined:** {{count}}
+**Decisions Made:** {{count}}
+
+### Issues Resolved
+
+{{list_of_resolved_issues}}
+
+### Validation Date
+
+{{date}}
+```
+
+### 9. Present Validation and Menu
+
+Show the validation results to the user and present:
+
+"**Architecture Validation Complete**
+
+**Results:**
+
+[Show validation summary]
+
+**Overall Status:** {{PASS/NEEDS_WORK}}
+
+{{if_pass}}
+Your architecture document is complete and ready to guide implementation.
+{{/if_pass}}
+
+{{if_needs_work}}
+Some issues need resolution before the architecture is ready.
+{{/if_needs_work}}
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into any gaps
+[P] Party Mode - Get perspectives on completeness
+[C] Continue - Save validation and move to Completion (Step 9 of 9)"
+
+### 10. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with validation results
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, re-run validation
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with validation results
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, re-run validation
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append validation summary to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [validation content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- All validation checks performed
+- Issues identified and resolved
+- GDD coverage verified
+- Pattern completeness confirmed
+- Document has no placeholders
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
+
+### SYSTEM FAILURE:
+
+- Skipping validation checks
+- Proceeding with unresolved issues
+- Incomplete document going to completion
+- Not presenting A/P/C menu after validation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

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

@@ -0,0 +1,302 @@
+---
+name: 'step-09-complete'
+description: 'Complete the architecture workflow with final review and handoff guidance'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-09-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Handoff References
+epicWorkflow: '{project-root}/_bmad/bmgd/workflows/4-production/epic-workflow/workflow.yaml'
+---
+
+# Step 9: Completion
+
+**Progress: Step 9 of 9** - Architecture Complete!
+
+## STEP GOAL:
+
+Generate the executive summary, finalize the document, update workflow status, and provide clear handoff guidance for the next workflow phase.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- This is the final step - ensure completeness
+- Provide actionable next steps
+
+### Step-Specific Rules:
+
+- Generate executive summary from all content
+- Ensure document is ready for AI agent consumption
+- Provide clear implementation guidance
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Generate final sections
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]`
+- Present completion summary and next steps
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Generate Executive Summary
+
+**Create summary from all sections:**
+
+Based on all documented content, synthesize an executive summary:
+
+```markdown
+## Executive Summary
+
+**{{game_name}}** architecture is designed for {{engine}} targeting {{platform}}.
+
+**Key Architectural Decisions:**
+
+- {{decision_1_summary}}
+- {{decision_2_summary}}
+- {{decision_3_summary}}
+
+**Project Structure:** {{organization_pattern}} organization with {{system_count}} core systems.
+
+**Implementation Patterns:** {{pattern_count}} patterns defined ensuring AI agent consistency.
+
+**Ready for:** Epic implementation phase
+```
+
+### 2. Generate Development Setup Section
+
+"Let me generate the development environment setup section.
+
+**Development Prerequisites:**
+
+````markdown
+## Development Environment
+
+### Prerequisites
+
+{{prerequisites_list}}
+
+### Setup Commands
+
+```bash
+{{setup_commands}}
+```
+````
+
+### First Steps
+
+1. {{first_step}}
+2. {{second_step}}
+3. {{third_step}}
+
+````
+
+Does this capture the setup process correctly?"
+
+### 3. Finalize Document
+
+**Update the document with final content:**
+
+- Add Executive Summary at the top (after frontmatter)
+- Add Development Environment section
+- Update document status to 'complete'
+- Update frontmatter with all steps completed
+
+**Final frontmatter:**
+
+```yaml
+---
+title: 'Game Architecture'
+project: '{{project_name}}'
+date: '{{date}}'
+author: '{{user_name}}'
+version: '1.0'
+stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+status: 'complete'
+engine: '{{engine}}'
+platform: '{{platform}}'
+---
+````
+
+### 4. Present Completion Summary
+
+"**Architecture Complete!**
+
+{{user_name}}, the Game Architecture for **{{game_name}}** is now complete!
+
+**Architecture Summary:**
+
+- **Engine:** {{engine}} v{{version}}
+- **Platform:** {{platform}}
+- **Organization:** {{organization_pattern}}
+- **Decisions Made:** {{decision_count}}
+- **Patterns Defined:** {{pattern_count}}
+
+**Sections Completed:**
+
+1. Project Context
+2. Engine & Framework
+3. Architectural Decisions
+4. Cross-cutting Concerns
+5. Project Structure
+6. Implementation Patterns
+7. Validation
+8. Development Setup
+
+**Document saved to:** `{outputFile}`
+
+Do you want to review or adjust anything before we finalize?"
+
+### 5. Handle Review Requests
+
+**If user wants to review:**
+
+"Which section would you like to review?
+
+1. Executive Summary
+2. Engine & Framework
+3. Architectural Decisions
+4. Cross-cutting Concerns
+5. Project Structure
+6. Implementation Patterns
+7. Validation Summary
+8. Development Setup
+
+Or type 'all' to see the complete document."
+
+**Show requested section and allow edits.**
+
+### 6. Present Next Steps Menu
+
+**After user confirms completion:**
+
+"**Recommended Next Steps for {{game_name}}:**
+
+1. **Initialize Project** - Run the setup commands to create your project
+   - Command: `{{setup_command}}`
+   - This creates the base structure we designed
+
+2. **Create Epics** - Break down GDD into implementation epics
+   - Workflow: `create-epics`
+   - Input: GDD + Architecture
+   - Output: Implementation-ready epic stories
+
+3. **Begin Implementation** - Start coding with AI agents
+   - Each agent will read this architecture
+   - Patterns ensure consistency across all code
+
+**Which would you like to do next?**
+
+1. Review the completed architecture
+2. Proceed to Epic creation workflow
+3. Exit workflow"
+
+### 7. Handle User Selection
+
+Based on user choice:
+
+**If 1 (Review):**
+
+- Present full document or requested section
+- Return to next steps menu
+
+**If 2 (Epic Creation):**
+
+- Confirm architecture is saved
+- Provide handoff guidance for epic workflow
+- Note that architecture document will be input
+
+**If 3 (Exit):**
+
+- Confirm document is saved and complete
+- Exit workflow gracefully
+
+### 8. Provide Handoff Guidance
+
+**For Epic Creation handoff:**
+
+"**Handoff to Epic Creation**
+
+Your architecture is ready to guide epic creation.
+
+**What the Epic workflow will do:**
+
+- Read your architecture document
+- Break GDD features into implementable stories
+- Ensure stories align with architectural patterns
+- Create acceptance criteria referencing architecture
+
+**Architecture inputs that will be used:**
+
+- Project structure for file placement
+- Implementation patterns for code style
+- Cross-cutting concerns for consistency
+- System mapping for story assignment
+
+Ready to proceed to epic creation, or any questions about the architecture?"
+
+---
+
+## CRITICAL STEP COMPLETION NOTE
+
+This is the final step. Ensure:
+
+- Executive summary is generated
+- All content is saved to architecture.md
+- Frontmatter shows all 9 steps completed
+- User has clear actionable next steps
+- Handoff to epic workflow is smooth
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Executive summary synthesizes all content
+- Development setup is complete
+- Document status updated to 'complete'
+- Frontmatter shows all steps completed
+- User has clear next steps
+- Document saved and ready for AI agent consumption
+
+### SYSTEM FAILURE:
+
+- Missing executive summary
+- Incomplete development setup
+- Frontmatter not updated
+- No clear next steps provided
+- User left without actionable guidance
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+---
+
+## Game Architecture Workflow Complete
+
+The Game Architecture workflow transforms a GDD into a comprehensive architecture document through 9 collaborative steps:
+
+1. **Initialize** - Validate readiness, discover input documents
+2. **Context** - Load and understand project requirements
+3. **Starter** - Select engine and starter templates
+4. **Decisions** - Make collaborative architectural decisions
+5. **Cross-cutting** - Define patterns for all systems
+6. **Structure** - Define project organization
+7. **Patterns** - Design implementation patterns
+8. **Validation** - Verify completeness and coherence
+9. **Complete** - Finalize and provide handoff
+
+This step-file architecture ensures consistent, thorough architecture creation with user collaboration at every step.

package/src/modules/bmgd/workflows/3-technical/game-architecture/workflow.md

@@ -0,0 +1,55 @@
+# Game Architecture Workflow
+
+**Collaborative game architecture workflow for AI-agent consistency**
+
+## Overview
+
+This workflow facilitates the creation of a decision-focused game architecture document covering engine selection, systems design, networking, and technical patterns - optimized for game development with AI agents.
+
+## Workflow Structure
+
+The workflow uses a step-file architecture for modular, stateful execution:
+
+1. **Step 1: Initialize** - Validate readiness and discover input documents
+2. **Step 1b: Continue** - Resume existing architecture work
+3. **Step 2: Context** - Load and understand project context from GDD/Epics
+4. **Step 3: Starter** - Discover and evaluate game engine/starter templates
+5. **Step 4: Decisions** - Facilitate collaborative architectural decisions
+6. **Step 5: Cross-cutting** - Address cross-cutting concerns
+7. **Step 6: Structure** - Define project structure and boundaries
+8. **Step 7: Patterns** - Design novel and implementation patterns
+9. **Step 8: Validation** - Validate architectural coherence
+10. **Step 9: Complete** - Final review and workflow completion
+
+## State Tracking
+
+Progress is tracked in the architecture document frontmatter:
+
+```yaml
+stepsCompleted: [1, 2, 3, ...] # Array of completed step numbers
+```
+
+## Starting the Workflow
+
+To begin, load and execute step-01-init.md:
+
+```
+{workflow_path}/steps/step-01-init.md
+```
+
+## Critical Rules
+
+- **NEVER** generate architectural decisions without user input
+- **ALWAYS** verify current versions via web search
+- **NEVER** mention time estimates
+- **ALWAYS** present options and wait for user selection
+- **FOLLOW** the step sequence exactly - no skipping or optimizing
+
+## Agent Role
+
+You are a veteran game architect facilitator:
+
+- Focus on decisions that prevent AI agent conflicts
+- Push for specificity in all technical choices
+- Ensure every epic has architectural support
+- Document patterns that ensure consistent implementation