bmad-method 6.0.0-alpha.2 → 6.0.0-alpha.20

package/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-01-init.md

@@ -0,0 +1,223 @@
+---
+name: 'step-01-init'
+description: 'Initialize the architecture workflow, validate readiness, and discover input documents'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-init.md'
+continueStepFile: '{workflow_path}/steps/step-01b-continue.md'
+nextStepFile: '{workflow_path}/steps/step-02-context.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+templateFile: '{workflow_path}/templates/architecture-template.md'
+
+# Knowledge Bases
+decisionCatalog: '{workflow_path}/decision-catalog.yaml'
+architecturePatterns: '{workflow_path}/architecture-patterns.yaml'
+patternCategories: '{workflow_path}/pattern-categories.csv'
+---
+
+# Step 1: Initialize Architecture Workflow
+
+**Progress: Step 1 of 9** - Next: Project Context
+
+## STEP GOAL:
+
+Validate workflow readiness, check for existing architecture work, discover input documents (GDD, Epics), and initialize the output document with proper frontmatter.
+
+## 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
+- Focus on architectural decisions that prevent AI agent conflicts
+- This is a decision-focused workflow, not an implementation spec
+
+### Step-Specific Rules:
+
+- Check for existing architecture before starting fresh
+- Validate that required input documents exist (GDD at minimum)
+- Initialize document with proper frontmatter for state tracking
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Wait for user confirmation at each checkpoint
+- Update frontmatter `stepsCompleted: [1]` before loading next step
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Check for Existing Architecture
+
+**Search for existing architecture document:**
+
+Look for existing architecture files in {output_folder}:
+
+- `*architecture*.md`
+- `*arch*.md`
+
+**If existing architecture found:**
+
+"I found an existing architecture document: `{{existing_file}}`
+
+**Options:**
+
+1. **Continue** - Resume from where you left off
+2. **Start Fresh** - Begin a new architecture (will overwrite)
+3. **Review** - Let me review the existing document first
+
+Which would you like to do?"
+
+**Handle user selection:**
+
+- If **Continue**: Load `{continueStepFile}`
+- If **Start Fresh**: Continue with step 2 below
+- If **Review**: Show document summary and return to options
+
+### 2. Discover Required Input Documents
+
+**Search for GDD:**
+
+Look for GDD files using patterns:
+
+- `{output_folder}/*gdd*.md`
+- `{output_folder}/*game-design*.md`
+
+**If GDD not found:**
+
+"**GDD Not Found**
+
+The Architecture workflow works from your Game Design Document (GDD).
+
+The GDD provides:
+
+- Core mechanics and systems to architect
+- Technical requirements and constraints
+- Platform targets and performance needs
+
+Please run the GDD workflow first: `create-gdd`"
+
+**Exit workflow - GDD required**
+
+**If GDD found:**
+
+"**Input Document Found:**
+
+- GDD: `{{gdd_file}}`
+
+I'll analyze this to understand your game's technical requirements."
+
+### 3. Discover Optional Input Documents
+
+**Search for additional documents:**
+
+- **Epics**: `{output_folder}/*epic*.md`
+- **Game Brief**: `{output_folder}/*brief*.md`
+- **Narrative**: `{output_folder}/*narrative*.md`
+
+**Report findings:**
+
+"**Additional Documents Found:**
+{{list_of_found_documents}}
+
+These will provide additional context for architectural decisions."
+
+### 4. Confirm Workflow Start
+
+**Present start confirmation:**
+
+"**Ready to Start Architecture Workflow**
+
+{{user_name}}, I'm ready to help you create the game architecture for your project.
+
+**What we'll cover:**
+
+1. Engine/framework selection and validation
+2. Core architectural decisions (rendering, physics, networking, etc.)
+3. Project structure and code organization
+4. Implementation patterns for AI agent consistency
+5. Cross-cutting concerns (error handling, logging, etc.)
+
+**Input documents:**
+
+- GDD: `{{gdd_file}}`
+  {{additional_documents_list}}
+
+**The goal:** Create an architecture document that ensures all AI agents implement your game consistently.
+
+Ready to begin? [Y/N]"
+
+### 5. Initialize Output Document
+
+**If user confirms, create the initial document:**
+
+Create `{outputFile}` with frontmatter:
+
+```markdown
+---
+title: 'Game Architecture'
+project: '{{project_name}}'
+date: '{{date}}'
+author: '{{user_name}}'
+version: '1.0'
+stepsCompleted: [1]
+status: 'in-progress'
+
+# Source Documents
+gdd: '{{gdd_file}}'
+epics: '{{epics_file_or_null}}'
+brief: '{{brief_file_or_null}}'
+---
+
+# Game Architecture
+
+## Document Status
+
+This architecture document is being created through the BMGD Architecture Workflow.
+
+**Steps Completed:** 1 of 9 (Initialize)
+
+---
+
+_Content will be added as we progress through the workflow._
+```
+
+### 6. Proceed to Context Step
+
+After initialization:
+
+- Update frontmatter: `stepsCompleted: [1]`
+- Load `{nextStepFile}`
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Existing architecture check performed
+- GDD discovered and validated
+- Optional documents discovered
+- User confirmed workflow start
+- Output document initialized with proper frontmatter
+- Frontmatter updated with stepsCompleted: [1]
+
+### SYSTEM FAILURE:
+
+- Skipping input document discovery
+- Starting without user confirmation
+- Not checking for existing architecture
+- Missing frontmatter initialization
+- Proceeding without GDD
+
+**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-01b-continue.md

@@ -0,0 +1,153 @@
+---
+name: 'step-01b-continue'
+description: 'Continue an existing architecture workflow from where it left off'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Step Files (for routing)
+step02: '{workflow_path}/steps/step-02-context.md'
+step03: '{workflow_path}/steps/step-03-starter.md'
+step04: '{workflow_path}/steps/step-04-decisions.md'
+step05: '{workflow_path}/steps/step-05-crosscutting.md'
+step06: '{workflow_path}/steps/step-06-structure.md'
+step07: '{workflow_path}/steps/step-07-patterns.md'
+step08: '{workflow_path}/steps/step-08-validation.md'
+step09: '{workflow_path}/steps/step-09-complete.md'
+---
+
+# Step 1b: Continue Existing Architecture
+
+**Resuming Architecture Workflow**
+
+## STEP GOAL:
+
+Load the existing architecture document, determine progress, and route to the appropriate next step.
+
+## 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
+
+### Step-Specific Rules:
+
+- Parse frontmatter to determine completed steps
+- Present summary of current progress
+- Route to correct next step based on state
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Existing Architecture
+
+**Read the existing architecture document:**
+
+Load `{outputFile}` and parse the frontmatter to extract:
+
+- `stepsCompleted` array
+- `status`
+- `project` name
+- Source document references
+
+### 2. Analyze Progress
+
+**Determine workflow state:**
+
+Map completed steps to workflow progress:
+
+- Step 1: Initialize
+- Step 2: Context
+- Step 3: Starter/Engine
+- Step 4: Decisions
+- Step 5: Cross-cutting
+- Step 6: Structure
+- Step 7: Patterns
+- Step 8: Validation
+- Step 9: Complete
+
+**Calculate next step:**
+
+Find the highest completed step and determine the next step file to load.
+
+### 3. Present Continuation Summary
+
+"**Resuming Architecture Workflow**
+
+{{user_name}}, I found your existing architecture for **{{project_name}}**.
+
+**Progress:** Steps completed: {{stepsCompleted}}
+
+**Current Status:**
+
+- Last completed: {{last_step_name}}
+- Next step: {{next_step_name}} (Step {{next_step_number}} of 9)
+
+**Document sections completed:**
+{{list_of_completed_sections}}
+
+Would you like to:
+
+1. **Continue** - Resume from {{next_step_name}}
+2. **Review** - Show me what we've documented so far
+3. **Restart Step** - Redo the last completed step
+
+Select an option:"
+
+### 4. Handle User Selection
+
+**If Continue:**
+
+- Load the next step file based on `stepsCompleted`
+
+**If Review:**
+
+- Present summary of all completed sections
+- Return to continuation options
+
+**If Restart Step:**
+
+- Decrement stepsCompleted to remove last step
+- Load the step file for the step being restarted
+
+### 5. Route to Next Step
+
+Based on next step number, load the appropriate step file:
+
+| Next Step | File     |
+| --------- | -------- |
+| 2         | {step02} |
+| 3         | {step03} |
+| 4         | {step04} |
+| 5         | {step05} |
+| 6         | {step06} |
+| 7         | {step07} |
+| 8         | {step08} |
+| 9         | {step09} |
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Existing document loaded and parsed
+- Progress accurately determined
+- User presented with clear options
+- Correct step file loaded based on state
+
+### SYSTEM FAILURE:
+
+- Failing to parse frontmatter correctly
+- Loading wrong step file
+- Not presenting continuation options
+- Overwriting existing progress without confirmation
+
+**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-02-context.md

@@ -0,0 +1,262 @@
+---
+name: 'step-02-context'
+description: 'Load and understand project context from GDD and supporting documents'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-02-context.md'
+nextStepFile: '{workflow_path}/steps/step-03-starter.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 2: Project Context
+
+**Progress: Step 2 of 9** - Next: Engine/Starter Selection
+
+## STEP GOAL:
+
+Load and analyze the GDD and supporting documents to understand the game's technical requirements, systems, and constraints that will drive architectural decisions.
+
+## 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
+- Extract technical implications from game design
+- Identify complexity drivers and novel requirements
+
+### Step-Specific Rules:
+
+- Load ALL referenced input documents
+- Identify systems that need architectural support
+- Flag novel concepts requiring special attention
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after context analysis
+- ONLY proceed when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into technical requirements
+- **P (Party Mode)**: Get multiple perspectives on complexity
+- **C (Continue)**: Confirm understanding and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load GDD Document
+
+**Load the full GDD:**
+
+Read the GDD file identified in initialization. Extract:
+
+- Game title and core concept
+- Platform targets
+- Core mechanics and systems
+- Technical requirements section
+- Performance constraints
+- Multiplayer/networking needs
+- Any technical risks identified
+
+### 2. Load Supporting Documents
+
+**Load any available supporting documents:**
+
+- **Epics**: User stories and acceptance criteria
+- **Game Brief**: Vision and scope constraints
+- **Narrative**: Story-driven technical needs
+
+### 3. Analyze Technical Requirements
+
+**Extract and categorize technical needs:**
+
+**Core Systems Identified:**
+
+| System          | Complexity          | GDD Reference |
+| --------------- | ------------------- | ------------- |
+| {{system_name}} | {{low/medium/high}} | {{section}}   |
+
+**Platform Requirements:**
+
+- Primary platform: {{platform}}
+- Secondary platforms: {{if_any}}
+- Cross-platform considerations: {{if_applicable}}
+
+**Performance Constraints:**
+
+- Frame rate target: {{fps}}
+- Resolution support: {{resolutions}}
+- Memory constraints: {{if_specified}}
+- Load time requirements: {{if_specified}}
+
+**Networking Requirements:**
+
+- Multiplayer type: {{none/local/online}}
+- Network architecture: {{p2p/client-server/hybrid}}
+- Sync requirements: {{if_applicable}}
+
+### 4. Identify Complexity Drivers
+
+**Flag areas requiring architectural attention:**
+
+"Based on my analysis, these are the complexity drivers:
+
+**High Complexity:**
+{{list_of_high_complexity_items}}
+
+**Novel Concepts:**
+{{unique_features_without_standard_patterns}}
+
+**Technical Risks:**
+{{risks_from_gdd}}"
+
+### 5. Reflect Understanding
+
+**Present analysis to user:**
+
+"{{user_name}}, I've analyzed the technical requirements for **{{game_name}}**.
+
+**Project Summary:**
+
+- {{core_concept}}
+- Platform: {{platform}}
+- {{key_distinguishing_features}}
+
+**Key Systems Requiring Architecture:**
+
+1. {{system_1}} - {{brief_description}}
+2. {{system_2}} - {{brief_description}}
+3. {{system_3}} - {{brief_description}}
+
+**Complexity Assessment:**
+
+- Overall complexity: {{low/medium/high}}
+- Novel elements: {{count}} requiring custom patterns
+- Critical decisions: {{estimated_count}}
+
+**Technical Constraints:**
+{{summary_of_constraints}}
+
+Does this match your understanding of the project?"
+
+### 6. Generate Context Section
+
+Based on the analysis, prepare the content:
+
+```markdown
+## Project Context
+
+### Game Overview
+
+**{{game_name}}** - {{core_concept}}
+
+### Technical Scope
+
+**Platform:** {{platform}}
+**Genre:** {{genre}}
+**Project Level:** {{complexity_level}}
+
+### Core Systems
+
+{{systems_table}}
+
+### Technical Requirements
+
+{{requirements_summary}}
+
+### Complexity Drivers
+
+{{complexity_analysis}}
+
+### Technical Risks
+
+{{identified_risks}}
+```
+
+### 7. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Project Context section based on my analysis.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 6]
+
+**Validation Check:**
+
+- Have I captured all core systems?
+- Are the complexity assessments accurate?
+- Any technical constraints I missed?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into technical requirements
+[P] Party Mode - Get multiple perspectives on complexity
+[C] Continue - Save this and move to Engine Selection (Step 3 of 9)"
+
+### 8. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Ask user: "Accept these changes? (y/n)"
+- If yes: Update content, return to A/P/C menu
+- If no: Keep original, return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [context content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- GDD fully loaded and analyzed
+- Supporting documents incorporated
+- Systems and complexity identified
+- Technical constraints documented
+- User confirmed understanding accuracy
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2]
+
+### SYSTEM FAILURE:
+
+- Generating analysis without reading documents
+- Missing critical systems from GDD
+- Proceeding without user confirmation
+- Not presenting A/P/C menu after analysis
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.